Internalize all slicer components

7 files changed, 613 insertions, 376 deletions

diff --git a/slicer/slicer/modelParts.h b/slicer/slicer/modelParts.h
index 8cf525a..6f9338d 100644
--- a/slicer/slicer/modelParts.h
+++ b/slicer/slicer/modelParts.h
@@ -121,39 +121,13 @@ namespace Slicer {
 			virtual const Metadata & GetMetadata() const = 0;
 	};
 
-#define templateMODELPARTFOR(Type) \
-	template <class T> ModelPartPtr DLL_PUBLIC ModelPartFor(IceUtil::Optional<Type> & t); \
-	template <class T> ModelPartPtr DLL_PUBLIC ModelPartFor(IceUtil::Optional<Type> * t); \
-	template <class T> ModelPartPtr DLL_PUBLIC ModelPartFor(Type & t); \
-	template <class T> ModelPartPtr DLL_PUBLIC ModelPartFor(Type * t);
-#define MODELPARTFOR(Type) \
-	ModelPartPtr DLL_PUBLIC ModelPartFor(IceUtil::Optional<Type> & t); \
-	ModelPartPtr DLL_PUBLIC ModelPartFor(IceUtil::Optional<Type> * t); \
-	ModelPartPtr DLL_PUBLIC ModelPartFor(Type & t); \
-	ModelPartPtr DLL_PUBLIC ModelPartFor(Type * t);
-	templateMODELPARTFOR(IceInternal::Handle<T>);
-	templateMODELPARTFOR(std::vector<T>);
-	templateMODELPARTFOR(std::list<T>);
-	template <class K, class V> ModelPartPtr DLL_PUBLIC ModelPartFor(std::map<K, V> & t);
-	template <class K, class V> ModelPartPtr DLL_PUBLIC ModelPartFor(std::map<K, V> * t);
-	MODELPARTFOR(std::string);
-	MODELPARTFOR(bool);
-	MODELPARTFOR(Ice::Float);
-	MODELPARTFOR(Ice::Double);
-	MODELPARTFOR(Ice::Byte);
-	MODELPARTFOR(Ice::Short);
-	MODELPARTFOR(Ice::Int);
-	MODELPARTFOR(Ice::Long);
-	templateMODELPARTFOR(T);
-#undef templateMODELPARTFOR
-#undef MODELPARTFOR
-
 	class ChildRef : public IceUtil::Shared {
 		public:
 			virtual ModelPartPtr Child() const = 0;
 			virtual const Metadata & ChildMetaData() const = 0;
 	};
 	typedef IceUtil::Handle<ChildRef> ChildRefPtr;
