tree 0f786f8a847b585402409b464bd21fbb03204b5f
parent e9c842348105aa938a710c0139ca7fde3892dcbc
author Tarrin Neal <tarrinneal@gmail.com> 1673635612 -0800
committer GitHub <noreply@github.com> 1673635612 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJjwaccCRBK7hj4Ov3rIwAANyMIAF8SxZRAodmWBu+NTVfJ8JMx
 ZvyfO6Tg7Sr3CdbEc5HNGC1e3JGky/sGCvB3f7p6m3LHvFU2TQvnvLCqGAZK8Csz
 Ih8iTYqEkP9zF6vG3wmx5WJmPl4tO/+x15+GD07Cyb04p3bfSC43lvoPi56JXwJZ
 q8EBNeqv9sOe83AnK2ItHGYPtHU2JKln/qQ+2eLSjJf2bb+P3QqadTofDOfPofUF
 PyUPkXsbqzS7biDgyCgL1hu9AklPHn9EtcI1NgzB3BDPuCm4J52etUBiqMrL4gxS
 5YIrhNo1R8c/EDTE/+5ETPvjYbFuWEBv9jPjsJe5V3bvtr40iZDaUXc91R7gBtY=
 =V6Sb
 -----END PGP SIGNATURE-----
 

[pigeon] Adds StructuredGenerator class and subclasses (#3037)

* Rename generator class to Adapter

* create new generator class and dart subclass

* cpp and dart test gen

* added files

* Adds Generator class to all generators

* adds swift

* Updates tests to use new Adapter naming scheme

* Dart generate methods

* convert all generate functions to use new method

* chagngelog

* remove Generator class fields

* move paths to options

* remove dartTestOptions

* Moves write header to generator class method

* Updates tests to use new generator class

* source -> header

* correct options

* header -> source

* header -> prefix, source -> header

* remove headers from generateTestDart

* changelog

* Nits and combines source and header generators

* renames Adapter to GeneratorAdapter

* Update version number for breaking changes

* nits

* more personal nits

* update tests to match new merged generators

* cleaner header methods

* Fixes dart header bug

* add gen files for clarity

* better field naming

* better field naming

* removed unneeded dart test generator

* Add filetype to generator

* Adds filetype as field to generatorAdapters

* merge

* analyze

* add import method

* re-remove DartTestGenerator

* Moves imports to new method

* adds writeEnum method to generator class

* nits

* assert

* objc enum

* fix code order issues

* add writeDataClass method

* remove writeMainClass from java

* java + kotlin

* remove dead code

* swift

* fix dart test error

* cpp + objc

* objc + cpp

* Move all migrated methods into class

* Creates writeHeader method on Generator classes

* private unique methods and reorder

* changelog

* changelog

* changelog

* changelog

* prologue

* gen

* dart

* java

* kotlin

* swift

* cpp

* objc

* remove unneeded java method

* analyze

* single file gens

* objc

* Cpp

* analyze

* vocab

* vocab

* typo

* less comma

* wrap write methods

* move code from writeGeneralUtilities

* update changelog

* adds open and close namespace and fixes nits

* makes writeEnum optional

* remove unneeded sink

* remove unneeded namespace from guardname

* [indent]

* clean up