From ccaff59929097ad9ce92ed696e0f90efd925b564 Mon Sep 17 00:00:00 2001 From: Miguel Company Date: Fri, 13 Sep 2024 12:37:49 +0200 Subject: [PATCH] Refs #21664. Inject factory in all methods called inside `register_builtin_annotations_types`. Signed-off-by: Miguel Company --- .../types/BuiltinAnnotationsTypeObject.h | 258 +-- .../BuiltinAnnotationsTypeObject.cpp | 1534 ++++++++--------- 2 files changed, 896 insertions(+), 896 deletions(-) diff --git a/include/fastrtps/types/BuiltinAnnotationsTypeObject.h b/include/fastrtps/types/BuiltinAnnotationsTypeObject.h index 69364ca5181..3453a34d70e 100644 --- a/include/fastrtps/types/BuiltinAnnotationsTypeObject.h +++ b/include/fastrtps/types/BuiltinAnnotationsTypeObject.h @@ -31,153 +31,153 @@ using namespace eprosima::fastrtps::types; void register_builtin_annotations_types(TypeObjectFactory* factory); -const TypeIdentifier* GetidIdentifier(bool complete = false); -const TypeObject* GetidObject(bool complete = false); -const TypeObject* GetMinimalidObject(); -const TypeObject* GetCompleteidObject(); +const TypeIdentifier* GetidIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetidObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalidObject(TypeObjectFactory* factory); +const TypeObject* GetCompleteidObject(TypeObjectFactory* factory); -const TypeIdentifier* GetautoidIdentifier(bool complete = false); -const TypeObject* GetautoidObject(bool complete = false); -const TypeObject* GetMinimalautoidObject(); -const TypeObject* GetCompleteautoidObject(); +const TypeIdentifier* GetautoidIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetautoidObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalautoidObject(TypeObjectFactory* factory); +const TypeObject* GetCompleteautoidObject(TypeObjectFactory* factory); namespace autoid { - const TypeIdentifier* GetAutoidKindIdentifier(bool complete = false); - const TypeObject* GetAutoidKindObject(bool complete = false); - const TypeObject* GetMinimalAutoidKindObject(); - const TypeObject* GetCompleteAutoidKindObject(); + const TypeIdentifier* GetAutoidKindIdentifier(TypeObjectFactory* factory, bool complete = false); + const TypeObject* GetAutoidKindObject(TypeObjectFactory* factory, bool complete = false); + const TypeObject* GetMinimalAutoidKindObject(TypeObjectFactory* factory); + const TypeObject* GetCompleteAutoidKindObject(TypeObjectFactory* factory); } -const TypeIdentifier* GetoptionalIdentifier(bool complete = false); -const TypeObject* GetoptionalObject(bool complete = false); -const TypeObject* GetMinimaloptionalObject(); -const TypeObject* GetCompleteoptionalObject(); +const TypeIdentifier* GetoptionalIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetoptionalObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimaloptionalObject(TypeObjectFactory* factory); +const TypeObject* GetCompleteoptionalObject(TypeObjectFactory* factory); -const TypeIdentifier* GetpositionIdentifier(bool complete = false); -const TypeObject* GetpositionObject(bool complete = false); -const TypeObject* GetMinimalpositionObject(); -const TypeObject* GetCompletepositionObject(); +const TypeIdentifier* GetpositionIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetpositionObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalpositionObject(TypeObjectFactory* factory); +const TypeObject* GetCompletepositionObject(TypeObjectFactory* factory); -const TypeIdentifier* GetvalueIdentifier(bool complete = false); -const TypeObject* GetvalueObject(bool complete = false); -const TypeObject* GetMinimalvalueObject(); -const TypeObject* GetCompletevalueObject(); +const TypeIdentifier* GetvalueIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetvalueObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalvalueObject(TypeObjectFactory* factory); +const TypeObject* GetCompletevalueObject(TypeObjectFactory* factory); -const TypeIdentifier* GetextensibilityIdentifier(bool complete = false); -const TypeObject* GetextensibilityObject(bool complete = false); -const TypeObject* GetMinimalextensibilityObject(); -const TypeObject* GetCompleteextensibilityObject(); +const TypeIdentifier* GetextensibilityIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetextensibilityObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalextensibilityObject(TypeObjectFactory* factory); +const TypeObject* GetCompleteextensibilityObject(TypeObjectFactory* factory); namespace extensibility { - const TypeIdentifier* GetExtensibilityKindIdentifier(bool complete = false); - const TypeObject* GetExtensibilityKindObject(bool complete = false); - const TypeObject* GetMinimalExtensibilityKindObject(); - const TypeObject* GetCompleteExtensibilityKindObject(); + const TypeIdentifier* GetExtensibilityKindIdentifier(TypeObjectFactory* factory, bool complete = false); + const TypeObject* GetExtensibilityKindObject(TypeObjectFactory* factory, bool complete = false); + const TypeObject* GetMinimalExtensibilityKindObject(TypeObjectFactory* factory); + const TypeObject* GetCompleteExtensibilityKindObject(TypeObjectFactory* factory); } -const TypeIdentifier* GetfinalIdentifier(bool complete = false); -const TypeObject* GetfinalObject(bool complete = false); -const TypeObject* GetMinimalfinalObject(); -const TypeObject* GetCompletefinalObject(); - -const TypeIdentifier* GetappendableIdentifier(bool complete = false); -const TypeObject* GetappendableObject(bool complete = false); -const TypeObject* GetMinimalappendableObject(); -const TypeObject* GetCompleteappendableObject(); - -const TypeIdentifier* GetmutableIdentifier(bool complete = false); -const TypeObject* GetmutableObject(bool complete = false); -const TypeObject* GetMinimalmutableObject(); -const TypeObject* GetCompletemutableObject(); - -const TypeIdentifier* GetkeyIdentifier(bool complete = false); -const TypeObject* GetkeyObject(bool complete = false); -const TypeObject* GetMinimalkeyObject(); -const TypeObject* GetCompletekeyObject(); - -const TypeIdentifier* Getmust_understandIdentifier(bool complete = false); -const TypeObject* Getmust_understandObject(bool complete = false); -const TypeObject* GetMinimalmust_understandObject(); -const TypeObject* GetCompletemust_understandObject(); - -const TypeIdentifier* Getdefault_literalIdentifier(bool complete = false); -const TypeObject* Getdefault_literalObject(bool complete = false); -const TypeObject* GetMinimaldefault_literalObject(); -const TypeObject* GetCompletedefault_literalObject(); - -const TypeIdentifier* GetdefaultIdentifier(bool complete = false); -const TypeObject* GetdefaultObject(bool complete = false); -const TypeObject* GetMinimaldefaultObject(); -const TypeObject* GetCompletedefaultObject(); - -const TypeIdentifier* GetrangeIdentifier(bool complete = false); -const TypeObject* GetrangeObject(bool complete = false); -const TypeObject* GetMinimalrangeObject(); -const TypeObject* GetCompleterangeObject(); - -const TypeIdentifier* GetminIdentifier(bool complete = false); -const TypeObject* GetminObject(bool complete = false); -const TypeObject* GetMinimalminObject(); -const TypeObject* GetCompleteminObject(); - -const TypeIdentifier* GetmaxIdentifier(bool complete = false); -const TypeObject* GetmaxObject(bool complete = false); -const TypeObject* GetMinimalmaxObject(); -const TypeObject* GetCompletemaxObject(); - -const TypeIdentifier* GetunitIdentifier(bool complete = false); -const TypeObject* GetunitObject(bool complete = false); -const TypeObject* GetMinimalunitObject(); -const TypeObject* GetCompleteunitObject(); - -const TypeIdentifier* Getbit_boundIdentifier(bool complete = false); -const TypeObject* Getbit_boundObject(bool complete = false); -const TypeObject* GetMinimalbit_boundObject(); -const TypeObject* GetCompletebit_boundObject(); - -const TypeIdentifier* GetexternalIdentifier(bool complete = false); -const TypeObject* GetexternalObject(bool complete = false); -const TypeObject* GetMinimalexternalObject(); -const TypeObject* GetCompleteexternalObject(); - -const TypeIdentifier* GetnestedIdentifier(bool complete = false); -const TypeObject* GetnestedObject(bool complete = false); -const TypeObject* GetMinimalnestedObject(); -const TypeObject* GetCompletenestedObject(); - -const TypeIdentifier* GetverbatimIdentifier(bool complete = false); -const TypeObject* GetverbatimObject(bool complete = false); -const TypeObject* GetMinimalverbatimObject(); -const TypeObject* GetCompleteverbatimObject(); +const TypeIdentifier* GetfinalIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetfinalObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalfinalObject(TypeObjectFactory* factory); +const TypeObject* GetCompletefinalObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetappendableIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetappendableObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalappendableObject(TypeObjectFactory* factory); +const TypeObject* GetCompleteappendableObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetmutableIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetmutableObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalmutableObject(TypeObjectFactory* factory); +const TypeObject* GetCompletemutableObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetkeyIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetkeyObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalkeyObject(TypeObjectFactory* factory); +const TypeObject* GetCompletekeyObject(TypeObjectFactory* factory); + +const TypeIdentifier* Getmust_understandIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* Getmust_understandObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalmust_understandObject(TypeObjectFactory* factory); +const TypeObject* GetCompletemust_understandObject(TypeObjectFactory* factory); + +const TypeIdentifier* Getdefault_literalIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* Getdefault_literalObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimaldefault_literalObject(TypeObjectFactory* factory); +const TypeObject* GetCompletedefault_literalObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetdefaultIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetdefaultObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimaldefaultObject(TypeObjectFactory* factory); +const TypeObject* GetCompletedefaultObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetrangeIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetrangeObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalrangeObject(TypeObjectFactory* factory); +const TypeObject* GetCompleterangeObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetminIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetminObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalminObject(TypeObjectFactory* factory); +const TypeObject* GetCompleteminObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetmaxIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetmaxObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalmaxObject(TypeObjectFactory* factory); +const TypeObject* GetCompletemaxObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetunitIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetunitObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalunitObject(TypeObjectFactory* factory); +const TypeObject* GetCompleteunitObject(TypeObjectFactory* factory); + +const TypeIdentifier* Getbit_boundIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* Getbit_boundObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalbit_boundObject(TypeObjectFactory* factory); +const TypeObject* GetCompletebit_boundObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetexternalIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetexternalObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalexternalObject(TypeObjectFactory* factory); +const TypeObject* GetCompleteexternalObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetnestedIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetnestedObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalnestedObject(TypeObjectFactory* factory); +const TypeObject* GetCompletenestedObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetverbatimIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetverbatimObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalverbatimObject(TypeObjectFactory* factory); +const TypeObject* GetCompleteverbatimObject(TypeObjectFactory* factory); namespace verbatim { - const TypeIdentifier* GetPlacementKindIdentifier(bool complete = false); - const TypeObject* GetPlacementKindObject(bool complete = false); - const TypeObject* GetMinimalPlacementKindObject(); - const TypeObject* GetCompletePlacementKindObject(); + const TypeIdentifier* GetPlacementKindIdentifier(TypeObjectFactory* factory, bool complete = false); + const TypeObject* GetPlacementKindObject(TypeObjectFactory* factory, bool complete = false); + const TypeObject* GetMinimalPlacementKindObject(TypeObjectFactory* factory); + const TypeObject* GetCompletePlacementKindObject(TypeObjectFactory* factory); } -const TypeIdentifier* GetserviceIdentifier(bool complete = false); -const TypeObject* GetserviceObject(bool complete = false); -const TypeObject* GetMinimalserviceObject(); -const TypeObject* GetCompleteserviceObject(); - -const TypeIdentifier* GetonewayIdentifier(bool complete = false); -const TypeObject* GetonewayObject(bool complete = false); -const TypeObject* GetMinimalonewayObject(); -const TypeObject* GetCompleteonewayObject(); - -const TypeIdentifier* GetamiIdentifier(bool complete = false); -const TypeObject* GetamiObject(bool complete = false); -const TypeObject* GetMinimalamiObject(); -const TypeObject* GetCompleteamiObject(); - -const TypeIdentifier* Getnon_serializedIdentifier(bool complete = false); -const TypeObject* Getnon_serializedObject(bool complete = false); -const TypeObject* GetMinimalnon_serializedObject(); -const TypeObject* GetCompletenon_serializedObject(); +const TypeIdentifier* GetserviceIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetserviceObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalserviceObject(TypeObjectFactory* factory); +const TypeObject* GetCompleteserviceObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetonewayIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetonewayObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalonewayObject(TypeObjectFactory* factory); +const TypeObject* GetCompleteonewayObject(TypeObjectFactory* factory); + +const TypeIdentifier* GetamiIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetamiObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalamiObject(TypeObjectFactory* factory); +const TypeObject* GetCompleteamiObject(TypeObjectFactory* factory); + +const TypeIdentifier* Getnon_serializedIdentifier(TypeObjectFactory* factory, bool complete = false); +const TypeObject* Getnon_serializedObject(TypeObjectFactory* factory, bool complete = false); +const TypeObject* GetMinimalnon_serializedObject(TypeObjectFactory* factory); +const TypeObject* GetCompletenon_serializedObject(TypeObjectFactory* factory); #endif // _BUILTIN_ANNOTATIONS_TYPE_OBJECT_H_ \ No newline at end of file diff --git a/src/cpp/dynamic-types/BuiltinAnnotationsTypeObject.cpp b/src/cpp/dynamic-types/BuiltinAnnotationsTypeObject.cpp index 88b2b673c50..7693c5698d7 100644 --- a/src/cpp/dynamic-types/BuiltinAnnotationsTypeObject.cpp +++ b/src/cpp/dynamic-types/BuiltinAnnotationsTypeObject.cpp @@ -41,152 +41,152 @@ using namespace eprosima::fastrtps::rtps; void register_builtin_annotations_types( TypeObjectFactory* factory) { - factory->add_type_object("id", GetidIdentifier(true), GetidObject(true)); - factory->add_type_object("id", GetidIdentifier(false), GetidObject(false)); + factory->add_type_object("id", GetidIdentifier(factory, true), GetidObject(factory, true)); + factory->add_type_object("id", GetidIdentifier(factory, false), GetidObject(factory, false)); - factory->add_type_object("autoid", GetautoidIdentifier(true), GetautoidObject(true)); - factory->add_type_object("autoid", GetautoidIdentifier(false), GetautoidObject(false)); + factory->add_type_object("autoid", GetautoidIdentifier(factory, true), GetautoidObject(factory, true)); + factory->add_type_object("autoid", GetautoidIdentifier(factory, false), GetautoidObject(factory, false)); { using namespace autoid; - factory->add_type_object("AutoidKind", GetAutoidKindIdentifier(true), GetAutoidKindObject(true)); - factory->add_type_object("AutoidKind", GetAutoidKindIdentifier(false), GetAutoidKindObject(false)); + factory->add_type_object("AutoidKind", GetAutoidKindIdentifier(factory, true), GetAutoidKindObject(factory, true)); + factory->add_type_object("AutoidKind", GetAutoidKindIdentifier(factory, false), GetAutoidKindObject(factory, false)); } - factory->add_type_object("optional", GetoptionalIdentifier(true), GetoptionalObject(true)); - factory->add_type_object("optional", GetoptionalIdentifier(false), GetoptionalObject(false)); + factory->add_type_object("optional", GetoptionalIdentifier(factory, true), GetoptionalObject(factory, true)); + factory->add_type_object("optional", GetoptionalIdentifier(factory, false), GetoptionalObject(factory, false)); - factory->add_type_object("position", GetpositionIdentifier(true), GetpositionObject(true)); - factory->add_type_object("position", GetpositionIdentifier(false), GetpositionObject(false)); + factory->add_type_object("position", GetpositionIdentifier(factory, true), GetpositionObject(factory, true)); + factory->add_type_object("position", GetpositionIdentifier(factory, false), GetpositionObject(factory, false)); - factory->add_type_object("value", GetvalueIdentifier(true), GetvalueObject(true)); - factory->add_type_object("value", GetvalueIdentifier(false), GetvalueObject(false)); + factory->add_type_object("value", GetvalueIdentifier(factory, true), GetvalueObject(factory, true)); + factory->add_type_object("value", GetvalueIdentifier(factory, false), GetvalueObject(factory, false)); - factory->add_type_object("extensibility", GetextensibilityIdentifier(true), GetextensibilityObject(true)); - factory->add_type_object("extensibility", GetextensibilityIdentifier(false), GetextensibilityObject(false)); + factory->add_type_object("extensibility", GetextensibilityIdentifier(factory, true), GetextensibilityObject(factory, true)); + factory->add_type_object("extensibility", GetextensibilityIdentifier(factory, false), GetextensibilityObject(factory, false)); { using namespace extensibility; - factory->add_type_object("ExtensibilityKind", GetExtensibilityKindIdentifier(true), - GetExtensibilityKindObject(true)); - factory->add_type_object("ExtensibilityKind", GetExtensibilityKindIdentifier(false), - GetExtensibilityKindObject(false)); + factory->add_type_object("ExtensibilityKind", GetExtensibilityKindIdentifier(factory, true), + GetExtensibilityKindObject(factory, true)); + factory->add_type_object("ExtensibilityKind", GetExtensibilityKindIdentifier(factory, false), + GetExtensibilityKindObject(factory, false)); } - factory->add_type_object("final", GetfinalIdentifier(true), GetfinalObject(true)); - factory->add_type_object("final", GetfinalIdentifier(false), GetfinalObject(false)); + factory->add_type_object("final", GetfinalIdentifier(factory, true), GetfinalObject(factory, true)); + factory->add_type_object("final", GetfinalIdentifier(factory, false), GetfinalObject(factory, false)); - factory->add_type_object("appendable", GetappendableIdentifier(true), GetappendableObject(true)); - factory->add_type_object("appendable", GetappendableIdentifier(false), GetappendableObject(false)); + factory->add_type_object("appendable", GetappendableIdentifier(factory, true), GetappendableObject(factory, true)); + factory->add_type_object("appendable", GetappendableIdentifier(factory, false), GetappendableObject(factory, false)); - factory->add_type_object("mutable", GetmutableIdentifier(true), GetmutableObject(true)); - factory->add_type_object("mutable", GetmutableIdentifier(false), GetmutableObject(false)); + factory->add_type_object("mutable", GetmutableIdentifier(factory, true), GetmutableObject(factory, true)); + factory->add_type_object("mutable", GetmutableIdentifier(factory, false), GetmutableObject(factory, false)); - factory->add_type_object("key", GetkeyIdentifier(true), GetkeyObject(true)); - factory->add_type_object("key", GetkeyIdentifier(false), GetkeyObject(false)); + factory->add_type_object("key", GetkeyIdentifier(factory, true), GetkeyObject(factory, true)); + factory->add_type_object("key", GetkeyIdentifier(factory, false), GetkeyObject(factory, false)); - factory->add_type_object("Key", GetkeyIdentifier(true), GetkeyObject(true)); - factory->add_type_object("Key", GetkeyIdentifier(false), GetkeyObject(false)); + factory->add_type_object("Key", GetkeyIdentifier(factory, true), GetkeyObject(factory, true)); + factory->add_type_object("Key", GetkeyIdentifier(factory, false), GetkeyObject(factory, false)); - factory->add_type_object("must_understand", Getmust_understandIdentifier(true), Getmust_understandObject(true)); - factory->add_type_object("must_understand", Getmust_understandIdentifier(false), Getmust_understandObject(false)); + factory->add_type_object("must_understand", Getmust_understandIdentifier(factory, true), Getmust_understandObject(factory, true)); + factory->add_type_object("must_understand", Getmust_understandIdentifier(factory, false), Getmust_understandObject(factory, false)); - factory->add_type_object("default_literal", Getdefault_literalIdentifier(true), Getdefault_literalObject(true)); - factory->add_type_object("default_literal", Getdefault_literalIdentifier(false), Getdefault_literalObject(false)); + factory->add_type_object("default_literal", Getdefault_literalIdentifier(factory, true), Getdefault_literalObject(factory, true)); + factory->add_type_object("default_literal", Getdefault_literalIdentifier(factory, false), Getdefault_literalObject(factory, false)); - factory->add_type_object("default", GetdefaultIdentifier(true), GetdefaultObject(true)); - factory->add_type_object("default", GetdefaultIdentifier(false), GetdefaultObject(false)); + factory->add_type_object("default", GetdefaultIdentifier(factory, true), GetdefaultObject(factory, true)); + factory->add_type_object("default", GetdefaultIdentifier(factory, false), GetdefaultObject(factory, false)); - factory->add_type_object("range", GetrangeIdentifier(true), GetrangeObject(true)); - factory->add_type_object("range", GetrangeIdentifier(false), GetrangeObject(false)); + factory->add_type_object("range", GetrangeIdentifier(factory, true), GetrangeObject(factory, true)); + factory->add_type_object("range", GetrangeIdentifier(factory, false), GetrangeObject(factory, false)); - factory->add_type_object("min", GetminIdentifier(true), GetminObject(true)); - factory->add_type_object("min", GetminIdentifier(false), GetminObject(false)); + factory->add_type_object("min", GetminIdentifier(factory, true), GetminObject(factory, true)); + factory->add_type_object("min", GetminIdentifier(factory, false), GetminObject(factory, false)); - factory->add_type_object("max", GetmaxIdentifier(true), GetmaxObject(true)); - factory->add_type_object("max", GetmaxIdentifier(false), GetmaxObject(false)); + factory->add_type_object("max", GetmaxIdentifier(factory, true), GetmaxObject(factory, true)); + factory->add_type_object("max", GetmaxIdentifier(factory, false), GetmaxObject(factory, false)); - factory->add_type_object("unit", GetunitIdentifier(true), GetunitObject(true)); - factory->add_type_object("unit", GetunitIdentifier(false), GetunitObject(false)); + factory->add_type_object("unit", GetunitIdentifier(factory, true), GetunitObject(factory, true)); + factory->add_type_object("unit", GetunitIdentifier(factory, false), GetunitObject(factory, false)); - factory->add_type_object("bit_bound", Getbit_boundIdentifier(true), Getbit_boundObject(true)); - factory->add_type_object("bit_bound", Getbit_boundIdentifier(false), Getbit_boundObject(false)); + factory->add_type_object("bit_bound", Getbit_boundIdentifier(factory, true), Getbit_boundObject(factory, true)); + factory->add_type_object("bit_bound", Getbit_boundIdentifier(factory, false), Getbit_boundObject(factory, false)); - factory->add_type_object("external", GetexternalIdentifier(true), GetexternalObject(true)); - factory->add_type_object("external", GetexternalIdentifier(false), GetexternalObject(false)); + factory->add_type_object("external", GetexternalIdentifier(factory, true), GetexternalObject(factory, true)); + factory->add_type_object("external", GetexternalIdentifier(factory, false), GetexternalObject(factory, false)); - factory->add_type_object("nested", GetnestedIdentifier(true), GetnestedObject(true)); - factory->add_type_object("nested", GetnestedIdentifier(false), GetnestedObject(false)); + factory->add_type_object("nested", GetnestedIdentifier(factory, true), GetnestedObject(factory, true)); + factory->add_type_object("nested", GetnestedIdentifier(factory, false), GetnestedObject(factory, false)); - factory->add_type_object("verbatim", GetverbatimIdentifier(true), GetverbatimObject(true)); - factory->add_type_object("verbatim", GetverbatimIdentifier(false), GetverbatimObject(false)); + factory->add_type_object("verbatim", GetverbatimIdentifier(factory, true), GetverbatimObject(factory, true)); + factory->add_type_object("verbatim", GetverbatimIdentifier(factory, false), GetverbatimObject(factory, false)); { using namespace verbatim; - factory->add_type_object("PlacementKind", GetPlacementKindIdentifier(true), GetPlacementKindObject(true)); - factory->add_type_object("PlacementKind", GetPlacementKindIdentifier(false), GetPlacementKindObject(false)); + factory->add_type_object("PlacementKind", GetPlacementKindIdentifier(factory, true), GetPlacementKindObject(factory, true)); + factory->add_type_object("PlacementKind", GetPlacementKindIdentifier(factory, false), GetPlacementKindObject(factory, false)); } - factory->add_type_object("service", GetserviceIdentifier(true), GetserviceObject(true)); - factory->add_type_object("service", GetserviceIdentifier(false), GetserviceObject(false)); + factory->add_type_object("service", GetserviceIdentifier(factory, true), GetserviceObject(factory, true)); + factory->add_type_object("service", GetserviceIdentifier(factory, false), GetserviceObject(factory, false)); - factory->add_type_object("oneway", GetonewayIdentifier(true), GetonewayObject(true)); - factory->add_type_object("oneway", GetonewayIdentifier(false), GetonewayObject(false)); + factory->add_type_object("oneway", GetonewayIdentifier(factory, true), GetonewayObject(factory, true)); + factory->add_type_object("oneway", GetonewayIdentifier(factory, false), GetonewayObject(factory, false)); - factory->add_type_object("ami", GetamiIdentifier(true), GetamiObject(true)); - factory->add_type_object("ami", GetamiIdentifier(false), GetamiObject(false)); + factory->add_type_object("ami", GetamiIdentifier(factory, true), GetamiObject(factory, true)); + factory->add_type_object("ami", GetamiIdentifier(factory, false), GetamiObject(factory, false)); - factory->add_type_object("non_serialized", Getnon_serializedIdentifier(true), Getnon_serializedObject(true)); - factory->add_type_object("non_serialized", Getnon_serializedIdentifier(false), Getnon_serializedObject(false)); + factory->add_type_object("non_serialized", Getnon_serializedIdentifier(factory, true), Getnon_serializedObject(factory, true)); + factory->add_type_object("non_serialized", Getnon_serializedIdentifier(factory, false), Getnon_serializedObject(factory, false)); } const TypeIdentifier* GetidIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("id", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("id", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetidObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("id", complete); + GetidObject(factory, complete); // Generated inside + return factory->get_type_identifier("id", complete); } const TypeObject* GetidObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("id", complete); + const TypeObject* c_type_object = factory->get_type_object("id", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteidObject(); + return GetCompleteidObject(factory); } // else - return GetMinimalidObject(); + return GetMinimalidObject(factory); } -const TypeObject* GetMinimalidObject() +const TypeObject* GetMinimalidObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("id", false); + const TypeObject* c_type_object = factory->get_type_object("id", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("uint32_t", false)); + mam_value.common().member_type_id(*factory->get_type_identifier("uint32_t", false)); mam_value.name("value"); type_object->minimal().annotation_type().member_seq().emplace_back(mam_value); @@ -214,36 +214,36 @@ const TypeObject* GetMinimalidObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("id", &identifier, type_object); + factory->add_type_object("id", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("id", false); + return factory->get_type_object("id", false); } -const TypeObject* GetCompleteidObject() +const TypeObject* GetCompleteidObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("id", true); + const TypeObject* c_type_object = factory->get_type_object("id", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("id"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("uint32_t", false)); + cam_value.common().member_type_id(*factory->get_type_identifier("uint32_t", false)); cam_value.name("value"); type_object->complete().annotation_type().member_seq().emplace_back(cam_value); @@ -271,55 +271,55 @@ const TypeObject* GetCompleteidObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("id", &identifier, type_object); + factory->add_type_object("id", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("id", true); + return factory->get_type_object("id", true); } const TypeIdentifier* GetautoidIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("autoid", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("autoid", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetautoidObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("autoid", complete); + GetautoidObject(factory, complete); // Generated inside + return factory->get_type_identifier("autoid", complete); } const TypeObject* GetautoidObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("autoid", complete); + const TypeObject* c_type_object = factory->get_type_object("autoid", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteautoidObject(); + return GetCompleteautoidObject(factory); } // else - return GetMinimalautoidObject(); + return GetMinimalautoidObject(factory); } -const TypeObject* GetMinimalautoidObject() +const TypeObject* GetMinimalautoidObject(TypeObjectFactory* factory) { using namespace autoid; - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("autoid", false); + const TypeObject* c_type_object = factory->get_type_object("autoid", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*GetAutoidKindIdentifier(false)); + mam_value.common().member_type_id(*GetAutoidKindIdentifier(factory, false)); mam_value.name("value"); AnnotationParameterValue def_value_value; @@ -351,37 +351,37 @@ const TypeObject* GetMinimalautoidObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("autoid", &identifier, type_object); + factory->add_type_object("autoid", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("autoid", false); + return factory->get_type_object("autoid", false); } -const TypeObject* GetCompleteautoidObject() +const TypeObject* GetCompleteautoidObject(TypeObjectFactory* factory) { using namespace autoid; - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("autoid", true); + const TypeObject* c_type_object = factory->get_type_object("autoid", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("autoid"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*GetAutoidKindIdentifier(true)); + cam_value.common().member_type_id(*GetAutoidKindIdentifier(factory, true)); cam_value.name("value"); AnnotationParameterValue def_value_value; @@ -413,59 +413,59 @@ const TypeObject* GetCompleteautoidObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("autoid", &identifier, type_object); + factory->add_type_object("autoid", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("autoid", true); + return factory->get_type_object("autoid", true); } namespace autoid { const TypeIdentifier* GetAutoidKindIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("AutoidKind", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("AutoidKind", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetAutoidKindObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("AutoidKind", complete); + GetAutoidKindObject(factory, complete); // Generated inside + return factory->get_type_identifier("AutoidKind", complete); } const TypeObject* GetAutoidKindObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("AutoidKind", complete); + const TypeObject* c_type_object = factory->get_type_object("AutoidKind", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteAutoidKindObject(); + return GetCompleteAutoidKindObject(factory); } // else - return GetMinimalAutoidKindObject(); + return GetMinimalAutoidKindObject(factory); } -const TypeObject* GetMinimalAutoidKindObject() +const TypeObject* GetMinimalAutoidKindObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("AutoidKind", false); + const TypeObject* c_type_object = factory->get_type_object("AutoidKind", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ENUM); // No flags apply - //type_object->minimal().enumerated_type().enum_flags().IS_FINAL(false); - //type_object->minimal().enumerated_type().enum_flags().IS_APPENDABLE(false); - //type_object->minimal().enumerated_type().enum_flags().IS_MUTABLE(false); - //type_object->minimal().enumerated_type().enum_flags().IS_NESTED(false); - //type_object->minimal().enumerated_type().enum_flags().IS_AUTOID_HASH(false); + //type_object->minimal().enumerated_type().enum_flags().IS_FINAL(factory, false); + //type_object->minimal().enumerated_type().enum_flags().IS_APPENDABLE(factory, false); + //type_object->minimal().enumerated_type().enum_flags().IS_MUTABLE(factory, false); + //type_object->minimal().enumerated_type().enum_flags().IS_NESTED(factory, false); + //type_object->minimal().enumerated_type().enum_flags().IS_AUTOID_HASH(factory, false); type_object->minimal().enumerated_type().header().common().bit_bound(32); // TODO fixed by IDL, isn't? @@ -525,29 +525,29 @@ const TypeObject* GetMinimalAutoidKindObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("AutoidKind", &identifier, type_object); + factory->add_type_object("AutoidKind", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("AutoidKind", false); + return factory->get_type_object("AutoidKind", false); } -const TypeObject* GetCompleteAutoidKindObject() +const TypeObject* GetCompleteAutoidKindObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("AutoidKind", true); + const TypeObject* c_type_object = factory->get_type_object("AutoidKind", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ENUM); // No flags apply - //type_object->complete().enumerated_type().enum_flags().IS_FINAL(false); - //type_object->complete().enumerated_type().enum_flags().IS_APPENDABLE(false); - //type_object->complete().enumerated_type().enum_flags().IS_MUTABLE(false); - //type_object->complete().enumerated_type().enum_flags().IS_NESTED(false); - //type_object->complete().enumerated_type().enum_flags().IS_AUTOID_HASH(false); + //type_object->complete().enumerated_type().enum_flags().IS_FINAL(factory, false); + //type_object->complete().enumerated_type().enum_flags().IS_APPENDABLE(factory, false); + //type_object->complete().enumerated_type().enum_flags().IS_MUTABLE(factory, false); + //type_object->complete().enumerated_type().enum_flags().IS_NESTED(factory, false); + //type_object->complete().enumerated_type().enum_flags().IS_AUTOID_HASH(factory, false); type_object->complete().enumerated_type().header().common().bit_bound(32); // TODO fixed by IDL, isn't? //type_object->complete().enumerated_type().header().detail().ann_builtin()... @@ -606,55 +606,55 @@ const TypeObject* GetCompleteAutoidKindObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("AutoidKind", &identifier, type_object); + factory->add_type_object("AutoidKind", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("AutoidKind", true); + return factory->get_type_object("AutoidKind", true); } } // autoid namespace const TypeIdentifier* GetoptionalIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("optional", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("optional", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetoptionalObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("optional", complete); + GetoptionalObject(factory, complete); // Generated inside + return factory->get_type_identifier("optional", complete); } const TypeObject* GetoptionalObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("optional", complete); + const TypeObject* c_type_object = factory->get_type_object("optional", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteoptionalObject(); + return GetCompleteoptionalObject(factory); } // else - return GetMinimaloptionalObject(); + return GetMinimaloptionalObject(factory); } -const TypeObject* GetMinimaloptionalObject() +const TypeObject* GetMinimaloptionalObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("optional", false); + const TypeObject* c_type_object = factory->get_type_object("optional", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + mam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); mam_value.name("value"); AnnotationParameterValue def_value_value; @@ -686,36 +686,36 @@ const TypeObject* GetMinimaloptionalObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("optional", &identifier, type_object); + factory->add_type_object("optional", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("optional", false); + return factory->get_type_object("optional", false); } -const TypeObject* GetCompleteoptionalObject() +const TypeObject* GetCompleteoptionalObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("optional", true); + const TypeObject* c_type_object = factory->get_type_object("optional", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("optional"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + cam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); cam_value.name("value"); AnnotationParameterValue def_value_value; @@ -747,54 +747,54 @@ const TypeObject* GetCompleteoptionalObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("optional", &identifier, type_object); + factory->add_type_object("optional", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("optional", true); + return factory->get_type_object("optional", true); } const TypeIdentifier* GetpositionIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("position", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("position", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetpositionObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("position", complete); + GetpositionObject(factory, complete); // Generated inside + return factory->get_type_identifier("position", complete); } const TypeObject* GetpositionObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("position", complete); + const TypeObject* c_type_object = factory->get_type_object("position", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletepositionObject(); + return GetCompletepositionObject(factory); } // else - return GetMinimalpositionObject(); + return GetMinimalpositionObject(factory); } -const TypeObject* GetMinimalpositionObject() +const TypeObject* GetMinimalpositionObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("position", false); + const TypeObject* c_type_object = factory->get_type_object("position", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("uint16_t", false)); + mam_value.common().member_type_id(*factory->get_type_identifier("uint16_t", false)); mam_value.name("value"); type_object->minimal().annotation_type().member_seq().emplace_back(mam_value); @@ -822,36 +822,36 @@ const TypeObject* GetMinimalpositionObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("position", &identifier, type_object); + factory->add_type_object("position", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("position", false); + return factory->get_type_object("position", false); } -const TypeObject* GetCompletepositionObject() +const TypeObject* GetCompletepositionObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("position", true); + const TypeObject* c_type_object = factory->get_type_object("position", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("position"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("uint16_t", false)); + cam_value.common().member_type_id(*factory->get_type_identifier("uint16_t", false)); cam_value.name("value"); type_object->complete().annotation_type().member_seq().emplace_back(cam_value); @@ -879,54 +879,54 @@ const TypeObject* GetCompletepositionObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("position", &identifier, type_object); + factory->add_type_object("position", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("position", true); + return factory->get_type_object("position", true); } const TypeIdentifier* GetvalueIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("value", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("value", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetvalueObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("value", complete); + GetvalueObject(factory, complete); // Generated inside + return factory->get_type_identifier("value", complete); } const TypeObject* GetvalueObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("value", complete); + const TypeObject* c_type_object = factory->get_type_object("value", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletevalueObject(); + return GetCompletevalueObject(factory); } // else - return GetMinimalvalueObject(); + return GetMinimalvalueObject(factory); } -const TypeObject* GetMinimalvalueObject() +const TypeObject* GetMinimalvalueObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("value", false); + const TypeObject* c_type_object = factory->get_type_object("value", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + mam_value.common().member_type_id(*factory->get_string_identifier(255, false)); mam_value.name("value"); type_object->minimal().annotation_type().member_seq().emplace_back(mam_value); @@ -954,36 +954,36 @@ const TypeObject* GetMinimalvalueObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("value", &identifier, type_object); + factory->add_type_object("value", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("value", false); + return factory->get_type_object("value", false); } -const TypeObject* GetCompletevalueObject() +const TypeObject* GetCompletevalueObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("value", true); + const TypeObject* c_type_object = factory->get_type_object("value", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("value"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + cam_value.common().member_type_id(*factory->get_string_identifier(255, false)); cam_value.name("value"); type_object->complete().annotation_type().member_seq().emplace_back(cam_value); @@ -1011,56 +1011,56 @@ const TypeObject* GetCompletevalueObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("value", &identifier, type_object); + factory->add_type_object("value", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("value", true); + return factory->get_type_object("value", true); } const TypeIdentifier* GetextensibilityIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("extensibility", + const TypeIdentifier* c_identifier = factory->get_type_identifier("extensibility", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetextensibilityObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("extensibility", complete); + GetextensibilityObject(factory, complete); // Generated inside + return factory->get_type_identifier("extensibility", complete); } const TypeObject* GetextensibilityObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("extensibility", complete); + const TypeObject* c_type_object = factory->get_type_object("extensibility", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteextensibilityObject(); + return GetCompleteextensibilityObject(factory); } // else - return GetMinimalextensibilityObject(); + return GetMinimalextensibilityObject(factory); } -const TypeObject* GetMinimalextensibilityObject() +const TypeObject* GetMinimalextensibilityObject(TypeObjectFactory* factory) { using namespace extensibility; - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("extensibility", false); + const TypeObject* c_type_object = factory->get_type_object("extensibility", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*GetExtensibilityKindIdentifier(false)); + mam_value.common().member_type_id(*GetExtensibilityKindIdentifier(factory, false)); mam_value.name("value"); type_object->minimal().annotation_type().member_seq().emplace_back(mam_value); @@ -1088,37 +1088,37 @@ const TypeObject* GetMinimalextensibilityObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("extensibility", &identifier, type_object); + factory->add_type_object("extensibility", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("extensibility", false); + return factory->get_type_object("extensibility", false); } -const TypeObject* GetCompleteextensibilityObject() +const TypeObject* GetCompleteextensibilityObject(TypeObjectFactory* factory) { using namespace extensibility; - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("extensibility", true); + const TypeObject* c_type_object = factory->get_type_object("extensibility", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("extensibility"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*GetExtensibilityKindIdentifier(true)); + cam_value.common().member_type_id(*GetExtensibilityKindIdentifier(factory, true)); cam_value.name("value"); type_object->complete().annotation_type().member_seq().emplace_back(cam_value); @@ -1146,60 +1146,60 @@ const TypeObject* GetCompleteextensibilityObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("extensibility", &identifier, type_object); + factory->add_type_object("extensibility", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("extensibility", true); + return factory->get_type_object("extensibility", true); } namespace extensibility { const TypeIdentifier* GetExtensibilityKindIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("ExtensibilityKind", + const TypeIdentifier* c_identifier = factory->get_type_identifier("ExtensibilityKind", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetExtensibilityKindObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("ExtensibilityKind", complete); + GetExtensibilityKindObject(factory, complete); // Generated inside + return factory->get_type_identifier("ExtensibilityKind", complete); } const TypeObject* GetExtensibilityKindObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("ExtensibilityKind", complete); + const TypeObject* c_type_object = factory->get_type_object("ExtensibilityKind", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteExtensibilityKindObject(); + return GetCompleteExtensibilityKindObject(factory); } // else - return GetMinimalExtensibilityKindObject(); + return GetMinimalExtensibilityKindObject(factory); } -const TypeObject* GetMinimalExtensibilityKindObject() +const TypeObject* GetMinimalExtensibilityKindObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("ExtensibilityKind", false); + const TypeObject* c_type_object = factory->get_type_object("ExtensibilityKind", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ENUM); // No flags apply - //type_object->minimal().enumerated_type().enum_flags().IS_FINAL(false); - //type_object->minimal().enumerated_type().enum_flags().IS_APPENDABLE(false); - //type_object->minimal().enumerated_type().enum_flags().IS_MUTABLE(false); - //type_object->minimal().enumerated_type().enum_flags().IS_NESTED(false); - //type_object->minimal().enumerated_type().enum_flags().IS_AUTOID_HASH(false); + //type_object->minimal().enumerated_type().enum_flags().IS_FINAL(factory, false); + //type_object->minimal().enumerated_type().enum_flags().IS_APPENDABLE(factory, false); + //type_object->minimal().enumerated_type().enum_flags().IS_MUTABLE(factory, false); + //type_object->minimal().enumerated_type().enum_flags().IS_NESTED(factory, false); + //type_object->minimal().enumerated_type().enum_flags().IS_AUTOID_HASH(factory, false); type_object->minimal().enumerated_type().header().common().bit_bound(32); // TODO fixed by IDL, isn't? @@ -1275,29 +1275,29 @@ const TypeObject* GetMinimalExtensibilityKindObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("ExtensibilityKind", &identifier, type_object); + factory->add_type_object("ExtensibilityKind", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("ExtensibilityKind", false); + return factory->get_type_object("ExtensibilityKind", false); } -const TypeObject* GetCompleteExtensibilityKindObject() +const TypeObject* GetCompleteExtensibilityKindObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("ExtensibilityKind", true); + const TypeObject* c_type_object = factory->get_type_object("ExtensibilityKind", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ENUM); // No flags apply - //type_object->complete().enumerated_type().enum_flags().IS_FINAL(false); - //type_object->complete().enumerated_type().enum_flags().IS_APPENDABLE(false); - //type_object->complete().enumerated_type().enum_flags().IS_MUTABLE(false); - //type_object->complete().enumerated_type().enum_flags().IS_NESTED(false); - //type_object->complete().enumerated_type().enum_flags().IS_AUTOID_HASH(false); + //type_object->complete().enumerated_type().enum_flags().IS_FINAL(factory, false); + //type_object->complete().enumerated_type().enum_flags().IS_APPENDABLE(factory, false); + //type_object->complete().enumerated_type().enum_flags().IS_MUTABLE(factory, false); + //type_object->complete().enumerated_type().enum_flags().IS_NESTED(factory, false); + //type_object->complete().enumerated_type().enum_flags().IS_AUTOID_HASH(factory, false); type_object->complete().enumerated_type().header().common().bit_bound(32); // TODO fixed by IDL, isn't? //type_object->complete().enumerated_type().header().detail().ann_builtin()... @@ -1370,50 +1370,50 @@ const TypeObject* GetCompleteExtensibilityKindObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("ExtensibilityKind", &identifier, type_object); + factory->add_type_object("ExtensibilityKind", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("ExtensibilityKind", true); + return factory->get_type_object("ExtensibilityKind", true); } } // extensibility namespace const TypeIdentifier* GetfinalIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("final", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("final", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetfinalObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("final", complete); + GetfinalObject(factory, complete); // Generated inside + return factory->get_type_identifier("final", complete); } const TypeObject* GetfinalObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("final", complete); + const TypeObject* c_type_object = factory->get_type_object("final", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletefinalObject(); + return GetCompletefinalObject(factory); } // else - return GetMinimalfinalObject(); + return GetMinimalfinalObject(factory); } -const TypeObject* GetMinimalfinalObject() +const TypeObject* GetMinimalfinalObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("final", false); + const TypeObject* c_type_object = factory->get_type_object("final", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); @@ -1440,29 +1440,29 @@ const TypeObject* GetMinimalfinalObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("final", &identifier, type_object); + factory->add_type_object("final", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("final", false); + return factory->get_type_object("final", false); } -const TypeObject* GetCompletefinalObject() +const TypeObject* GetCompletefinalObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("final", true); + const TypeObject* c_type_object = factory->get_type_object("final", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... @@ -1491,49 +1491,49 @@ const TypeObject* GetCompletefinalObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("final", &identifier, type_object); + factory->add_type_object("final", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("final", true); + return factory->get_type_object("final", true); } const TypeIdentifier* GetappendableIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("appendable", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("appendable", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetappendableObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("appendable", complete); + GetappendableObject(factory, complete); // Generated inside + return factory->get_type_identifier("appendable", complete); } const TypeObject* GetappendableObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("appendable", complete); + const TypeObject* c_type_object = factory->get_type_object("appendable", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteappendableObject(); + return GetCompleteappendableObject(factory); } // else - return GetMinimalappendableObject(); + return GetMinimalappendableObject(factory); } -const TypeObject* GetMinimalappendableObject() +const TypeObject* GetMinimalappendableObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("appendable", false); + const TypeObject* c_type_object = factory->get_type_object("appendable", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); @@ -1560,29 +1560,29 @@ const TypeObject* GetMinimalappendableObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("appendable", &identifier, type_object); + factory->add_type_object("appendable", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("appendable", false); + return factory->get_type_object("appendable", false); } -const TypeObject* GetCompleteappendableObject() +const TypeObject* GetCompleteappendableObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("appendable", true); + const TypeObject* c_type_object = factory->get_type_object("appendable", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... @@ -1611,49 +1611,49 @@ const TypeObject* GetCompleteappendableObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("appendable", &identifier, type_object); + factory->add_type_object("appendable", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("appendable", true); + return factory->get_type_object("appendable", true); } const TypeIdentifier* GetmutableIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("mutable", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("mutable", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetmutableObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("mutable", complete); + GetmutableObject(factory, complete); // Generated inside + return factory->get_type_identifier("mutable", complete); } const TypeObject* GetmutableObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("mutable", complete); + const TypeObject* c_type_object = factory->get_type_object("mutable", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletemutableObject(); + return GetCompletemutableObject(factory); } // else - return GetMinimalmutableObject(); + return GetMinimalmutableObject(factory); } -const TypeObject* GetMinimalmutableObject() +const TypeObject* GetMinimalmutableObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("mutable", false); + const TypeObject* c_type_object = factory->get_type_object("mutable", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); @@ -1680,29 +1680,29 @@ const TypeObject* GetMinimalmutableObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("mutable", &identifier, type_object); + factory->add_type_object("mutable", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("mutable", false); + return factory->get_type_object("mutable", false); } -const TypeObject* GetCompletemutableObject() +const TypeObject* GetCompletemutableObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("mutable", true); + const TypeObject* c_type_object = factory->get_type_object("mutable", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... @@ -1731,54 +1731,54 @@ const TypeObject* GetCompletemutableObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("mutable", &identifier, type_object); + factory->add_type_object("mutable", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("mutable", true); + return factory->get_type_object("mutable", true); } const TypeIdentifier* GetkeyIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("key", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("key", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetkeyObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("key", complete); + GetkeyObject(factory, complete); // Generated inside + return factory->get_type_identifier("key", complete); } const TypeObject* GetkeyObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("key", complete); + const TypeObject* c_type_object = factory->get_type_object("key", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletekeyObject(); + return GetCompletekeyObject(factory); } // else - return GetMinimalkeyObject(); + return GetMinimalkeyObject(factory); } -const TypeObject* GetMinimalkeyObject() +const TypeObject* GetMinimalkeyObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("key", false); + const TypeObject* c_type_object = factory->get_type_object("key", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + mam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); mam_value.name("value"); AnnotationParameterValue def_value_value; @@ -1810,36 +1810,36 @@ const TypeObject* GetMinimalkeyObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("key", &identifier, type_object); + factory->add_type_object("key", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("key", false); + return factory->get_type_object("key", false); } -const TypeObject* GetCompletekeyObject() +const TypeObject* GetCompletekeyObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("key", true); + const TypeObject* c_type_object = factory->get_type_object("key", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("key"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + cam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); cam_value.name("value"); AnnotationParameterValue def_value_value; @@ -1871,55 +1871,55 @@ const TypeObject* GetCompletekeyObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("key", &identifier, type_object); + factory->add_type_object("key", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("key", true); + return factory->get_type_object("key", true); } const TypeIdentifier* Getmust_understandIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("must_understand", + const TypeIdentifier* c_identifier = factory->get_type_identifier("must_understand", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - Getmust_understandObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("must_understand", complete); + Getmust_understandObject(factory, complete); // Generated inside + return factory->get_type_identifier("must_understand", complete); } const TypeObject* Getmust_understandObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("must_understand", complete); + const TypeObject* c_type_object = factory->get_type_object("must_understand", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletemust_understandObject(); + return GetCompletemust_understandObject(factory); } // else - return GetMinimalmust_understandObject(); + return GetMinimalmust_understandObject(factory); } -const TypeObject* GetMinimalmust_understandObject() +const TypeObject* GetMinimalmust_understandObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("must_understand", false); + const TypeObject* c_type_object = factory->get_type_object("must_understand", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + mam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); mam_value.name("value"); AnnotationParameterValue def_value_value; @@ -1951,36 +1951,36 @@ const TypeObject* GetMinimalmust_understandObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("must_understand", &identifier, type_object); + factory->add_type_object("must_understand", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("must_understand", false); + return factory->get_type_object("must_understand", false); } -const TypeObject* GetCompletemust_understandObject() +const TypeObject* GetCompletemust_understandObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("must_understand", true); + const TypeObject* c_type_object = factory->get_type_object("must_understand", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("must_understand"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + cam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); cam_value.name("value"); AnnotationParameterValue def_value_value; @@ -2012,50 +2012,50 @@ const TypeObject* GetCompletemust_understandObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("must_understand", &identifier, type_object); + factory->add_type_object("must_understand", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("must_understand", true); + return factory->get_type_object("must_understand", true); } const TypeIdentifier* Getdefault_literalIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("default_literal", + const TypeIdentifier* c_identifier = factory->get_type_identifier("default_literal", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - Getdefault_literalObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("default_literal", complete); + Getdefault_literalObject(factory, complete); // Generated inside + return factory->get_type_identifier("default_literal", complete); } const TypeObject* Getdefault_literalObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("default_literal", complete); + const TypeObject* c_type_object = factory->get_type_object("default_literal", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletedefault_literalObject(); + return GetCompletedefault_literalObject(factory); } // else - return GetMinimaldefault_literalObject(); + return GetMinimaldefault_literalObject(factory); } -const TypeObject* GetMinimaldefault_literalObject() +const TypeObject* GetMinimaldefault_literalObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("default_literal", false); + const TypeObject* c_type_object = factory->get_type_object("default_literal", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); @@ -2082,29 +2082,29 @@ const TypeObject* GetMinimaldefault_literalObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("default_literal", &identifier, type_object); + factory->add_type_object("default_literal", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("default_literal", false); + return factory->get_type_object("default_literal", false); } -const TypeObject* GetCompletedefault_literalObject() +const TypeObject* GetCompletedefault_literalObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("default_literal", true); + const TypeObject* c_type_object = factory->get_type_object("default_literal", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... @@ -2133,54 +2133,54 @@ const TypeObject* GetCompletedefault_literalObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("default_literal", &identifier, type_object); + factory->add_type_object("default_literal", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("default_literal", true); + return factory->get_type_object("default_literal", true); } const TypeIdentifier* GetdefaultIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("default", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("default", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetdefaultObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("default", complete); + GetdefaultObject(factory, complete); // Generated inside + return factory->get_type_identifier("default", complete); } const TypeObject* GetdefaultObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("default", complete); + const TypeObject* c_type_object = factory->get_type_object("default", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletedefaultObject(); + return GetCompletedefaultObject(factory); } // else - return GetMinimaldefaultObject(); + return GetMinimaldefaultObject(factory); } -const TypeObject* GetMinimaldefaultObject() +const TypeObject* GetMinimaldefaultObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("default", false); + const TypeObject* c_type_object = factory->get_type_object("default", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + mam_value.common().member_type_id(*factory->get_string_identifier(255, false)); mam_value.name("value"); type_object->minimal().annotation_type().member_seq().emplace_back(mam_value); @@ -2208,36 +2208,36 @@ const TypeObject* GetMinimaldefaultObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("default", &identifier, type_object); + factory->add_type_object("default", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("default", false); + return factory->get_type_object("default", false); } -const TypeObject* GetCompletedefaultObject() +const TypeObject* GetCompletedefaultObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("default", true); + const TypeObject* c_type_object = factory->get_type_object("default", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("default"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + cam_value.common().member_type_id(*factory->get_string_identifier(255, false)); cam_value.name("value"); type_object->complete().annotation_type().member_seq().emplace_back(cam_value); @@ -2265,60 +2265,60 @@ const TypeObject* GetCompletedefaultObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("default", &identifier, type_object); + factory->add_type_object("default", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("default", true); + return factory->get_type_object("default", true); } const TypeIdentifier* GetrangeIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("range", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("range", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetrangeObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("range", complete); + GetrangeObject(factory, complete); // Generated inside + return factory->get_type_identifier("range", complete); } const TypeObject* GetrangeObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("range", complete); + const TypeObject* c_type_object = factory->get_type_object("range", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleterangeObject(); + return GetCompleterangeObject(factory); } // else - return GetMinimalrangeObject(); + return GetMinimalrangeObject(factory); } -const TypeObject* GetMinimalrangeObject() +const TypeObject* GetMinimalrangeObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("range", false); + const TypeObject* c_type_object = factory->get_type_object("range", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_min; - mam_min.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + mam_min.common().member_type_id(*factory->get_string_identifier(255, false)); mam_min.name("min"); type_object->minimal().annotation_type().member_seq().emplace_back(mam_min); MinimalAnnotationParameter mam_max; - mam_max.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + mam_max.common().member_type_id(*factory->get_string_identifier(255, false)); mam_max.name("max"); type_object->minimal().annotation_type().member_seq().emplace_back(mam_max); @@ -2346,42 +2346,42 @@ const TypeObject* GetMinimalrangeObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("range", &identifier, type_object); + factory->add_type_object("range", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("range", false); + return factory->get_type_object("range", false); } -const TypeObject* GetCompleterangeObject() +const TypeObject* GetCompleterangeObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("range", true); + const TypeObject* c_type_object = factory->get_type_object("range", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("range"); CompleteAnnotationParameter cam_min; - cam_min.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + cam_min.common().member_type_id(*factory->get_string_identifier(255, false)); cam_min.name("min"); type_object->complete().annotation_type().member_seq().emplace_back(cam_min); CompleteAnnotationParameter cam_max; - cam_max.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + cam_max.common().member_type_id(*factory->get_string_identifier(255, false)); cam_max.name("max"); type_object->complete().annotation_type().member_seq().emplace_back(cam_max); @@ -2409,54 +2409,54 @@ const TypeObject* GetCompleterangeObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("range", &identifier, type_object); + factory->add_type_object("range", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("range", true); + return factory->get_type_object("range", true); } const TypeIdentifier* GetminIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("min", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("min", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetminObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("min", complete); + GetminObject(factory, complete); // Generated inside + return factory->get_type_identifier("min", complete); } const TypeObject* GetminObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("min", complete); + const TypeObject* c_type_object = factory->get_type_object("min", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteminObject(); + return GetCompleteminObject(factory); } // else - return GetMinimalminObject(); + return GetMinimalminObject(factory); } -const TypeObject* GetMinimalminObject() +const TypeObject* GetMinimalminObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("min", false); + const TypeObject* c_type_object = factory->get_type_object("min", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + mam_value.common().member_type_id(*factory->get_string_identifier(255, false)); mam_value.name("value"); type_object->minimal().annotation_type().member_seq().emplace_back(mam_value); @@ -2484,36 +2484,36 @@ const TypeObject* GetMinimalminObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("min", &identifier, type_object); + factory->add_type_object("min", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("min", false); + return factory->get_type_object("min", false); } -const TypeObject* GetCompleteminObject() +const TypeObject* GetCompleteminObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("min", true); + const TypeObject* c_type_object = factory->get_type_object("min", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("min"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + cam_value.common().member_type_id(*factory->get_string_identifier(255, false)); cam_value.name("value"); type_object->complete().annotation_type().member_seq().emplace_back(cam_value); @@ -2541,54 +2541,54 @@ const TypeObject* GetCompleteminObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("min", &identifier, type_object); + factory->add_type_object("min", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("min", true); + return factory->get_type_object("min", true); } const TypeIdentifier* GetmaxIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("max", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("max", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetmaxObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("max", complete); + GetmaxObject(factory, complete); // Generated inside + return factory->get_type_identifier("max", complete); } const TypeObject* GetmaxObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("max", complete); + const TypeObject* c_type_object = factory->get_type_object("max", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletemaxObject(); + return GetCompletemaxObject(factory); } // else - return GetMinimalmaxObject(); + return GetMinimalmaxObject(factory); } -const TypeObject* GetMinimalmaxObject() +const TypeObject* GetMinimalmaxObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("max", false); + const TypeObject* c_type_object = factory->get_type_object("max", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + mam_value.common().member_type_id(*factory->get_string_identifier(255, false)); mam_value.name("value"); type_object->minimal().annotation_type().member_seq().emplace_back(mam_value); @@ -2616,36 +2616,36 @@ const TypeObject* GetMinimalmaxObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("max", &identifier, type_object); + factory->add_type_object("max", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("max", false); + return factory->get_type_object("max", false); } -const TypeObject* GetCompletemaxObject() +const TypeObject* GetCompletemaxObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("max", true); + const TypeObject* c_type_object = factory->get_type_object("max", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("max"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + cam_value.common().member_type_id(*factory->get_string_identifier(255, false)); cam_value.name("value"); type_object->complete().annotation_type().member_seq().emplace_back(cam_value); @@ -2673,54 +2673,54 @@ const TypeObject* GetCompletemaxObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("max", &identifier, type_object); + factory->add_type_object("max", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("max", true); + return factory->get_type_object("max", true); } const TypeIdentifier* GetunitIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("unit", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("unit", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetunitObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("unit", complete); + GetunitObject(factory, complete); // Generated inside + return factory->get_type_identifier("unit", complete); } const TypeObject* GetunitObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("unit", complete); + const TypeObject* c_type_object = factory->get_type_object("unit", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteunitObject(); + return GetCompleteunitObject(factory); } // else - return GetMinimalunitObject(); + return GetMinimalunitObject(factory); } -const TypeObject* GetMinimalunitObject() +const TypeObject* GetMinimalunitObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("unit", false); + const TypeObject* c_type_object = factory->get_type_object("unit", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + mam_value.common().member_type_id(*factory->get_string_identifier(255, false)); mam_value.name("value"); type_object->minimal().annotation_type().member_seq().emplace_back(mam_value); @@ -2748,36 +2748,36 @@ const TypeObject* GetMinimalunitObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("unit", &identifier, type_object); + factory->add_type_object("unit", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("unit", false); + return factory->get_type_object("unit", false); } -const TypeObject* GetCompleteunitObject() +const TypeObject* GetCompleteunitObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("unit", true); + const TypeObject* c_type_object = factory->get_type_object("unit", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("unit"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + cam_value.common().member_type_id(*factory->get_string_identifier(255, false)); cam_value.name("value"); type_object->complete().annotation_type().member_seq().emplace_back(cam_value); @@ -2805,54 +2805,54 @@ const TypeObject* GetCompleteunitObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("unit", &identifier, type_object); + factory->add_type_object("unit", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("unit", true); + return factory->get_type_object("unit", true); } const TypeIdentifier* Getbit_boundIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("bit_bound", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("bit_bound", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - Getbit_boundObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("bit_bound", complete); + Getbit_boundObject(factory, complete); // Generated inside + return factory->get_type_identifier("bit_bound", complete); } const TypeObject* Getbit_boundObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("bit_bound", complete); + const TypeObject* c_type_object = factory->get_type_object("bit_bound", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletebit_boundObject(); + return GetCompletebit_boundObject(factory); } // else - return GetMinimalbit_boundObject(); + return GetMinimalbit_boundObject(factory); } -const TypeObject* GetMinimalbit_boundObject() +const TypeObject* GetMinimalbit_boundObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("bit_bound", false); + const TypeObject* c_type_object = factory->get_type_object("bit_bound", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("uint16_t", false)); + mam_value.common().member_type_id(*factory->get_type_identifier("uint16_t", false)); mam_value.name("value"); type_object->minimal().annotation_type().member_seq().emplace_back(mam_value); @@ -2880,36 +2880,36 @@ const TypeObject* GetMinimalbit_boundObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("bit_bound", &identifier, type_object); + factory->add_type_object("bit_bound", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("bit_bound", false); + return factory->get_type_object("bit_bound", false); } -const TypeObject* GetCompletebit_boundObject() +const TypeObject* GetCompletebit_boundObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("bit_bound", true); + const TypeObject* c_type_object = factory->get_type_object("bit_bound", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("bit_bound"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("uint16_t", false)); + cam_value.common().member_type_id(*factory->get_type_identifier("uint16_t", false)); cam_value.name("value"); type_object->complete().annotation_type().member_seq().emplace_back(cam_value); @@ -2937,54 +2937,54 @@ const TypeObject* GetCompletebit_boundObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("bit_bound", &identifier, type_object); + factory->add_type_object("bit_bound", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("bit_bound", true); + return factory->get_type_object("bit_bound", true); } const TypeIdentifier* GetexternalIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("external", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("external", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetexternalObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("external", complete); + GetexternalObject(factory, complete); // Generated inside + return factory->get_type_identifier("external", complete); } const TypeObject* GetexternalObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("external", complete); + const TypeObject* c_type_object = factory->get_type_object("external", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteexternalObject(); + return GetCompleteexternalObject(factory); } // else - return GetMinimalexternalObject(); + return GetMinimalexternalObject(factory); } -const TypeObject* GetMinimalexternalObject() +const TypeObject* GetMinimalexternalObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("external", false); + const TypeObject* c_type_object = factory->get_type_object("external", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + mam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); mam_value.name("value"); AnnotationParameterValue def_value_value; @@ -3016,36 +3016,36 @@ const TypeObject* GetMinimalexternalObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("external", &identifier, type_object); + factory->add_type_object("external", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("external", false); + return factory->get_type_object("external", false); } -const TypeObject* GetCompleteexternalObject() +const TypeObject* GetCompleteexternalObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("external", true); + const TypeObject* c_type_object = factory->get_type_object("external", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("external"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + cam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); cam_value.name("value"); AnnotationParameterValue def_value_value; @@ -3077,54 +3077,54 @@ const TypeObject* GetCompleteexternalObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("external", &identifier, type_object); + factory->add_type_object("external", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("external", true); + return factory->get_type_object("external", true); } const TypeIdentifier* GetnestedIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("nested", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("nested", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetnestedObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("nested", complete); + GetnestedObject(factory, complete); // Generated inside + return factory->get_type_identifier("nested", complete); } const TypeObject* GetnestedObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("nested", complete); + const TypeObject* c_type_object = factory->get_type_object("nested", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletenestedObject(); + return GetCompletenestedObject(factory); } // else - return GetMinimalnestedObject(); + return GetMinimalnestedObject(factory); } -const TypeObject* GetMinimalnestedObject() +const TypeObject* GetMinimalnestedObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("nested", false); + const TypeObject* c_type_object = factory->get_type_object("nested", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + mam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); mam_value.name("value"); AnnotationParameterValue def_value_value; @@ -3156,36 +3156,36 @@ const TypeObject* GetMinimalnestedObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("nested", &identifier, type_object); + factory->add_type_object("nested", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("nested", false); + return factory->get_type_object("nested", false); } -const TypeObject* GetCompletenestedObject() +const TypeObject* GetCompletenestedObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("nested", true); + const TypeObject* c_type_object = factory->get_type_object("nested", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("nested"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + cam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); cam_value.name("value"); AnnotationParameterValue def_value_value; @@ -3217,55 +3217,55 @@ const TypeObject* GetCompletenestedObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("nested", &identifier, type_object); + factory->add_type_object("nested", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("nested", true); + return factory->get_type_object("nested", true); } const TypeIdentifier* GetverbatimIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("verbatim", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("verbatim", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetverbatimObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("verbatim", complete); + GetverbatimObject(factory, complete); // Generated inside + return factory->get_type_identifier("verbatim", complete); } const TypeObject* GetverbatimObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("verbatim", complete); + const TypeObject* c_type_object = factory->get_type_object("verbatim", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteverbatimObject(); + return GetCompleteverbatimObject(factory); } // else - return GetMinimalverbatimObject(); + return GetMinimalverbatimObject(factory); } -const TypeObject* GetMinimalverbatimObject() +const TypeObject* GetMinimalverbatimObject(TypeObjectFactory* factory) { using namespace verbatim; - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("verbatim", false); + const TypeObject* c_type_object = factory->get_type_object("verbatim", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_language; - mam_language.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + mam_language.common().member_type_id(*factory->get_string_identifier(255, false)); mam_language.name("language"); AnnotationParameterValue def_value_language; @@ -3275,7 +3275,7 @@ const TypeObject* GetMinimalverbatimObject() type_object->minimal().annotation_type().member_seq().emplace_back(mam_language); MinimalAnnotationParameter mam_placement; - mam_placement.common().member_type_id(*GetPlacementKindIdentifier(false)); + mam_placement.common().member_type_id(*GetPlacementKindIdentifier(factory, false)); mam_placement.name("placement"); AnnotationParameterValue def_value_placement; @@ -3285,7 +3285,7 @@ const TypeObject* GetMinimalverbatimObject() type_object->minimal().annotation_type().member_seq().emplace_back(mam_placement); MinimalAnnotationParameter mam_text; - mam_text.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + mam_text.common().member_type_id(*factory->get_string_identifier(255, false)); mam_text.name("text"); type_object->minimal().annotation_type().member_seq().emplace_back(mam_text); @@ -3313,37 +3313,37 @@ const TypeObject* GetMinimalverbatimObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("verbatim", &identifier, type_object); + factory->add_type_object("verbatim", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("verbatim", false); + return factory->get_type_object("verbatim", false); } -const TypeObject* GetCompleteverbatimObject() +const TypeObject* GetCompleteverbatimObject(TypeObjectFactory* factory) { using namespace verbatim; - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("verbatim", true); + const TypeObject* c_type_object = factory->get_type_object("verbatim", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("verbatim"); CompleteAnnotationParameter cam_language; - cam_language.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + cam_language.common().member_type_id(*factory->get_string_identifier(255, false)); cam_language.name("language"); AnnotationParameterValue def_value_language; @@ -3353,7 +3353,7 @@ const TypeObject* GetCompleteverbatimObject() type_object->complete().annotation_type().member_seq().emplace_back(cam_language); CompleteAnnotationParameter cam_placement; - cam_placement.common().member_type_id(*GetPlacementKindIdentifier(true)); + cam_placement.common().member_type_id(*GetPlacementKindIdentifier(factory, true)); cam_placement.name("placement"); AnnotationParameterValue def_value_placement; @@ -3363,7 +3363,7 @@ const TypeObject* GetCompleteverbatimObject() type_object->complete().annotation_type().member_seq().emplace_back(cam_placement); CompleteAnnotationParameter cam_text; - cam_text.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + cam_text.common().member_type_id(*factory->get_string_identifier(255, false)); cam_text.name("text"); type_object->complete().annotation_type().member_seq().emplace_back(cam_text); @@ -3391,60 +3391,60 @@ const TypeObject* GetCompleteverbatimObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("verbatim", &identifier, type_object); + factory->add_type_object("verbatim", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("verbatim", true); + return factory->get_type_object("verbatim", true); } namespace verbatim { const TypeIdentifier* GetPlacementKindIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("PlacementKind", + const TypeIdentifier* c_identifier = factory->get_type_identifier("PlacementKind", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetPlacementKindObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("PlacementKind", complete); + GetPlacementKindObject(factory, complete); // Generated inside + return factory->get_type_identifier("PlacementKind", complete); } const TypeObject* GetPlacementKindObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("PlacementKind", complete); + const TypeObject* c_type_object = factory->get_type_object("PlacementKind", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletePlacementKindObject(); + return GetCompletePlacementKindObject(factory); } // else - return GetMinimalPlacementKindObject(); + return GetMinimalPlacementKindObject(factory); } -const TypeObject* GetMinimalPlacementKindObject() +const TypeObject* GetMinimalPlacementKindObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("PlacementKind", false); + const TypeObject* c_type_object = factory->get_type_object("PlacementKind", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ENUM); // No flags apply - //type_object->minimal().enumerated_type().enum_flags().IS_FINAL(false); - //type_object->minimal().enumerated_type().enum_flags().IS_APPENDABLE(false); - //type_object->minimal().enumerated_type().enum_flags().IS_MUTABLE(false); - //type_object->minimal().enumerated_type().enum_flags().IS_NESTED(false); - //type_object->minimal().enumerated_type().enum_flags().IS_AUTOID_HASH(false); + //type_object->minimal().enumerated_type().enum_flags().IS_FINAL(factory, false); + //type_object->minimal().enumerated_type().enum_flags().IS_APPENDABLE(factory, false); + //type_object->minimal().enumerated_type().enum_flags().IS_MUTABLE(factory, false); + //type_object->minimal().enumerated_type().enum_flags().IS_NESTED(factory, false); + //type_object->minimal().enumerated_type().enum_flags().IS_AUTOID_HASH(factory, false); type_object->minimal().enumerated_type().header().common().bit_bound(32); // TODO fixed by IDL, isn't? @@ -3568,29 +3568,29 @@ const TypeObject* GetMinimalPlacementKindObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("PlacementKind", &identifier, type_object); + factory->add_type_object("PlacementKind", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("PlacementKind", false); + return factory->get_type_object("PlacementKind", false); } -const TypeObject* GetCompletePlacementKindObject() +const TypeObject* GetCompletePlacementKindObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("PlacementKind", true); + const TypeObject* c_type_object = factory->get_type_object("PlacementKind", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ENUM); // No flags apply - //type_object->complete().enumerated_type().enum_flags().IS_FINAL(false); - //type_object->complete().enumerated_type().enum_flags().IS_APPENDABLE(false); - //type_object->complete().enumerated_type().enum_flags().IS_MUTABLE(false); - //type_object->complete().enumerated_type().enum_flags().IS_NESTED(false); - //type_object->complete().enumerated_type().enum_flags().IS_AUTOID_HASH(false); + //type_object->complete().enumerated_type().enum_flags().IS_FINAL(factory, false); + //type_object->complete().enumerated_type().enum_flags().IS_APPENDABLE(factory, false); + //type_object->complete().enumerated_type().enum_flags().IS_MUTABLE(factory, false); + //type_object->complete().enumerated_type().enum_flags().IS_NESTED(factory, false); + //type_object->complete().enumerated_type().enum_flags().IS_AUTOID_HASH(factory, false); type_object->complete().enumerated_type().header().common().bit_bound(32); // TODO fixed by IDL, isn't? //type_object->complete().enumerated_type().header().detail().ann_builtin()... @@ -3705,55 +3705,55 @@ const TypeObject* GetCompletePlacementKindObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("PlacementKind", &identifier, type_object); + factory->add_type_object("PlacementKind", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("PlacementKind", true); + return factory->get_type_object("PlacementKind", true); } } // verbatim namespace const TypeIdentifier* GetserviceIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("service", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("service", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetserviceObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("service", complete); + GetserviceObject(factory, complete); // Generated inside + return factory->get_type_identifier("service", complete); } const TypeObject* GetserviceObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("service", complete); + const TypeObject* c_type_object = factory->get_type_object("service", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteserviceObject(); + return GetCompleteserviceObject(factory); } // else - return GetMinimalserviceObject(); + return GetMinimalserviceObject(factory); } -const TypeObject* GetMinimalserviceObject() +const TypeObject* GetMinimalserviceObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("service", false); + const TypeObject* c_type_object = factory->get_type_object("service", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_platform; - mam_platform.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + mam_platform.common().member_type_id(*factory->get_string_identifier(255, false)); mam_platform.name("platform"); AnnotationParameterValue def_value_platform; @@ -3785,36 +3785,36 @@ const TypeObject* GetMinimalserviceObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("service", &identifier, type_object); + factory->add_type_object("service", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("service", false); + return factory->get_type_object("service", false); } -const TypeObject* GetCompleteserviceObject() +const TypeObject* GetCompleteserviceObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("service", true); + const TypeObject* c_type_object = factory->get_type_object("service", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("service"); CompleteAnnotationParameter cam_platform; - cam_platform.common().member_type_id(*TypeObjectFactory::get_instance()->get_string_identifier(255, false)); + cam_platform.common().member_type_id(*factory->get_string_identifier(255, false)); cam_platform.name("platform"); AnnotationParameterValue def_value_platform; @@ -3846,54 +3846,54 @@ const TypeObject* GetCompleteserviceObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("service", &identifier, type_object); + factory->add_type_object("service", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("service", true); + return factory->get_type_object("service", true); } const TypeIdentifier* GetonewayIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("oneway", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("oneway", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetonewayObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("oneway", complete); + GetonewayObject(factory, complete); // Generated inside + return factory->get_type_identifier("oneway", complete); } const TypeObject* GetonewayObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("oneway", complete); + const TypeObject* c_type_object = factory->get_type_object("oneway", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteonewayObject(); + return GetCompleteonewayObject(factory); } // else - return GetMinimalonewayObject(); + return GetMinimalonewayObject(factory); } -const TypeObject* GetMinimalonewayObject() +const TypeObject* GetMinimalonewayObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("oneway", false); + const TypeObject* c_type_object = factory->get_type_object("oneway", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + mam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); mam_value.name("value"); AnnotationParameterValue def_value_value; @@ -3925,36 +3925,36 @@ const TypeObject* GetMinimalonewayObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("oneway", &identifier, type_object); + factory->add_type_object("oneway", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("oneway", false); + return factory->get_type_object("oneway", false); } -const TypeObject* GetCompleteonewayObject() +const TypeObject* GetCompleteonewayObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("oneway", true); + const TypeObject* c_type_object = factory->get_type_object("oneway", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("oneway"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + cam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); cam_value.name("value"); AnnotationParameterValue def_value_value; @@ -3986,54 +3986,54 @@ const TypeObject* GetCompleteonewayObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("oneway", &identifier, type_object); + factory->add_type_object("oneway", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("oneway", true); + return factory->get_type_object("oneway", true); } const TypeIdentifier* GetamiIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("ami", complete); + const TypeIdentifier* c_identifier = factory->get_type_identifier("ami", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - GetamiObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("ami", complete); + GetamiObject(factory, complete); // Generated inside + return factory->get_type_identifier("ami", complete); } const TypeObject* GetamiObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("ami", complete); + const TypeObject* c_type_object = factory->get_type_object("ami", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompleteamiObject(); + return GetCompleteamiObject(factory); } // else - return GetMinimalamiObject(); + return GetMinimalamiObject(factory); } -const TypeObject* GetMinimalamiObject() +const TypeObject* GetMinimalamiObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("ami", false); + const TypeObject* c_type_object = factory->get_type_object("ami", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + mam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); mam_value.name("value"); AnnotationParameterValue def_value_value; @@ -4065,36 +4065,36 @@ const TypeObject* GetMinimalamiObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("ami", &identifier, type_object); + factory->add_type_object("ami", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("ami", false); + return factory->get_type_object("ami", false); } -const TypeObject* GetCompleteamiObject() +const TypeObject* GetCompleteamiObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("ami", true); + const TypeObject* c_type_object = factory->get_type_object("ami", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("ami"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + cam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); cam_value.name("value"); AnnotationParameterValue def_value_value; @@ -4126,55 +4126,55 @@ const TypeObject* GetCompleteamiObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("ami", &identifier, type_object); + factory->add_type_object("ami", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("ami", true); + return factory->get_type_object("ami", true); } const TypeIdentifier* Getnon_serializedIdentifier( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeIdentifier* c_identifier = TypeObjectFactory::get_instance()->get_type_identifier("non_serialized", + const TypeIdentifier* c_identifier = factory->get_type_identifier("non_serialized", complete); if (c_identifier != nullptr && (!complete || c_identifier->_d() == EK_COMPLETE)) { return c_identifier; } - Getnon_serializedObject(complete); // Generated inside - return TypeObjectFactory::get_instance()->get_type_identifier("non_serialized", complete); + Getnon_serializedObject(factory, complete); // Generated inside + return factory->get_type_identifier("non_serialized", complete); } const TypeObject* Getnon_serializedObject( - bool complete) + TypeObjectFactory* factory, bool complete) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("non_serialized", complete); + const TypeObject* c_type_object = factory->get_type_object("non_serialized", complete); if (c_type_object != nullptr) { return c_type_object; } else if (complete) { - return GetCompletenon_serializedObject(); + return GetCompletenon_serializedObject(factory); } // else - return GetMinimalnon_serializedObject(); + return GetMinimalnon_serializedObject(factory); } -const TypeObject* GetMinimalnon_serializedObject() +const TypeObject* GetMinimalnon_serializedObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("non_serialized", false); + const TypeObject* c_type_object = factory->get_type_object("non_serialized", false); if (c_type_object != nullptr) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_MINIMAL); type_object->minimal()._d(TK_ANNOTATION); MinimalAnnotationParameter mam_value; - mam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + mam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); mam_value.name("value"); AnnotationParameterValue def_value_value; @@ -4206,36 +4206,36 @@ const TypeObject* GetMinimalnon_serializedObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("non_serialized", &identifier, type_object); + factory->add_type_object("non_serialized", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("non_serialized", false); + return factory->get_type_object("non_serialized", false); } -const TypeObject* GetCompletenon_serializedObject() +const TypeObject* GetCompletenon_serializedObject(TypeObjectFactory* factory) { - const TypeObject* c_type_object = TypeObjectFactory::get_instance()->get_type_object("non_serialized", true); + const TypeObject* c_type_object = factory->get_type_object("non_serialized", true); if (c_type_object != nullptr && c_type_object->_d() == EK_COMPLETE) { return c_type_object; } - TypeObject* type_object = new TypeObject(); + TypeObject* type_object = new TypeObject () ; type_object->_d(EK_COMPLETE); type_object->complete()._d(TK_ANNOTATION); // No flags apply - //type_object->complete().annotation_type().annotation_flags().IS_FINAL(false); - //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(false); - //type_object->complete().annotation_type().annotation_flags().IS_NESTED(false); - //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(false); + //type_object->complete().annotation_type().annotation_flags().IS_FINAL(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_APPENDABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_MUTABLE(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_NESTED(factory, false); + //type_object->complete().annotation_type().annotation_flags().IS_AUTOID_HASH(factory, false); //type_object->complete().annotation_type().header().detail().ann_builtin()... //type_object->complete().annotation_type().header().detail().ann_custom()... type_object->complete().annotation_type().header().annotation_name("non_serialized"); CompleteAnnotationParameter cam_value; - cam_value.common().member_type_id(*TypeObjectFactory::get_instance()->get_type_identifier("bool", false)); + cam_value.common().member_type_id(*factory->get_type_identifier("bool", false)); cam_value.name("value"); AnnotationParameterValue def_value_value; @@ -4267,7 +4267,7 @@ const TypeObject* GetCompletenon_serializedObject() identifier.equivalence_hash()[i] = objectHash.digest[i]; } - TypeObjectFactory::get_instance()->add_type_object("non_serialized", &identifier, type_object); + factory->add_type_object("non_serialized", &identifier, type_object); delete type_object; - return TypeObjectFactory::get_instance()->get_type_object("non_serialized", true); + return factory->get_type_object("non_serialized", true); }