From 4806968e243e92c18be2952287779e77058a0d37 Mon Sep 17 00:00:00 2001 From: Dan Goodliffe Date: Fri, 8 Jan 2016 22:22:54 +0000 Subject: Split type specific model parts into their own file. --- slicer/slicer/modelParts.cpp | 50 ---- slicer/slicer/modelParts.h | 471 ------------------------------------- slicer/slicer/modelPartsTypes.cpp | 69 ++++++ slicer/slicer/modelPartsTypes.h | 481 ++++++++++++++++++++++++++++++++++++++ slicer/slicer/parser.cpp | 1 + slicer/slicer/slicer.cpp | 14 -- slicer/test/compilation.cpp | 1 + 7 files changed, 552 insertions(+), 535 deletions(-) create mode 100644 slicer/slicer/modelPartsTypes.cpp create mode 100644 slicer/slicer/modelPartsTypes.h diff --git a/slicer/slicer/modelParts.cpp b/slicer/slicer/modelParts.cpp index d0747e4..12df3af 100644 --- a/slicer/slicer/modelParts.cpp +++ b/slicer/slicer/modelParts.cpp @@ -116,55 +116,5 @@ namespace Slicer { { return false; } - - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "String"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Boolean"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Float"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Double"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Byte"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Short"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Int"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Long"; - - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalString"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalBoolean"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalFloat"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalDouble"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalByte"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalShort"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalInt"; - template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalLong"; - - void ModelPartForSimpleBase::OnEachChild(const ChildHandler &) { } - ChildRefPtr ModelPartForSimpleBase::GetAnonChildRef(const HookFilter &) { return NULL; } - ChildRefPtr ModelPartForSimpleBase::GetChildRef(const std::string &, const HookFilter &) { return NULL; } - bool ModelPartForSimpleBase::HasValue() const { return true; } - ModelPartType ModelPartForSimpleBase::GetType() const { return type; } - ModelPartType ModelPartForSimpleBase::type = mpt_Simple; - - void ModelPartForConvertedBase::OnEachChild(const ChildHandler &) { } - ChildRefPtr ModelPartForConvertedBase::GetAnonChildRef(const HookFilter &) { return NULL; } - ChildRefPtr ModelPartForConvertedBase::GetChildRef(const std::string &, const HookFilter &) { return NULL; } - bool ModelPartForConvertedBase::HasValue() const { return true; } - ModelPartType ModelPartForConvertedBase::GetType() const { return type; } - ModelPartType ModelPartForConvertedBase::type = mpt_Simple; - - ModelPartType ModelPartForComplexBase::GetType() const { return type; } - ModelPartType ModelPartForComplexBase::type = mpt_Complex; - - void ModelPartForEnumBase::OnEachChild(const ChildHandler &) { } - ChildRefPtr ModelPartForEnumBase::GetAnonChildRef(const HookFilter &) { return NULL; } - ChildRefPtr ModelPartForEnumBase::GetChildRef(const std::string &, const HookFilter &) { return NULL; } - bool ModelPartForEnumBase::HasValue() const { return true; } - ModelPartType ModelPartForEnumBase::GetType() const { return type; } - ModelPartType ModelPartForEnumBase::type = mpt_Simple; - - bool ModelPartForSequenceBase::HasValue() const { return true; } - ModelPartType ModelPartForSequenceBase::GetType() const { return type; } - ModelPartType ModelPartForSequenceBase::type = mpt_Sequence; - - bool ModelPartForDictionaryBase::HasValue() const { return true; } - ModelPartType ModelPartForDictionaryBase::GetType() const { return type; } - ModelPartType ModelPartForDictionaryBase::type = mpt_Dictionary; } diff --git a/slicer/slicer/modelParts.h b/slicer/slicer/modelParts.h index 863a72b..73bdff2 100644 --- a/slicer/slicer/modelParts.h +++ b/slicer/slicer/modelParts.h @@ -201,304 +201,6 @@ namespace Slicer { static const std::string & ToModelTypeName(const std::string &); }; - class DLL_PUBLIC ModelPartForSimpleBase : public ModelPart { - public: - virtual void OnEachChild(const ChildHandler &) override; - virtual ChildRefPtr GetAnonChildRef(const HookFilter &) override; - virtual ChildRefPtr GetChildRef(const std::string &, const HookFilter &) override; - virtual bool HasValue() const override; - virtual ModelPartType GetType() const override; - static ModelPartType type; - }; - - template - class DLL_PUBLIC ModelPartForSimple : public ModelPartForSimpleBase { - public: - typedef T element_type; - - ModelPartForSimple(T & h) : - Member(h) - { - } - ModelPartForSimple(T * h) : - Member(*h) - { - } - virtual void SetValue(ValueSourcePtr s) override { s->set(Member); } - virtual void GetValue(ValueTargetPtr s) override { s->get(Member); } - - private: - T & Member; - }; - - class DLL_PUBLIC ModelPartForConvertedBase : public ModelPart { - public: - virtual void OnEachChild(const ChildHandler &) override; - virtual ChildRefPtr GetAnonChildRef(const HookFilter &) override; - virtual ChildRefPtr GetChildRef(const std::string &, const HookFilter &) override; - virtual bool HasValue() const override; - virtual ModelPartType GetType() const override; - static ModelPartType type; - }; - - template - class DLL_PUBLIC ModelPartForConverted : public ModelPartForConvertedBase { - public: - typedef T element_type; - - ModelPartForConverted(T & h) : - Member(h) - { - } - ModelPartForConverted(T * h) : - Member(*h) - { - } - virtual void SetValue(ValueSourcePtr s) override; - virtual void GetValue(ValueTargetPtr s) override; - - private: - T & Member; - }; - - template - class DLL_PUBLIC ModelPartForOptional : public ModelPart { - public: - ModelPartForOptional(IceUtil::Optional< typename T::element_type > & h) : - OptionalMember(h) - { - if (OptionalMember) { - modelPart = new T(*OptionalMember); - } - } - ModelPartForOptional(IceUtil::Optional< typename T::element_type > * h) : - OptionalMember(*h) - { - if (OptionalMember) { - modelPart = new T(*OptionalMember); - } - } - virtual void OnEachChild(const ChildHandler & ch) override - { - if (OptionalMember) { - modelPart->OnEachChild(ch); - } - } - virtual void Complete() override - { - if (OptionalMember) { - modelPart->Complete(); - } - } - virtual void Create() override - { - if (!OptionalMember) { - OptionalMember = typename T::element_type(); - modelPart = new T(*OptionalMember); - modelPart->Create(); - } - } - virtual ChildRefPtr GetAnonChildRef(const HookFilter & flt) override - { - if (OptionalMember) { - return modelPart->GetAnonChildRef(flt); - } - return NULL; - } - virtual ChildRefPtr GetChildRef(const std::string & name, const HookFilter & flt) override - { - if (OptionalMember) { - return modelPart->GetChildRef(name, flt); - } - return NULL; - } - virtual void SetValue(ValueSourcePtr s) override - { - if (OptionalMember) { - modelPart->SetValue(s); - } - } - virtual void GetValue(ValueTargetPtr s) override - { - if (!OptionalMember) { - OptionalMember = typename T::element_type(); - modelPart = new T(*OptionalMember); - } - modelPart->GetValue(s); - } - - virtual bool HasValue() const override { return OptionalMember && modelPart->HasValue(); } - - virtual ModelPartType GetType() const - { - return T::type; - } - - virtual bool IsOptional() const override { return true; }; - - virtual const Metadata & GetMetadata() const override { return modelPart->GetMetadata(); } - - private: - IceUtil::Optional< typename T::element_type > & OptionalMember; - ModelPartPtr modelPart; - }; - - class DLL_PUBLIC ModelPartForComplexBase : public ModelPart { - public: - virtual ModelPartType GetType() const override; - static ModelPartType type; - }; - - template - class DLL_PUBLIC ModelPartForComplex : public ModelPartForComplexBase { - public: - class HookBase : public HookCommon { - public: - virtual ModelPartPtr Get(T * t) const = 0; - }; - typedef IceUtil::Handle HookPtr; - - template - class HookMetadata : public HookBase { - public: - virtual const Metadata & GetMetadata() const override { return metadata; } - - private: - static Metadata metadata; - }; - - template - class Hook : public HookMetadata { - public: - Hook(const std::string & n) : - name(n) - { - } - - ModelPartPtr Get(T * t) const override - { - return t ? new MP(t->*M) : NULL; - } - - std::string PartName() const override - { - return name; - } - - - private: - const std::string name; - }; - - virtual void OnEachChild(const ChildHandler & ch) - { - for (const auto & h : hooks) { - auto modelPart = h->Get(GetModel()); - ch(h->PartName(), modelPart && modelPart->HasValue() ? modelPart : ModelPartPtr(), h); - } - } - - virtual ChildRefPtr GetAnonChildRef(const HookFilter & flt) override - { - for (const auto & h : hooks) { - if (!flt || flt(h)) { - return new MemberChildRef(h->Get(GetModel()), h->GetMetadata()); - } - } - return NULL; - } - ChildRefPtr GetChildRef(const std::string & name, const HookFilter & flt) override - { - for (const auto & h : hooks) { - if (h->PartName() == name && (!flt || flt(h))) { - return new MemberChildRef(h->Get(GetModel()), h->GetMetadata()); - } - } - return NULL; - } - - virtual const Metadata & GetMetadata() const override { return metadata; } - - virtual T * GetModel() = 0; - - typedef std::vector Hooks; - - private: - static Hooks hooks; - static Metadata metadata; - }; - - template - class DLL_PUBLIC ModelPartForClass : public ModelPartForComplex { - public: - typedef T element_type; - - ModelPartForClass(T & h) : - ModelObject(h) - { - } - - ModelPartForClass(T * h) : - ModelObject(*h) - { - } - - virtual void Create() override - { - ModelObject = new typename T::element_type(); - } - - typename T::element_type * GetModel() override - { - return ModelObject.get(); - } - - virtual ModelPartPtr GetSubclassModelPart(const std::string & name) override - { - auto ref = classRefMap()->find(ModelPart::ToModelTypeName(name)); - if (ref == classRefMap()->end()) { - throw UnknownType(name); - } - return ref->second(&this->ModelObject); - } - - virtual bool HasValue() const override { return ModelObject; } - - virtual TypeId GetTypeId() const override; - - virtual IceUtil::Optional GetTypeIdProperty() const override { return typeIdProperty; } - - private: - T & ModelObject; - static std::string typeIdProperty; - }; - - template - class DLL_PUBLIC ModelPartForStruct : public ModelPartForComplex { - public: - typedef T element_type; - - ModelPartForStruct(T & o) : - ModelObject(o) - { - } - - ModelPartForStruct(T * o) : - ModelObject(*o) - { - } - - T * GetModel() override - { - return &ModelObject; - } - - virtual bool HasValue() const override { return true; } - - private: - T & ModelObject; - }; - template class DLL_PUBLIC ModelPartForRoot : public ModelPart { public: @@ -563,179 +265,6 @@ namespace Slicer { ModelPartPtr mp; DLL_PUBLIC static std::string rootName; }; - - class DLL_PUBLIC ModelPartForEnumBase : public ModelPart { - public: - virtual void OnEachChild(const ChildHandler &) override; - ChildRefPtr GetAnonChildRef(const HookFilter &) override; - ChildRefPtr GetChildRef(const std::string &, const HookFilter &) override; - virtual bool HasValue() const override; - virtual ModelPartType GetType() const override; - static ModelPartType type; - }; - - template - class DLL_PUBLIC ModelPartForEnum : public ModelPartForEnumBase { - public: - typedef T element_type; - typedef boost::bimap Enumerations; - - ModelPartForEnum(T & s) : - modelPart(s) - { - } - - ModelPartForEnum(T * s) : - modelPart(*s) - { - } - - virtual const Metadata & GetMetadata() const override { return metadata; } - - virtual void SetValue(ValueSourcePtr s) override; - - virtual void GetValue(ValueTargetPtr s) override; - - private: - T & modelPart; - static Metadata metadata; - static Enumerations enumerations; - }; - - class DLL_PUBLIC ModelPartForSequenceBase : public ModelPart { - public: - virtual bool HasValue() const override; - virtual ModelPartType GetType() const override; - static ModelPartType type; - }; - - template - class DLL_PUBLIC ModelPartForSequence : public ModelPartForSequenceBase { - public: - typedef T element_type; - - ModelPartForSequence(T & s) : - sequence(s) - { - } - - ModelPartForSequence(T * s) : - sequence(*s) - { - } - - virtual void OnEachChild(const ChildHandler & ch) override - { - for(auto & element : sequence) { - ch(elementName, elementModelPart(element), NULL); - } - } - - ChildRefPtr GetAnonChildRef(const HookFilter &) override - { - sequence.push_back(typename element_type::value_type()); - return new ImplicitChildRef(ModelPartFor(sequence.back())); - } - - ChildRefPtr GetChildRef(const std::string &, const HookFilter &) override; - - virtual const Metadata & GetMetadata() const override { return metadata; } - - private: - ModelPartPtr elementModelPart(typename T::value_type &) const; - - T & sequence; - static std::string elementName; - static Metadata metadata; - }; - - template - class DLL_PUBLIC ModelPartForDictionaryElement : public ModelPartForComplex > { - public: - ModelPartForDictionaryElement(typename T::key_type * k, typename T::mapped_type * v) : - key(k), - value(v) - { - } - - ModelPartForDictionaryElement * GetModel() override - { - return this; - } - - virtual bool HasValue() const override { return true; } - - typename T::key_type * key; - typename T::mapped_type * value; - }; - - template - class DLL_PUBLIC ModelPartForDictionaryElementInserter : public ModelPartForDictionaryElement { - public: - ModelPartForDictionaryElementInserter(T & d) : - ModelPartForDictionaryElement(&key, &value), - dictionary(d) - { - } - - virtual void Complete() override { dictionary.insert(typename T::value_type(key, value)); } - - mutable typename T::key_type key; - mutable typename T::mapped_type value; - - private: - T & dictionary; - }; - - class DLL_PUBLIC ModelPartForDictionaryBase : public ModelPart { - public: - virtual bool HasValue() const override; - virtual ModelPartType GetType() const override; - static ModelPartType type; - }; - - template - class DLL_PUBLIC ModelPartForDictionary : public ModelPartForDictionaryBase { - public: - typedef T element_type; - - ModelPartForDictionary(T & d) : - dictionary(d) - { - } - - ModelPartForDictionary(T * d) : - dictionary(*d) - { - } - - virtual void OnEachChild(const ChildHandler & ch) override - { - for (auto & pair : dictionary) { - ch(pairName, new ModelPartForDictionaryElement(const_cast(&pair.first), &pair.second), NULL); - } - } - - ChildRefPtr GetAnonChildRef(const HookFilter &) override - { - return new ImplicitChildRef(new ModelPartForDictionaryElementInserter(dictionary)); - } - - ChildRefPtr GetChildRef(const std::string & name, const HookFilter &) override - { - if (name != pairName) { - throw IncorrectElementName(name); - } - return new ImplicitChildRef(new ModelPartForDictionaryElementInserter(dictionary)); - } - - virtual const Metadata & GetMetadata() const override { return metadata; } - - private: - T & dictionary; - static std::string pairName; - static Metadata metadata; - }; } #endif diff --git a/slicer/slicer/modelPartsTypes.cpp b/slicer/slicer/modelPartsTypes.cpp new file mode 100644 index 0000000..7f07b42 --- /dev/null +++ b/slicer/slicer/modelPartsTypes.cpp @@ -0,0 +1,69 @@ +#include "modelPartsTypes.h" + +namespace Slicer { +#define MODELPARTFOR(Type, ModelPart) \ + ModelPartPtr ModelPartFor(IceUtil::Optional & t) { return new ModelPartForOptional< ModelPart >(t); } \ + ModelPartPtr ModelPartFor(IceUtil::Optional * t) { return new ModelPartForOptional< ModelPart >(t); } \ + ModelPartPtr ModelPartFor(Type & t) { return new ModelPart< Type >(t); } \ + ModelPartPtr ModelPartFor(Type * t) { return new ModelPart< Type >(t); } + MODELPARTFOR(std::string, ModelPartForSimple); + MODELPARTFOR(bool, ModelPartForSimple); + MODELPARTFOR(Ice::Float, ModelPartForSimple); + MODELPARTFOR(Ice::Double, ModelPartForSimple); + MODELPARTFOR(Ice::Byte, ModelPartForSimple); + MODELPARTFOR(Ice::Short, ModelPartForSimple); + MODELPARTFOR(Ice::Int, ModelPartForSimple); + MODELPARTFOR(Ice::Long, ModelPartForSimple); +#undef MODELPARTFOR + + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "String"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Boolean"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Float"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Double"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Byte"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Short"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Int"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot::rootName = "Long"; + + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalString"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalBoolean"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalFloat"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalDouble"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalByte"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalShort"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalInt"; + template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot>::rootName = "OptionalLong"; + + void ModelPartForSimpleBase::OnEachChild(const ChildHandler &) { } + ChildRefPtr ModelPartForSimpleBase::GetAnonChildRef(const HookFilter &) { return NULL; } + ChildRefPtr ModelPartForSimpleBase::GetChildRef(const std::string &, const HookFilter &) { return NULL; } + bool ModelPartForSimpleBase::HasValue() const { return true; } + ModelPartType ModelPartForSimpleBase::GetType() const { return type; } + ModelPartType ModelPartForSimpleBase::type = mpt_Simple; + + void ModelPartForConvertedBase::OnEachChild(const ChildHandler &) { } + ChildRefPtr ModelPartForConvertedBase::GetAnonChildRef(const HookFilter &) { return NULL; } + ChildRefPtr ModelPartForConvertedBase::GetChildRef(const std::string &, const HookFilter &) { return NULL; } + bool ModelPartForConvertedBase::HasValue() const { return true; } + ModelPartType ModelPartForConvertedBase::GetType() const { return type; } + ModelPartType ModelPartForConvertedBase::type = mpt_Simple; + + ModelPartType ModelPartForComplexBase::GetType() const { return type; } + ModelPartType ModelPartForComplexBase::type = mpt_Complex; + + void ModelPartForEnumBase::OnEachChild(const ChildHandler &) { } + ChildRefPtr ModelPartForEnumBase::GetAnonChildRef(const HookFilter &) { return NULL; } + ChildRefPtr ModelPartForEnumBase::GetChildRef(const std::string &, const HookFilter &) { return NULL; } + bool ModelPartForEnumBase::HasValue() const { return true; } + ModelPartType ModelPartForEnumBase::GetType() const { return type; } + ModelPartType ModelPartForEnumBase::type = mpt_Simple; + + bool ModelPartForSequenceBase::HasValue() const { return true; } + ModelPartType ModelPartForSequenceBase::GetType() const { return type; } + ModelPartType ModelPartForSequenceBase::type = mpt_Sequence; + + bool ModelPartForDictionaryBase::HasValue() const { return true; } + ModelPartType ModelPartForDictionaryBase::GetType() const { return type; } + ModelPartType ModelPartForDictionaryBase::type = mpt_Dictionary; +} + diff --git a/slicer/slicer/modelPartsTypes.h b/slicer/slicer/modelPartsTypes.h new file mode 100644 index 0000000..47c08ea --- /dev/null +++ b/slicer/slicer/modelPartsTypes.h @@ -0,0 +1,481 @@ +#ifndef SLICER_MODELPARTSTYPES_H +#define SLICER_MODELPARTSTYPES_H + +#include "modelParts.h" + +namespace Slicer { + class DLL_PUBLIC ModelPartForSimpleBase : public ModelPart { + public: + virtual void OnEachChild(const ChildHandler &) override; + virtual ChildRefPtr GetAnonChildRef(const HookFilter &) override; + virtual ChildRefPtr GetChildRef(const std::string &, const HookFilter &) override; + virtual bool HasValue() const override; + virtual ModelPartType GetType() const override; + static ModelPartType type; + }; + + template + class DLL_PUBLIC ModelPartForSimple : public ModelPartForSimpleBase { + public: + typedef T element_type; + + ModelPartForSimple(T & h) : + Member(h) + { + } + ModelPartForSimple(T * h) : + Member(*h) + { + } + virtual void SetValue(ValueSourcePtr s) override { s->set(Member); } + virtual void GetValue(ValueTargetPtr s) override { s->get(Member); } + + private: + T & Member; + }; + + class DLL_PUBLIC ModelPartForConvertedBase : public ModelPart { + public: + virtual void OnEachChild(const ChildHandler &) override; + virtual ChildRefPtr GetAnonChildRef(const HookFilter &) override; + virtual ChildRefPtr GetChildRef(const std::string &, const HookFilter &) override; + virtual bool HasValue() const override; + virtual ModelPartType GetType() const override; + static ModelPartType type; + }; + + template + class DLL_PUBLIC ModelPartForConverted : public ModelPartForConvertedBase { + public: + typedef T element_type; + + ModelPartForConverted(T & h) : + Member(h) + { + } + ModelPartForConverted(T * h) : + Member(*h) + { + } + virtual void SetValue(ValueSourcePtr s) override; + virtual void GetValue(ValueTargetPtr s) override; + + private: + T & Member; + }; + + template + class DLL_PUBLIC ModelPartForOptional : public ModelPart { + public: + ModelPartForOptional(IceUtil::Optional< typename T::element_type > & h) : + OptionalMember(h) + { + if (OptionalMember) { + modelPart = new T(*OptionalMember); + } + } + ModelPartForOptional(IceUtil::Optional< typename T::element_type > * h) : + OptionalMember(*h) + { + if (OptionalMember) { + modelPart = new T(*OptionalMember); + } + } + virtual void OnEachChild(const ChildHandler & ch) override + { + if (OptionalMember) { + modelPart->OnEachChild(ch); + } + } + virtual void Complete() override + { + if (OptionalMember) { + modelPart->Complete(); + } + } + virtual void Create() override + { + if (!OptionalMember) { + OptionalMember = typename T::element_type(); + modelPart = new T(*OptionalMember); + modelPart->Create(); + } + } + virtual ChildRefPtr GetAnonChildRef(const HookFilter & flt) override + { + if (OptionalMember) { + return modelPart->GetAnonChildRef(flt); + } + return NULL; + } + virtual ChildRefPtr GetChildRef(const std::string & name, const HookFilter & flt) override + { + if (OptionalMember) { + return modelPart->GetChildRef(name, flt); + } + return NULL; + } + virtual void SetValue(ValueSourcePtr s) override + { + if (OptionalMember) { + modelPart->SetValue(s); + } + } + virtual void GetValue(ValueTargetPtr s) override + { + if (!OptionalMember) { + OptionalMember = typename T::element_type(); + modelPart = new T(*OptionalMember); + } + modelPart->GetValue(s); + } + + virtual bool HasValue() const override { return OptionalMember && modelPart->HasValue(); } + + virtual ModelPartType GetType() const + { + return T::type; + } + + virtual bool IsOptional() const override { return true; }; + + virtual const Metadata & GetMetadata() const override { return modelPart->GetMetadata(); } + + private: + IceUtil::Optional< typename T::element_type > & OptionalMember; + ModelPartPtr modelPart; + }; + + class DLL_PUBLIC ModelPartForComplexBase : public ModelPart { + public: + virtual ModelPartType GetType() const override; + static ModelPartType type; + }; + + template + class DLL_PUBLIC ModelPartForComplex : public ModelPartForComplexBase { + public: + class HookBase : public HookCommon { + public: + virtual ModelPartPtr Get(T * t) const = 0; + }; + typedef IceUtil::Handle HookPtr; + + template + class HookMetadata : public HookBase { + public: + virtual const Metadata & GetMetadata() const override { return metadata; } + + private: + static Metadata metadata; + }; + + template + class Hook : public HookMetadata { + public: + Hook(const std::string & n) : + name(n) + { + } + + ModelPartPtr Get(T * t) const override + { + return t ? new MP(t->*M) : NULL; + } + + std::string PartName() const override + { + return name; + } + + + private: + const std::string name; + }; + + virtual void OnEachChild(const ChildHandler & ch) + { + for (const auto & h : hooks) { + auto modelPart = h->Get(GetModel()); + ch(h->PartName(), modelPart && modelPart->HasValue() ? modelPart : ModelPartPtr(), h); + } + } + + virtual ChildRefPtr GetAnonChildRef(const HookFilter & flt) override + { + for (const auto & h : hooks) { + if (!flt || flt(h)) { + return new MemberChildRef(h->Get(GetModel()), h->GetMetadata()); + } + } + return NULL; + } + ChildRefPtr GetChildRef(const std::string & name, const HookFilter & flt) override + { + for (const auto & h : hooks) { + if (h->PartName() == name && (!flt || flt(h))) { + return new MemberChildRef(h->Get(GetModel()), h->GetMetadata()); + } + } + return NULL; + } + + virtual const Metadata & GetMetadata() const override { return metadata; } + + virtual T * GetModel() = 0; + + typedef std::vector Hooks; + + private: + static Hooks hooks; + static Metadata metadata; + }; + + template + class DLL_PUBLIC ModelPartForClass : public ModelPartForComplex { + public: + typedef T element_type; + + ModelPartForClass(T & h) : + ModelObject(h) + { + } + + ModelPartForClass(T * h) : + ModelObject(*h) + { + } + + virtual void Create() override + { + ModelObject = new typename T::element_type(); + } + + typename T::element_type * GetModel() override + { + return ModelObject.get(); + } + + virtual ModelPartPtr GetSubclassModelPart(const std::string & name) override + { + auto ref = classRefMap()->find(ModelPart::ToModelTypeName(name)); + if (ref == classRefMap()->end()) { + throw UnknownType(name); + } + return ref->second(&this->ModelObject); + } + + virtual bool HasValue() const override { return ModelObject; } + + virtual TypeId GetTypeId() const override; + + virtual IceUtil::Optional GetTypeIdProperty() const override { return typeIdProperty; } + + private: + T & ModelObject; + static std::string typeIdProperty; + }; + + template + class DLL_PUBLIC ModelPartForStruct : public ModelPartForComplex { + public: + typedef T element_type; + + ModelPartForStruct(T & o) : + ModelObject(o) + { + } + + ModelPartForStruct(T * o) : + ModelObject(*o) + { + } + + T * GetModel() override + { + return &ModelObject; + } + + virtual bool HasValue() const override { return true; } + + private: + T & ModelObject; + }; + + class DLL_PUBLIC ModelPartForEnumBase : public ModelPart { + public: + virtual void OnEachChild(const ChildHandler &) override; + ChildRefPtr GetAnonChildRef(const HookFilter &) override; + ChildRefPtr GetChildRef(const std::string &, const HookFilter &) override; + virtual bool HasValue() const override; + virtual ModelPartType GetType() const override; + static ModelPartType type; + }; + + template + class DLL_PUBLIC ModelPartForEnum : public ModelPartForEnumBase { + public: + typedef T element_type; + typedef boost::bimap Enumerations; + + ModelPartForEnum(T & s) : + modelPart(s) + { + } + + ModelPartForEnum(T * s) : + modelPart(*s) + { + } + + virtual const Metadata & GetMetadata() const override { return metadata; } + + virtual void SetValue(ValueSourcePtr s) override; + + virtual void GetValue(ValueTargetPtr s) override; + + private: + T & modelPart; + static Metadata metadata; + static Enumerations enumerations; + }; + + class DLL_PUBLIC ModelPartForSequenceBase : public ModelPart { + public: + virtual bool HasValue() const override; + virtual ModelPartType GetType() const override; + static ModelPartType type; + }; + + template + class DLL_PUBLIC ModelPartForSequence : public ModelPartForSequenceBase { + public: + typedef T element_type; + + ModelPartForSequence(T & s) : + sequence(s) + { + } + + ModelPartForSequence(T * s) : + sequence(*s) + { + } + + virtual void OnEachChild(const ChildHandler & ch) override + { + for(auto & element : sequence) { + ch(elementName, elementModelPart(element), NULL); + } + } + + ChildRefPtr GetAnonChildRef(const HookFilter &) override + { + sequence.push_back(typename element_type::value_type()); + return new ImplicitChildRef(ModelPartFor(sequence.back())); + } + + ChildRefPtr GetChildRef(const std::string &, const HookFilter &) override; + + virtual const Metadata & GetMetadata() const override { return metadata; } + + private: + ModelPartPtr elementModelPart(typename T::value_type &) const; + + T & sequence; + static std::string elementName; + static Metadata metadata; + }; + + template + class DLL_PUBLIC ModelPartForDictionaryElement : public ModelPartForComplex > { + public: + ModelPartForDictionaryElement(typename T::key_type * k, typename T::mapped_type * v) : + key(k), + value(v) + { + } + + ModelPartForDictionaryElement * GetModel() override + { + return this; + } + + virtual bool HasValue() const override { return true; } + + typename T::key_type * key; + typename T::mapped_type * value; + }; + + template + class DLL_PUBLIC ModelPartForDictionaryElementInserter : public ModelPartForDictionaryElement { + public: + ModelPartForDictionaryElementInserter(T & d) : + ModelPartForDictionaryElement(&key, &value), + dictionary(d) + { + } + + virtual void Complete() override { dictionary.insert(typename T::value_type(key, value)); } + + mutable typename T::key_type key; + mutable typename T::mapped_type value; + + private: + T & dictionary; + }; + + class DLL_PUBLIC ModelPartForDictionaryBase : public ModelPart { + public: + virtual bool HasValue() const override; + virtual ModelPartType GetType() const override; + static ModelPartType type; + }; + + template + class DLL_PUBLIC ModelPartForDictionary : public ModelPartForDictionaryBase { + public: + typedef T element_type; + + ModelPartForDictionary(T & d) : + dictionary(d) + { + } + + ModelPartForDictionary(T * d) : + dictionary(*d) + { + } + + virtual void OnEachChild(const ChildHandler & ch) override + { + for (auto & pair : dictionary) { + ch(pairName, new ModelPartForDictionaryElement(const_cast(&pair.first), &pair.second), NULL); + } + } + + ChildRefPtr GetAnonChildRef(const HookFilter &) override + { + return new ImplicitChildRef(new ModelPartForDictionaryElementInserter(dictionary)); + } + + ChildRefPtr GetChildRef(const std::string & name, const HookFilter &) override + { + if (name != pairName) { + throw IncorrectElementName(name); + } + return new ImplicitChildRef(new ModelPartForDictionaryElementInserter(dictionary)); + } + + virtual const Metadata & GetMetadata() const override { return metadata; } + + private: + T & dictionary; + static std::string pairName; + static Metadata metadata; + }; + +} + +#endif + diff --git a/slicer/slicer/parser.cpp b/slicer/slicer/parser.cpp index 5ea26b7..757dbbd 100644 --- a/slicer/slicer/parser.cpp +++ b/slicer/slicer/parser.cpp @@ -98,6 +98,7 @@ namespace Slicer { fprintbf(cpp, "// Begin Slicer code\n\n"); fprintbf(cpp, "#include <%s>\n\n", fs::change_extension(topLevelFile.filename(), ".h").string()); fprintbf(cpp, "#include \n\n"); + fprintbf(cpp, "#include \n\n"); fprintbf(cpp, "#define templateMODELPARTFOR(Type, ModelPart) \\\n"); fprintbf(cpp, "template <> ModelPartPtr DLL_PUBLIC ModelPartFor(IceUtil::Optional & t) { return new ModelPartForOptional< ModelPart< Type > >(t); } \\\n"); fprintbf(cpp, "template <> ModelPartPtr DLL_PUBLIC ModelPartFor(IceUtil::Optional * t) { return new ModelPartForOptional< ModelPart< Type > >(t); } \\\n"); diff --git a/slicer/slicer/slicer.cpp b/slicer/slicer/slicer.cpp index b2a531e..c2b6065 100644 --- a/slicer/slicer/slicer.cpp +++ b/slicer/slicer/slicer.cpp @@ -2,20 +2,6 @@ namespace Slicer { const Metadata emptyMetadata; -#define MODELPARTFOR(Type, ModelPart) \ - ModelPartPtr ModelPartFor(IceUtil::Optional & t) { return new ModelPartForOptional< ModelPart >(t); } \ - ModelPartPtr ModelPartFor(IceUtil::Optional * t) { return new ModelPartForOptional< ModelPart >(t); } \ - ModelPartPtr ModelPartFor(Type & t) { return new ModelPart< Type >(t); } \ - ModelPartPtr ModelPartFor(Type * t) { return new ModelPart< Type >(t); } - MODELPARTFOR(std::string, ModelPartForSimple); - MODELPARTFOR(bool, ModelPartForSimple); - MODELPARTFOR(Ice::Float, ModelPartForSimple); - MODELPARTFOR(Ice::Double, ModelPartForSimple); - MODELPARTFOR(Ice::Byte, ModelPartForSimple); - MODELPARTFOR(Ice::Short, ModelPartForSimple); - MODELPARTFOR(Ice::Int, ModelPartForSimple); - MODELPARTFOR(Ice::Long, ModelPartForSimple); -#undef MODELPARTFOR Slicer::MemberChildRef::MemberChildRef(Slicer::ModelPartPtr mp, const Slicer::Metadata & md) : mpp(mp), diff --git a/slicer/test/compilation.cpp b/slicer/test/compilation.cpp index 702b48d..bd869d9 100644 --- a/slicer/test/compilation.cpp +++ b/slicer/test/compilation.cpp @@ -3,6 +3,7 @@ #include #include +#include // LCOV_EXCL_START BOOST_TEST_DONT_PRINT_LOG_VALUE(std::type_info); -- cgit v1.2.3