fom_documents.h File Reference

#include "sen/core/base/compiler_macros.h"
#include "sen/core/lang/stl_resolver.h"
#include "sen/core/meta/callable.h"
#include "sen/core/meta/class_type.h"
#include "sen/core/meta/event.h"
#include "sen/core/meta/method.h"
#include "sen/core/meta/property.h"
#include "sen/core/meta/type.h"
#include "sen/core/meta/type_registry.h"
#include "pugixml.hpp"
#include <array>
#include <cstdint>
#include <filesystem>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

Go to the source code of this file.

Classes
struct	sen::lang::fom::Document
	One document that was read, and the nodes in it that declare something. More...
struct	sen::lang::fom::MappingDocument
	A mapping file and where it was read from, so a refusal can name the file that asked for something the FOM does not have. More...
struct	sen::lang::fom::DocumentTypeSet
	A type set and the path it was built from. One caller resolves a single FOM file by path. More...
struct	sen::lang::fom::Declaration
	One declaring node and the document it came from, so a refusal can name the file. More...
struct	sen::lang::fom::Declarations
	Everything that declares one type. The complete definition owns the type and decides its package; every other declaration adds its members to it. HLA 4 calls this the union over the collective set of modules, and uses the same two words for the two roles. More...
class	sen::lang::fom::FomDocuments
	Reads every document, indexes what each one declares, then builds the types. A type is built on first reference, from every declaration of it rather than only the first, which is what lets a file beside the FOM add members to it. More...

Namespaces
namespace	sen
namespace	sen::lang
namespace	sen::lang::fom

---

Class Documentation

sen::lang::fom::Document

struct sen::lang::fom::Document

One document that was read, and the nodes in it that declare something.

Class Members
path	path
xml_document	xml
xml_node	objectModel
string	name	modelIdentification/name, used to resolve dependency references
string	package	the directory name in lower case
bool	isExtension {}	from the extensions input: adds members, never owns a type
bool	built {}	guards ensureBuilt's recursion
vector< Document * >	dependencies
vector< Document * >	mappingImports	documents a mapping pulled in
vector< xml_node >	classNodes
vector< xml_node >	interactionNodes
CustomTypeRegistry	registry	The types this document owns. They become its type set, so this decides which generated file each type lands in.
vector< ConstTypeHandle<> >	storage

sen::lang::fom::MappingDocument

struct sen::lang::fom::MappingDocument

A mapping file and where it was read from, so a refusal can name the file that asked for something the FOM does not have.

Class Members
path	path
xml_document	xml

sen::lang::fom::DocumentTypeSet

struct sen::lang::fom::DocumentTypeSet

A type set and the path it was built from. One caller resolves a single FOM file by path.

Class Members
path	path
unique_ptr< TypeSet >	typeSet

sen::lang::fom::Declaration

struct sen::lang::fom::Declaration

One declaring node and the document it came from, so a refusal can name the file.

Class Members
xml_node	node
Document *	document {}

sen::lang::fom::Declarations

struct sen::lang::fom::Declarations

Everything that declares one type. The complete definition owns the type and decides its package; every other declaration adds its members to it. HLA 4 calls this the union over the collective set of modules, and uses the same two words for the two roles.

Class Members
vector< Declaration >	all	in the order the documents were read
Document *	owner {}	null when only extensions declare the type
bool	ownerIsComplete {false}	the owner's declaration carries semantics