Generate source code for C++, Rust, Go or Python from a Flatdata schema file
Generates code from a flatdata schema file.
For more information on
flatdata and its implementations, please refer to flatdata's homepage.
# installation pip3 install flatdata-generator # example: generate a header-only C++ library flatdata-generator -s locations.flatdata -g cpp -O locations.hpp
Currently supported target languages:
- Dot (graph of the schema)
- Flatdata (normalized stable schema)
flatdata generator works in several stages which are clearly separated from one another and can be extended/tested in isolation:
Parse the source schema file using
pyparsinglibrary. Grammar for the schema is defined in
Construct a node tree out of
pyparsing.ParseResults. The node tree contains entities for every construct of flatdata grammar, organized in hierarchical order, allowing non-tree references between nodes:
Namespace- Nesting namespaces in the tree is allowed.
Structure- Structures are grouping together a set of fields.
Archive- Archives are grouping together resources and are referencing structures or other archives (see
ResourceBase- All resources derive from
Reference- All references between flatdata entities are modeled with
Referencenodes. All references participate in name resolution. There are two type of references:
RuntimeReference- model explicit references and bound resources that show themselves at runtime.
TypeReference- model type dependencies, which are used during topological sorting at a later stage and for schema resolution.
Augment the tree with structures and references that are not directly corresponding to
pyparsing.ParseResultsor needed to implement advanced features. Among these:
- Add builtin structures if any of the resources require them. For
multivector< N, ... >requires
_builtin.multivector.IndexTypeNto be available.
- Add constant references to all archives so that constants are available for schema resolution.
- Add builtin structures if any of the resources require them. For example,
Resolve references iterates through all references and tries to find a node they refer to, either in:
- Parent scopes until (inclusive) innermost parent namespace.
- Root node if path is fully qualified.
Perform topological sorting to detect cycles in between entities and to determine the order of serialization for targets that depend on one.
Generate the source code using nodes in topological order and/or the tree (depending on the generator architecture - recursive descent or iterative).
Every node of the tree consists of its name, properties (metadata) and holds references to its children. Every node is reachable via certain path which is a dot-joint concatenation of the names of its parents. Node tree enforces several properties of the flatdata schema:
- No conflicting declarations: No two nodes with the same path are allowed.
- All references are correct: All reference nodes are resolvable.
- No cyclic dependencies among resources: All
TypeReferenceparticipate in topological sorting of the DAG formed by the tree edges and edges between source and target of a
Reference names are mangled so they are not ambiguous with other paths
components. For example reference to type
T would have name
and similarly reference to
.foo.bar.T would change to
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
|Filename, size||File type||Python version||Upload date||Hashes|
|Filename, size flatdata-generator-0.3.0.post2.tar.gz (34.6 kB)||File type Source||Python version None||Upload date||Hashes View hashes|
Hashes for flatdata-generator-0.3.0.post2.tar.gz