+
 	class DLL_PUBLIC ImplicitChildRef : public ChildRef {
 		public:
 			ImplicitChildRef(ModelPartPtr);
@@ -164,6 +138,7 @@ namespace Slicer {
 		private:
 			ModelPartPtr mpp;
 	};
+
 	class DLL_PUBLIC MemberChildRef : public ChildRef {
 		public:
 			MemberChildRef(ModelPartPtr, const Metadata &);
@@ -180,6 +155,11 @@ namespace Slicer {
 		public:
 			virtual ~ModelPart() = default;
 
+			template<typename T>
+			static ModelPartPtr CreateFor(T & t);
+			template<typename T>
+			static ModelPartPtr CreateRootFor(T & t);
+
 			virtual void OnEachChild(const ChildHandler &) = 0;
 			ModelPartPtr GetAnonChild(const HookFilter & = HookFilter());
 			ModelPartPtr GetChild(const std::string & memberName, const HookFilter & = HookFilter());
@@ -202,47 +182,21 @@ namespace Slicer {
 	};
 
 	template<typename T>
-	class DLL_PUBLIC ModelPartForRoot : public ModelPart {
+	class ModelPartForRoot : public ModelPart {
 		public:
-			ModelPartForRoot(T & o) :
-				ModelObject(&o),
-				mp(ModelPartFor(*ModelObject))
-			{
-			}
-
-			virtual ChildRefPtr GetAnonChildRef(const HookFilter &) override
-			{
-				mp->Create();
-				return new ImplicitChildRef(mp);
-			}
-
-			virtual ChildRefPtr GetChildRef(const std::string & name, const HookFilter &) override
-			{
-				if (name != rootName) {
-					throw IncorrectElementName(name);
-				}
-				mp->Create();
-				return new ImplicitChildRef(mp);
-			}
-
-			virtual void OnEachChild(const ChildHandler & ch) override
-			{
-				ch(rootName, mp, NULL);
-			}
-
-			virtual bool HasValue() const override { return ModelObject && mp->HasValue(); }
-
-			virtual ModelPartType GetType() const override
-			{
-				return mp->GetType();
-			}
-
-			virtual bool IsOptional() const override { return mp->IsOptional(); }
+			ModelPartForRoot(T & o);
+
+			virtual ChildRefPtr GetAnonChildRef(const HookFilter &) override;
+			virtual ChildRefPtr GetChildRef(const std::string & name, const HookFilter &) override;
+			virtual void OnEachChild(const ChildHandler & ch) override;
+			virtual bool HasValue() const override;
+			virtual ModelPartType GetType() const override;
+			virtual bool IsOptional() const override;
 
 		private:
 			T * ModelObject;
 			ModelPartPtr mp;
-			DLL_PUBLIC static std::string rootName;
+			static std::string rootName;
 	};
 }
 
diff --git a/slicer/slicer/modelPartsTypes.cpp b/slicer/slicer/modelPartsTypes.cpp
index 7f07b42..4540060 100644
--- a/slicer/slicer/modelPartsTypes.cpp
+++ b/slicer/slicer/modelPartsTypes.cpp
@@ -1,11 +1,6 @@
-#include "modelPartsTypes.h"
+#include "modelPartsTypes.impl.h"
 
 namespace Slicer {
-#define MODELPARTFOR(Type, ModelPart) \
-	ModelPartPtr ModelPartFor(IceUtil::Optional<Type> & t) { return new ModelPartForOptional< ModelPart<Type> >(t); } \
-	ModelPartPtr ModelPartFor(IceUtil::Optional<Type> * t) { return new ModelPartForOptional< ModelPart<Type> >(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);
@@ -14,25 +9,42 @@ namespace Slicer {
 	MODELPARTFOR(Ice::Short, ModelPartForSimple);
 	MODELPARTFOR(Ice::Int, ModelPartForSimple);
 	MODELPARTFOR(Ice::Long, ModelPartForSimple);
-#undef MODELPARTFOR
 
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<std::string>::rootName = "String";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<bool>::rootName = "Boolean";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<Ice::Float>::rootName = "Float";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<Ice::Double>::rootName = "Double";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<Ice::Byte>::rootName = "Byte";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<Ice::Short>::rootName = "Short";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<Ice::Int>::rootName = "Int";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<Ice::Long>::rootName = "Long";
+	template<> std::string Slicer::ModelPartForRoot<std::string>::rootName = "String";
+	template<> std::string Slicer::ModelPartForRoot<bool>::rootName = "Boolean";
+	template<> std::string Slicer::ModelPartForRoot<Ice::Float>::rootName = "Float";
+	template<> std::string Slicer::ModelPartForRoot<Ice::Double>::rootName = "Double";
+	template<> std::string Slicer::ModelPartForRoot<Ice::Byte>::rootName = "Byte";
+	template<> std::string Slicer::ModelPartForRoot<Ice::Short>::rootName = "Short";
+	template<> std::string Slicer::ModelPartForRoot<Ice::Int>::rootName = "Int";
+	template<> std::string Slicer::ModelPartForRoot<Ice::Long>::rootName = "Long";
 
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<IceUtil::Optional<std::string>>::rootName = "OptionalString";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<IceUtil::Optional<bool>>::rootName = "OptionalBoolean";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Float>>::rootName = "OptionalFloat";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Double>>::rootName = "OptionalDouble";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Byte>>::rootName = "OptionalByte";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Short>>::rootName = "OptionalShort";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Int>>::rootName = "OptionalInt";
-	template<> DLL_PUBLIC std::string Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Long>>::rootName = "OptionalLong";
+	template<> std::string Slicer::ModelPartForRoot<IceUtil::Optional<std::string>>::rootName = "OptionalString";
+	template<> std::string Slicer::ModelPartForRoot<IceUtil::Optional<bool>>::rootName = "OptionalBoolean";
+	template<> std::string Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Float>>::rootName = "OptionalFloat";
+	template<> std::string Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Double>>::rootName = "OptionalDouble";
+	template<> std::string Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Byte>>::rootName = "OptionalByte";
+	template<> std::string Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Short>>::rootName = "OptionalShort";
+	template<> std::string Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Int>>::rootName = "OptionalInt";
+	template<> std::string Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Long>>::rootName = "OptionalLong";
+
+	template class Slicer::ModelPartForRoot<std::string>;
+	template class Slicer::ModelPartForRoot<bool>;
+	template class Slicer::ModelPartForRoot<Ice::Float>;
+	template class Slicer::ModelPartForRoot<Ice::Double>;
+	template class Slicer::ModelPartForRoot<Ice::Byte>;
+	template class Slicer::ModelPartForRoot<Ice::Short>;
+	template class Slicer::ModelPartForRoot<Ice::Int>;
+	template class Slicer::ModelPartForRoot<Ice::Long>;
+
+	template class Slicer::ModelPartForRoot<IceUtil::Optional<std::string>>;
+	template class Slicer::ModelPartForRoot<IceUtil::Optional<bool>>;
+	template class Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Float>>;
+	template class Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Double>>;
+	template class Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Byte>>;
+	template class Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Short>>;
+	template class Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Int>>;
+	template class Slicer::ModelPartForRoot<IceUtil::Optional<Ice::Long>>;
 
 	void ModelPartForSimpleBase::OnEachChild(const ChildHandler &) { }
 	ChildRefPtr ModelPartForSimpleBase::GetAnonChildRef(const HookFilter &) { return NULL; }
diff --git a/slicer/slicer/modelPartsTypes.h b/slicer/slicer/modelPartsTypes.h
index 47c08ea..02ef8c8 100644
--- a/slicer/slicer/modelPartsTypes.h
+++ b/slicer/slicer/modelPartsTypes.h
@@ -15,20 +15,16 @@ namespace Slicer {
 	};
 
 	template<typename T>
-	class DLL_PUBLIC ModelPartForSimple : public ModelPartForSimpleBase {
+	class 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); }
+			ModelPartForSimple(T & h);
+
+			ModelPartForSimple(T * h);
+
+			virtual void SetValue(ValueSourcePtr s) override;
+			virtual void GetValue(ValueTargetPtr s) override;
 
 		private:
 			T & Member;
@@ -45,18 +41,13 @@ namespace Slicer {
 	};
 
 	template<typename T, typename M, T M::* MV>
-	class DLL_PUBLIC ModelPartForConverted : public ModelPartForConvertedBase {
+	class ModelPartForConverted : public ModelPartForConvertedBase {
 		public:
 			typedef T element_type;
 
-			ModelPartForConverted(T & h) :
-				Member(h)
-			{
-			}
-			ModelPartForConverted(T * h) :
-				Member(*h)
-			{
-			}
+			ModelPartForConverted(T & h);
+
+			ModelPartForConverted(T * h);
 			virtual void SetValue(ValueSourcePtr s) override;
 			virtual void GetValue(ValueTargetPtr s) override;
 
@@ -65,81 +56,25 @@ namespace Slicer {
 	};
 
 	template<typename T>
-	class DLL_PUBLIC ModelPartForOptional : public ModelPart {
+	class 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(); }
+			ModelPartForOptional(IceUtil::Optional< typename T::element_type > & h);
+			ModelPartForOptional(IceUtil::Optional< typename T::element_type > * h);
+			virtual void OnEachChild(const ChildHandler & ch) override;
+			virtual void Complete() override;
+			virtual void Create() override;
+			virtual ChildRefPtr GetAnonChildRef(const HookFilter & flt) override;
+			virtual ChildRefPtr GetChildRef(const std::string & name, const HookFilter & flt) override;
+			virtual void SetValue(ValueSourcePtr s) override;
+			virtual void GetValue(ValueTargetPtr s) override;
+
+			virtual bool HasValue() const override;
+
+			virtual ModelPartType GetType() const;
+
+			virtual bool IsOptional() const override;
+
+			virtual const Metadata & GetMetadata() const override;
 
 		private:
 			IceUtil::Optional< typename T::element_type > & OptionalMember;
@@ -153,7 +88,7 @@ namespace Slicer {
 	};
 
 	template<typename T>
-	class DLL_PUBLIC ModelPartForComplex : public ModelPartForComplexBase {
+	class ModelPartForComplex : public ModelPartForComplexBase {
 		public:
 			class HookBase : public HookCommon {
 				public:
@@ -193,34 +128,12 @@ namespace Slicer {
 					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 void OnEachChild(const ChildHandler & ch);
+
+			virtual ChildRefPtr GetAnonChildRef(const HookFilter & flt) override;
+			ChildRefPtr GetChildRef(const std::string & name, const HookFilter & flt) override;
 
-			virtual const Metadata & GetMetadata() const override { return metadata; }
+			virtual const Metadata & GetMetadata() const override;
 
 			virtual T * GetModel() = 0;
 
@@ -232,44 +145,25 @@ namespace Slicer {
 	};
 
 	template<typename T>
-	class DLL_PUBLIC ModelPartForClass : public ModelPartForComplex<typename T::element_type> {
+	class ModelPartForClass : public ModelPartForComplex<typename T::element_type> {
 		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; }
+			ModelPartForClass(T & h);
+
+			ModelPartForClass(T * h);
+
+			virtual void Create() override;
+
+			typename T::element_type * GetModel() override;
+
+			virtual ModelPartPtr GetSubclassModelPart(const std::string & name) override;
+
+			virtual bool HasValue() const override;
 
 			virtual TypeId GetTypeId() const override;
 
-			virtual IceUtil::Optional<std::string> GetTypeIdProperty() const override { return typeIdProperty; }
+			virtual IceUtil::Optional<std::string> GetTypeIdProperty() const override;
 
 		private:
 			T & ModelObject;
@@ -277,26 +171,17 @@ namespace Slicer {
 	};
 
 	template<typename T>
-	class DLL_PUBLIC ModelPartForStruct : public ModelPartForComplex<T> {
+	class ModelPartForStruct : public ModelPartForComplex<T> {
 		public:
 			typedef T element_type;
 
-			ModelPartForStruct(T & o) :
-				ModelObject(o)
-			{
-			}
+			ModelPartForStruct(T & o);
 
-			ModelPartForStruct(T * o) :
-				ModelObject(*o)
-			{
-			}
+			ModelPartForStruct(T * o);
 
-			T * GetModel() override
-			{
-				return &ModelObject;
-			}
+			T * GetModel() override;
 
-			virtual bool HasValue() const override { return true; }
+			virtual bool HasValue() const override;
 
 		private:
 			T & ModelObject;
@@ -313,22 +198,16 @@ namespace Slicer {
 	};
 
 	template<typename T>
-	class DLL_PUBLIC ModelPartForEnum : public ModelPartForEnumBase {
+	class ModelPartForEnum : public ModelPartForEnumBase {
 		public:
 			typedef T element_type;
 			typedef boost::bimap<T, std::string> Enumerations;
 
-			ModelPartForEnum(T & s) :
-				modelPart(s)
-			{
-			}
+			ModelPartForEnum(T & s);
 
-			ModelPartForEnum(T * s) :
-				modelPart(*s)
-			{
-			}
+			ModelPartForEnum(T * s);
 
-			virtual const Metadata & GetMetadata() const override { return metadata; }
+			virtual const Metadata & GetMetadata() const override;
 
 			virtual void SetValue(ValueSourcePtr s) override;
 
@@ -348,36 +227,21 @@ namespace Slicer {
 	};
 
 	template<typename T>
-	class DLL_PUBLIC ModelPartForSequence : public ModelPartForSequenceBase {
+	class 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()));
-			}
+			ModelPartForSequence(T & s);
+
+			ModelPartForSequence(T * s);
+
+			virtual void OnEachChild(const ChildHandler & ch) override;
+
+			ChildRefPtr GetAnonChildRef(const HookFilter &) override;
 
 			ChildRefPtr GetChildRef(const std::string &, const HookFilter &) override;
 
-			virtual const Metadata & GetMetadata() const override { return metadata; }
+			virtual const Metadata & GetMetadata() const override;
 
 		private:
 			ModelPartPtr elementModelPart(typename T::value_type &) const;
@@ -388,35 +252,24 @@ namespace Slicer {
 	};
 
 	template<typename T>
-	class DLL_PUBLIC ModelPartForDictionaryElement : public ModelPartForComplex<ModelPartForDictionaryElement<T> > {
+	class ModelPartForDictionaryElement : public ModelPartForComplex<ModelPartForDictionaryElement<T> > {
 		public:
-			ModelPartForDictionaryElement(typename T::key_type * k, typename T::mapped_type * v) :
-				key(k),
-				value(v)
-			{
-			}
+			ModelPartForDictionaryElement(typename T::key_type * k, typename T::mapped_type * v);
 
-			ModelPartForDictionaryElement<T> * GetModel() override
-			{
-				return this;
-			}
+			ModelPartForDictionaryElement<T> * GetModel() override;
 
-			virtual bool HasValue() const override { return true; }
+			virtual bool HasValue() const override;
 
 			typename T::key_type * key;
 			typename T::mapped_type * value;
 	};
 
 	template<typename T>
-	class DLL_PUBLIC ModelPartForDictionaryElementInserter : public ModelPartForDictionaryElement<T> {
+	class ModelPartForDictionaryElementInserter : public ModelPartForDictionaryElement<T> {
 		public:
-			ModelPartForDictionaryElementInserter(T & d) :
-				ModelPartForDictionaryElement<T>(&key, &value),
-				dictionary(d)
-			{
-			}
+			ModelPartForDictionaryElementInserter(T & d);
 
-			virtual void Complete() override { dictionary.insert(typename T::value_type(key, value)); }
+			virtual void Complete() override;
 
 			mutable typename T::key_type key;
 			mutable typename T::mapped_type value;
@@ -433,41 +286,21 @@ namespace Slicer {
 	};
 
 	template<typename T>
-	class DLL_PUBLIC ModelPartForDictionary : public ModelPartForDictionaryBase {
+	class 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<T>(const_cast<typename T::key_type *>(&pair.first), &pair.second), NULL);
-				}
-			}
-
-			ChildRefPtr GetAnonChildRef(const HookFilter &) override
-			{
-				return new ImplicitChildRef(new ModelPartForDictionaryElementInserter<T>(dictionary));
-			}
-
-			ChildRefPtr GetChildRef(const std::string & name, const HookFilter &) override
-			{
-				if (name != pairName) {
-					throw IncorrectElementName(name);
-				}
-				return new ImplicitChildRef(new ModelPartForDictionaryElementInserter<T>(dictionary));
-			}
-
-			virtual const Metadata & GetMetadata() const override { return metadata; }
+			ModelPartForDictionary(T & d);
+
+			ModelPartForDictionary(T * d);
+
+			virtual void OnEachChild(const ChildHandler & ch) override;
+
+			ChildRefPtr GetAnonChildRef(const HookFilter &) override;
+
+			ChildRefPtr GetChildRef(const std::string & name, const HookFilter &) override;
+
+			virtual const Metadata & GetMetadata() const override;
 
 		private:
 			T & dictionary;
diff --git a/slicer/slicer/modelPartsTypes.impl.h b/slicer/slicer/modelPartsTypes.impl.h
new file mode 100644
index 0000000..2f34fa1
--- /dev/null
+++ b/slicer/slicer/modelPartsTypes.impl.h
@@ -0,0 +1,447 @@
+#ifndef SLICER_MODELPARTSTYPES_IMPL_H
+#define SLICER_MODELPARTSTYPES_IMPL_H
+
+#include "modelPartsTypes.h"
+
+#define MODELPARTFOR(Type, ModelPartType) \
+	template<> ModelPartPtr ModelPart::CreateFor(Type & s) { return new ModelPartType<Type>(s); } \
+	template<> ModelPartPtr ModelPart::CreateFor(IceUtil::Optional<Type> & s) { return new ModelPartForOptional<ModelPartType<Type> >(s); } \
+	template<> ModelPartPtr ModelPart::CreateRootFor(Type & s) { return new ModelPartForRoot<Type>(s); } \
+	template<> ModelPartPtr ModelPart::CreateRootFor(IceUtil::Optional<Type> & s) { return new ModelPartForRoot<IceUtil::Optional<Type> >(s); } \
+
+namespace Slicer {
+	// ModelPartForRoot
+	template<typename T>
+	ModelPartForRoot<T>::ModelPartForRoot(T & o) :
+		ModelObject(&o),
+		mp(ModelPart::CreateFor(o))
+	{
+	}
+
+	template<typename T>
+	ChildRefPtr ModelPartForRoot<T>::GetAnonChildRef(const HookFilter &)
+	{
+		mp->Create();
+		return new ImplicitChildRef(mp);
+	}
+
+	template<typename T>
+	ChildRefPtr ModelPartForRoot<T>::GetChildRef(const std::string & name, const HookFilter &)
+	{
+		if (name != rootName) {
+			throw IncorrectElementName(name);
+		}
+		mp->Create();
+		return new ImplicitChildRef(mp);
+	}
+
+	template<typename T>
+	void ModelPartForRoot<T>::OnEachChild(const ChildHandler & ch)
+	{
+		ch(rootName, mp, NULL);
+	}
+
+	template<typename T>
+	bool ModelPartForRoot<T>::HasValue() const
+	{
+		return ModelObject && mp->HasValue();
+	}
+
+	template<typename T>
+	ModelPartType ModelPartForRoot<T>::GetType() const
+	{
+		return mp->GetType();
+	}
+
+	template<typename T>
+	bool ModelPartForRoot<T>::IsOptional() const
+	{
+		return mp->IsOptional();
+	}
+
+	// ModelPartForSimple
+	template<typename T>
+	ModelPartForSimple<T>::ModelPartForSimple(T & h) :
+		Member(h)
+	{
+	}
+
+	template<typename T>
+	ModelPartForSimple<T>::ModelPartForSimple(T * h) :
+		Member(*h)
+	{
+	}
+
+	template<typename T>
+	void ModelPartForSimple<T>::SetValue(ValueSourcePtr s)
+	{
+		s->set(Member);
+	}
+
+	template<typename T>
+	void ModelPartForSimple<T>::GetValue(ValueTargetPtr s)
+	{
+		s->get(Member);
+	}
+
+	// ModelPartForConverted
+	template<typename T, typename M, T M::* MV>
+	ModelPartForConverted<T, M, MV>::ModelPartForConverted(T & h) :
+		Member(h)
+	{
+	}
+
+	template<typename T, typename M, T M::* MV>
+	ModelPartForConverted<T, M, MV>::ModelPartForConverted(T * h) :
+		Member(*h)
+	{
+	}
+
+	// ModelPartForOptional
+	template<typename T>
+	ModelPartForOptional<T>::ModelPartForOptional(IceUtil::Optional< typename T::element_type > & h) :
+		OptionalMember(h)
+	{
+		if (OptionalMember) {
+			modelPart = new T(*OptionalMember);
+		}
+	}
+
+	template<typename T>
+	ModelPartForOptional<T>::ModelPartForOptional(IceUtil::Optional< typename T::element_type > * h) :
+		OptionalMember(*h)
+	{
+		if (OptionalMember) {
+			modelPart = new T(*OptionalMember);
+		}
+	}
+
+	template<typename T>
+	void ModelPartForOptional<T>::OnEachChild(const ChildHandler & ch)
+	{
+		if (OptionalMember) {
+			modelPart->OnEachChild(ch);
+		}
+	}
+
+	template<typename T>
+	void ModelPartForOptional<T>::Complete()
+	{
+		if (OptionalMember) {
+			modelPart->Complete();
+		}
+	}
+
+	template<typename T>
+	void ModelPartForOptional<T>::Create()
+	{
+		if (!OptionalMember) {
+			OptionalMember = typename T::element_type();
+			modelPart = new T(*OptionalMember);
+			modelPart->Create();
+		}
+	}
+
+	template<typename T>
+	ChildRefPtr ModelPartForOptional<T>::GetAnonChildRef(const HookFilter & flt)
+	{
+		if (OptionalMember) {
+			return modelPart->GetAnonChildRef(flt);
+		}
+		return NULL;
+	}
+
+	template<typename T>
+	ChildRefPtr ModelPartForOptional<T>::GetChildRef(const std::string & name, const HookFilter & flt)
+	{
+		if (OptionalMember) {
+			return modelPart->GetChildRef(name, flt);
+		}
+		return NULL;
+	}
+
+	template<typename T>
+	void ModelPartForOptional<T>::SetValue(ValueSourcePtr s)
+	{
+		if (OptionalMember) {
+			modelPart->SetValue(s);
+		}
+	}
+
+	template<typename T>
+	void ModelPartForOptional<T>::GetValue(ValueTargetPtr s)
+	{
+		if (!OptionalMember) {
+			OptionalMember = typename T::element_type();
+			modelPart = new T(*OptionalMember);
+		}
+		modelPart->GetValue(s);
+	}
+
+	template<typename T>
+	bool ModelPartForOptional<T>::HasValue() const
+	{
+		return OptionalMember && modelPart->HasValue();
+	}
+
+	template<typename T>
+	ModelPartType ModelPartForOptional<T>::GetType() const
+	{
+		return T::type;
+	}
+
+	template<typename T>
+	bool ModelPartForOptional<T>::IsOptional() const
+	{
+		return true;
+	};
+
+	template<typename T>
+	const Metadata & ModelPartForOptional<T>::GetMetadata() const
+	{
+		return modelPart->GetMetadata();
+	}
+
+	// ModelPartForComplex
+	template<typename T>
+	void ModelPartForComplex<T>::OnEachChild(const ChildHandler & ch)
+	{
+		for (const auto & h : hooks) {
+			auto modelPart = h->Get(GetModel());
+			ch(h->PartName(), modelPart && modelPart->HasValue() ? modelPart : ModelPartPtr(), h);
+		}
+	}
+
+	template<typename T>
+	ChildRefPtr ModelPartForComplex<T>::GetAnonChildRef(const HookFilter & flt)
+	{
+		for (const auto & h : hooks) {
+			if (!flt || flt(h)) {
+				return new MemberChildRef(h->Get(GetModel()), h->GetMetadata());
+			}
+		}
+		return NULL;
+	}
+
+	template<typename T>
+	ChildRefPtr ModelPartForComplex<T>::GetChildRef(const std::string & name, const HookFilter & flt)
+	{
+		for (const auto & h : hooks) {
+			if (h->PartName() == name && (!flt || flt(h))) {
+				return new MemberChildRef(h->Get(GetModel()), h->GetMetadata());
+			}
+		}
+		return NULL;
+	}
+
+	template<typename T>
+	const Metadata & ModelPartForComplex<T>::GetMetadata() const
+	{
+		return metadata;
+	}
+
+	// ModelPartForClass
+	template<typename T>
+	ModelPartForClass<T>::ModelPartForClass(T & h) :
+			ModelObject(h)
+	{
+	}
+
+	template<typename T>
+	ModelPartForClass<T>::ModelPartForClass(T * h) :
+			ModelObject(*h)
+	{
+	}
+
+	template<typename T>
+	void ModelPartForClass<T>::Create()
+	{
+		ModelObject = new typename T::element_type();
+	}
+
+	template<typename T>
+	typename T::element_type * ModelPartForClass<T>::GetModel()
+	{
+		return ModelObject.get();
+	}
+
+	template<typename T>
+	ModelPartPtr ModelPartForClass<T>::GetSubclassModelPart(const std::string & name)
+	{
+		auto ref = classRefMap()->find(ModelPart::ToModelTypeName(name));
+		if (ref == classRefMap()->end()) {
+			throw UnknownType(name);
+		}
+		return ref->second(&this->ModelObject);
+	}
+
+	template<typename T>
+	bool ModelPartForClass<T>::HasValue() const
+	{
+		return ModelObject;
+	}
+
+	template<typename T>
+	IceUtil::Optional<std::string> ModelPartForClass<T>::GetTypeIdProperty() const
+	{
+		return typeIdProperty;
+	}
+
+	// ModelPartForStruct
+	template<typename T>
+	ModelPartForStruct<T>::ModelPartForStruct(T & o) :
+		ModelObject(o)
+	{
+	}
+
+	template<typename T>
+	ModelPartForStruct<T>::ModelPartForStruct(T * o) :
+		ModelObject(*o)
+	{
+	}
+
+	template<typename T>
+	T * ModelPartForStruct<T>::GetModel()
+	{
+		return &ModelObject;
+	}
+
+	template<typename T>
+	bool ModelPartForStruct<T>::HasValue() const
+	{
+		return true;
+	}
+
+	// ModelPartForEnum
+	template<typename T>
+	ModelPartForEnum<T>::ModelPartForEnum(T & s) :
+		modelPart(s)
+	{
+	}
+
+	template<typename T>
+	ModelPartForEnum<T>::ModelPartForEnum(T * s) :
+		modelPart(s)
+	{
+	}
+
+	template<typename T>
+	const Metadata & ModelPartForEnum<T>::GetMetadata() const
+	{
+		return metadata;
+	}
+
+	// ModelPartForSequence
+	template<typename T>
+	ModelPartForSequence<T>::ModelPartForSequence(T & s) :
+		sequence(s)
+	{
+	}
+
+	template<typename T>
+	ModelPartForSequence<T>::ModelPartForSequence(T * s) :
+		sequence(*s)
+	{
+	}
+
+	template<typename T>
+	void ModelPartForSequence<T>::OnEachChild(const ChildHandler & ch)
+		{
+			for(auto & element : sequence) {
+				ch(elementName, elementModelPart(element), NULL);
+			}
+		}
+
+	template<typename T>
+	ChildRefPtr ModelPartForSequence<T>::GetAnonChildRef(const HookFilter &)
+	{
+		sequence.push_back(typename element_type::value_type());
+		return new ImplicitChildRef(ModelPart::CreateFor(sequence.back()));
+	}
+
+	template<typename T>
+	const Metadata & ModelPartForSequence<T>::GetMetadata() const
+	{
+		return metadata;
+	}
+
+	// ModelPartForDictionaryElement
+	template<typename T>
+	ModelPartForDictionaryElement<T>::ModelPartForDictionaryElement(typename T::key_type * k, typename T::mapped_type * v) :
+		key(k),
+		value(v)
+	{
+	}
+
+	template<typename T>
+	ModelPartForDictionaryElement<T> * ModelPartForDictionaryElement<T>::GetModel()
+	{
+		return this;
+	}
+
+	template<typename T>
+	bool ModelPartForDictionaryElement<T>::HasValue() const
+	{
+		return true;
+	}
+
+	// ModelPartForDictionaryElementInserter
+	template<typename T>
+	ModelPartForDictionaryElementInserter<T>::ModelPartForDictionaryElementInserter(T & d) :
+		ModelPartForDictionaryElement<T>(&key, &value),
+		dictionary(d)
+	{
+	}
+
+	template<typename T>
+	void ModelPartForDictionaryElementInserter<T>::Complete()
+	{
+		dictionary.insert(typename T::value_type(key, value));
+	}
+
+	// ModelPartForDictionary
+	template<typename T>
+	ModelPartForDictionary<T>::ModelPartForDictionary(T & d) :
+		dictionary(d)
+	{
+	}
+
+	template<typename T>
+	ModelPartForDictionary<T>::ModelPartForDictionary(T * d) :
+		dictionary(*d)
+	{
+	}
+
+	template<typename T>
+	void ModelPartForDictionary<T>::OnEachChild(const ChildHandler & ch)
+	{
+		for (auto & pair : dictionary) {
+			ch(pairName, new ModelPartForDictionaryElement<T>(const_cast<typename T::key_type *>(&pair.first), &pair.second), NULL);
+		}
+	}
+
+	template<typename T>
+	ChildRefPtr ModelPartForDictionary<T>::GetAnonChildRef(const HookFilter &)
+	{
+		return new ImplicitChildRef(new ModelPartForDictionaryElementInserter<T>(dictionary));
+	}
+
+	template<typename T>
+	ChildRefPtr ModelPartForDictionary<T>::GetChildRef(const std::string & name, const HookFilter &)
+	{
+		if (name != pairName) {
+			throw IncorrectElementName(name);
+		}
+		return new ImplicitChildRef(new ModelPartForDictionaryElementInserter<T>(dictionary));
+	}
+
+	template<typename T>
+	const Metadata & ModelPartForDictionary<T>::GetMetadata() const
+	{
+		return metadata;
+	}
+
+}
+
+#endif
+
diff --git a/slicer/slicer/parser.cpp b/slicer/slicer/parser.cpp
index df9e501..813d134 100644
--- a/slicer/slicer/parser.cpp
+++ b/slicer/slicer/parser.cpp
@@ -97,13 +97,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 <slicer/modelParts.h>\n\n");
-		fprintbf(cpp, "#include <slicer/modelPartsTypes.h>\n\n");
-		fprintbf(cpp, "#define templateMODELPARTFOR(Type, ModelPart) \\\n");
-		fprintbf(cpp, "template <> ModelPartPtr DLL_PUBLIC ModelPartFor(IceUtil::Optional<Type> & t) { return new ModelPartForOptional< ModelPart< Type > >(t); } \\\n");
-		fprintbf(cpp, "template <> ModelPartPtr DLL_PUBLIC ModelPartFor(IceUtil::Optional<Type> * t) { return new ModelPartForOptional< ModelPart< Type > >(t); } \\\n");
-		fprintbf(cpp, "template <> ModelPartPtr DLL_PUBLIC ModelPartFor(Type & t) { return new ModelPart< Type >(t); } \\\n");
-		fprintbf(cpp, "template <> ModelPartPtr DLL_PUBLIC ModelPartFor(Type * t) { return new ModelPart< Type >(t); }\n\n");
+		fprintbf(cpp, "#include <slicer/modelPartsTypes.impl.h>\n\n");
 		fprintbf(cpp, "namespace Slicer {\n");
 		return true;
 	}
@@ -141,11 +135,14 @@ namespace Slicer {
 	Slicer::defineRootName(const std::string & type, const std::string & name) const
 	{
 		fprintbf(cpp, "template<>\n");
-		fprintbf(cpp, "DLL_PUBLIC std::string ModelPartForRoot< %s >::rootName(\"%s\");\n\n",
+		fprintbf(cpp, "std::string ModelPartForRoot< %s >::rootName(\"%s\");\n\n",
 				type, name);
 		fprintbf(cpp, "template<>\n");
-		fprintbf(cpp, "DLL_PUBLIC std::string ModelPartForRoot< IceUtil::Optional< %s > >::rootName(\"Optional%s\");\n\n",
+		fprintbf(cpp, "std::string ModelPartForRoot< IceUtil::Optional< %s > >::rootName(\"Optional%s\");\n\n",
 				type, name);
+
+		fprintbf(cpp, "template class ModelPartForRoot< %s >;\n\n", type);
+		fprintbf(cpp, "template class ModelPartForRoot< IceUtil::Optional< %s > >;\n\n", type);
 	}
 
 	bool
@@ -164,7 +161,7 @@ namespace Slicer {
 
 		fprintbf(cpp, "template<>\n");
 		auto typeId = metaDataValue("slicer:typeid:", c->getMetaData());
-		fprintbf(cpp, "DLL_PUBLIC std::string ModelPartForClass< %s >::typeIdProperty(\"%s\");\n\n",
+		fprintbf(cpp, "std::string ModelPartForClass< %s >::typeIdProperty(\"%s\");\n\n",
 				typeToString(decl),
 				typeId ? *typeId : "slicer-typeid");
 
@@ -194,17 +191,17 @@ namespace Slicer {
 		}
 		fprintbf(cpp, "}\n\n");
 
-		fprintbf(cpp, "template<>\nDLL_PUBLIC TypeId\nModelPartForClass< %s >::GetTypeId() const\n{\n",
+		fprintbf(cpp, "template<>\nTypeId\nModelPartForClass< %s >::GetTypeId() const\n{\n",
 				typeToString(decl));
 		fprintbf(cpp, "\tauto id = ModelObject->ice_id();\n");
 		fprintbf(cpp, "\treturn (id == \"%s\") ? TypeId() : ModelPart::ToExchangeTypeName(id);\n}\n\n",
 				c->scoped());
 
-		fprintbf(cpp, "template<>\nDLL_PUBLIC Metadata ModelPartForComplex< %s >::metadata ",
+		fprintbf(cpp, "template<>\nMetadata ModelPartForComplex< %s >::metadata ",
 				c->scoped());
 		copyMetadata(c->getMetaData());
 
-		fprintbf(cpp, "templateMODELPARTFOR(::IceInternal::Handle< %s >, ModelPartForClass);\n\n",
+		fprintbf(cpp, "MODELPARTFOR(::IceInternal::Handle< %s >, ModelPartForClass);\n\n",
 				c->scoped());
 
 		classNo += 1;
@@ -227,11 +224,11 @@ namespace Slicer {
 		auto name = metaDataValue("slicer:root:", c->getMetaData());
 		defineRootName(c->scoped(), name ? *name : c->name());
 
-		fprintbf(cpp, "template<>\nDLL_PUBLIC Metadata ModelPartForComplex< %s >::metadata ",
+		fprintbf(cpp, "template<>\nMetadata ModelPartForComplex< %s >::metadata ",
 				c->scoped());
 		copyMetadata(c->getMetaData());
 
-		fprintbf(cpp, "templateMODELPARTFOR(%s, ModelPartForStruct);\n\n",
+		fprintbf(cpp, "MODELPARTFOR(%s, ModelPartForStruct);\n\n",
 				c->scoped());
 
 		return true;
@@ -243,7 +240,7 @@ namespace Slicer {
 		if (!cpp) return;
 
 		fprintbf(cpp, "template<>\n");
-		fprintbf(cpp, "DLL_PUBLIC ModelPartForComplex< %s >::Hooks ",
+		fprintbf(cpp, "ModelPartForComplex< %s >::Hooks ",
 				it->scoped());
 		fprintbf(cpp, "ModelPartForComplex< %s >::hooks {\n",
 				it->scoped());
@@ -350,7 +347,7 @@ namespace Slicer {
 		auto name = metaDataValue("slicer:root:", e->getMetaData());
 		defineRootName(e->scoped(), name ? *name : e->name());
 
-		fprintbf(cpp, "templateMODELPARTFOR(%s, ModelPartForEnum);\n\n",
+		fprintbf(cpp, "MODELPARTFOR(%s, ModelPartForEnum);\n\n",
 				e->scoped());
 	}
 
@@ -365,7 +362,7 @@ namespace Slicer {
 
 		fprintbf(cpp, "// Sequence %s\n", s->name());
 		fprintbf(cpp, "template<>\n");
-		fprintbf(cpp, "DLL_PUBLIC ChildRefPtr ModelPartForSequence< %s >::GetChildRef(const std::string & name, const HookFilter & flt)\n{\n",
+		fprintbf(cpp, "ChildRefPtr ModelPartForSequence< %s >::GetChildRef(const std::string & name, const HookFilter & flt)\n{\n",
 				s->scoped());
 		auto iname = metaDataValue("slicer:item:", s->getMetaData());
 		if (iname) {
@@ -378,26 +375,26 @@ namespace Slicer {
 		fprintbf(cpp, "\treturn GetAnonChildRef(flt);\n}\n\n");
 
 		fprintbf(cpp, "template<>\n");
-		fprintbf(cpp, "DLL_PUBLIC ModelPartPtr\n");
+		fprintbf(cpp, "ModelPartPtr\n");
 		fprintbf(cpp, "ModelPartForSequence< %s >::elementModelPart(typename %s::value_type & e) const {\n",
 				s->scoped(),
 				s->scoped());
-		fprintbf(cpp, "\treturn ModelPartFor(e);\n}\n\n");
+		fprintbf(cpp, "\treturn ModelPart::CreateFor(e);\n}\n\n");
 
 		fprintbf(cpp, "template<>\n");
 		auto ename = metaDataValue("slicer:element:", s->getMetaData());
-		fprintbf(cpp, "DLL_PUBLIC std::string ModelPartForSequence< %s >::elementName(\"%s\");\n\n",
+		fprintbf(cpp, "std::string ModelPartForSequence< %s >::elementName(\"%s\");\n\n",
 				s->scoped(),
 				ename ? *ename : "element");
 
 		auto name = metaDataValue("slicer:root:", s->getMetaData());
 		defineRootName(s->scoped(), name ? *name : s->name());
 
-		fprintbf(cpp, "template<>\nDLL_PUBLIC Metadata ModelPartForSequence< %s >::metadata ",
+		fprintbf(cpp, "template<>\nMetadata ModelPartForSequence< %s >::metadata ",
 				s->scoped());
 		copyMetadata(s->getMetaData());
 
-		fprintbf(cpp, "templateMODELPARTFOR(%s, ModelPartForSequence);\n\n",
+		fprintbf(cpp, "MODELPARTFOR(%s, ModelPartForSequence);\n\n",
 				s->scoped());
 	}
 
@@ -413,12 +410,12 @@ namespace Slicer {
 		fprintbf(cpp, "// Dictionary %s\n", d->name());
 		auto iname = metaDataValue("slicer:item:", d->getMetaData());
 		fprintbf(cpp, "template<>\n");
-		fprintbf(cpp, "DLL_PUBLIC std::string ModelPartForDictionary< %s >::pairName(\"%s\");\n\n",
+		fprintbf(cpp, "std::string ModelPartForDictionary< %s >::pairName(\"%s\");\n\n",
 				d->scoped(),
 				iname ? *iname : "element");
 
 		fprintbf(cpp, "template<>\n");
-		fprintbf(cpp, "DLL_PUBLIC ModelPartForComplex< ModelPartForDictionaryElement< %s > >::Hooks ",
+		fprintbf(cpp, "ModelPartForComplex< ModelPartForDictionaryElement< %s > >::Hooks ",
 				d->scoped());
 		fprintbf(cpp, "ModelPartForComplex< ModelPartForDictionaryElement< %s > >::hooks {\n",
 				d->scoped());
@@ -451,11 +448,11 @@ namespace Slicer {
 		auto name = metaDataValue("slicer:root:", d->getMetaData());
 		defineRootName(d->scoped(), name ? *name : d->name());
 
-		fprintbf(cpp, "template<>\nDLL_PUBLIC Metadata ModelPartForDictionary< %s >::metadata ",
+		fprintbf(cpp, "template<>\nMetadata ModelPartForDictionary< %s >::metadata ",
 				d->scoped());
 		copyMetadata(d->getMetaData());
 
-		fprintbf(cpp, "template<>\nDLL_PUBLIC Metadata ModelPartForComplex<ModelPartForDictionaryElement< %s > >::metadata ",
+		fprintbf(cpp, "template<>\nMetadata ModelPartForComplex<ModelPartForDictionaryElement< %s > >::metadata ",
 				d->scoped());
 		copyMetadata(d->getMetaData());
 
@@ -470,7 +467,7 @@ namespace Slicer {
 				d->scoped(),
 				d->scoped());
 
-		fprintbf(cpp, "templateMODELPARTFOR(%s, ModelPartForDictionary);\n\n",
+		fprintbf(cpp, "MODELPARTFOR(%s, ModelPartForDictionary);\n\n",
 				d->scoped());
 	}
 
diff --git a/slicer/slicer/slicer.h b/slicer/slicer/slicer.h
index 8a439d9..267b597 100644
--- a/slicer/slicer/slicer.h
+++ b/slicer/slicer/slicer.h
@@ -18,7 +18,7 @@ namespace Slicer {
 	DeserializeAnyWith(DeserializerPtr deserializer)
 	{
 		Object object;
-		deserializer->Deserialize(new ModelPartForRoot<Object>(object));
+		deserializer->Deserialize(ModelPart::CreateRootFor<Object>(object));
 		return object;
 	}
 
@@ -40,7 +40,7 @@ namespace Slicer {
 	void
 	SerializeAnyWith(Object object, SerializerPtr serializer)
 	{
-		serializer->Serialize(new ModelPartForRoot<Object>(object));
+		serializer->Serialize(ModelPart::CreateRootFor<Object>(object));
 	}
 
 	template <typename Serializer, typename Object, typename ... SerializerParams>
diff --git a/slicer/test/compilation.cpp b/slicer/test/compilation.cpp
index bd869d9..da13652 100644
--- a/slicer/test/compilation.cpp
+++ b/slicer/test/compilation.cpp
@@ -11,15 +11,9 @@ BOOST_TEST_DONT_PRINT_LOG_VALUE(std::type_info);
 
 #define TypeTest(Var, Expr, Explicit, Expected) \
 	Var obj = Expr; \
-	Slicer::ModelPartPtr mpp = new Slicer::Explicit<Var>(obj); \
+	Slicer::ModelPartPtr mpp = Slicer::ModelPart::CreateFor(obj); \
 	BOOST_REQUIRE_EQUAL(Slicer::Expected, mpp->GetType()); \
- \
-	Slicer::ModelPartPtr autoMpp = Slicer::ModelPartFor(obj); \
-	BOOST_REQUIRE_EQUAL(Slicer::Expected, autoMpp->GetType()); \
- \
-	Slicer::ModelPartPtr autoPtrMpp = Slicer::ModelPartFor(&obj); \
-	BOOST_REQUIRE_EQUAL(Slicer::Expected, autoPtrMpp->GetType()); \
-\
+	\
 	auto mppvalue = mpp.get(); \
 	auto amppvalue = mpp.get(); \
 	auto apmppvalue = mpp.get(); \