{

public:

template<typename T> void apply(ValueSerializer<T>& obj);

void apply(BaseSerializer& obj) { applyValue(obj); }

virtual void apply(ObjectSerializer& obj) {}

virtual void apply(ImageSerializer& obj) {}

virtual void apply(VectorSerializer& obj) {}

virtual void apply(UserSerializer& obj) {}

virtual void apply(BoolSerializer& obj) {}

virtual void apply(StringSerializer& obj) {}

virtual void apply(EnumSerializer& obj) {}

virtual void apply(GLenumSerializer& obj) {}

template<typename T>

void registerType(std::function<void(ValueSerializer<T>&)> func)

{

_registry[std::type_index(typeid(ValueSerializer<T>))] = [func](BaseSerializer& baseObj)

{ ValueSerializer<T>& obj = static_cast<ValueSerializer<T>&>(baseObj); func(obj); };

}

SerializerVisitor() : _manager(NULL), _inputVersion(INT_MAX) {}

void setManager(RewrapperManager* m, int v) { _manager = m; _inputVersion = v; }

void push(const std::string& n) { _propertyList.push(n); }

void pop() { _propertyList.pop(); }

const std::stack<std::string>& getPropertyList() const { return _propertyList; }

protected:

void traverse(WrappableSerializer& obj);

void applyValue(BaseSerializer& obj);

typedef std::map<std::type_index, std::function<void(BaseSerializer&)>> SerializerMap;

SerializerMap _registry; RewrapperManager* _manager; int _inputVersion;

std::stack<std::string> _propertyList;

{

WrapperAssociate(const std::string& name) : _firstVersion(0), _lastVersion(INT_MAX), _name(name) {}

int _firstVersion, _lastVersion; std::string _name;

{ bool _asInt; unsigned int _v0; std::map<std::string, unsigned int> _valueMap; META_VISITOR() };

template<typename T> void SerializerVisitor::apply(ValueSerializer<T>& obj)

{ applyValue(static_cast<BaseSerializer&>(obj)); }

class Rewrapper : public osg::Referenced

{

public:

template<typename T> void addValueSerializer(const std::string& prop, T def, bool hex = false)

{ ValueSerializer<T>* s = new ValueSerializer<T>(); s->_v0 = def; s->_hex = hex; add(prop, s); }

template<typename T> void addRefValueSerializer(const std::string& prop, const T& def, bool hex = false)

{ ValueSerializer<T>* s = new ValueSerializer<T>(); s->_v0 = def; s->_hex = hex; add(prop, s); }

template<typename T> void addListSerializer(const std::string& prop)

{ ListSerializer<T>* s = new ListSerializer<T>(); add(prop, s); }

void addObjectListSerializer(const std::string& prop, const std::string& t)

{ ListSerializer<ObjectTypeAndID>* s = new ListSerializer<ObjectTypeAndID>(); s->_v0 = ObjectTypeAndID(t, ""); add(prop, s); }

void addBoolSerializer(const std::string& prop, bool def)

{ BoolSerializer* s = new BoolSerializer; s->_v0 = def; add(prop, s); }

void addGLenumSerializer(const std::string& prop, const std::string& type, unsigned int def)

{ GLenumSerializer* s = new GLenumSerializer; s->_type = type; s->_v0 = def; add(prop, s); }

void addStringSerializer(const std::string& prop, const std::string& def)

{ StringSerializer* s = new StringSerializer; s->_v0 = def; add(prop, s); }

void addObjectSerializer(const std::string& prop, const std::string& type)

{ ObjectSerializer* s = new ObjectSerializer; s->_type = type; add(prop, s); }

void addImageSerializer(const std::string& prop, const std::string& type)

{ ImageSerializer* s = new ImageSerializer; s->_type = type; add(prop, s); }

void addVectorSerializer(const std::string& prop, const std::string& type)

{ VectorSerializer* s = new VectorSerializer; s->_type = type; add(prop, s); }

void addUserSerializer(const std::string& prop, BaseSerializer::ReadFunc f)

{ UserSerializer* s = new UserSerializer; s->_reader = f; add(prop, s); }

void beginEnumSerializer(const std::string& prop, const std::string& value)

{ _lastEnum = new EnumSerializer; _lastEnum->_v0 = value; add(prop, _lastEnum); }

void addEnumValue(const std::string & v) { if (_lastEnum) _lastEnum->_values.insert(v); }

void endEnumSerializer() { _lastEnum = NULL; }

void beginBitFlagSerializer(const std::string& prop, unsigned int v, bool i)

{ _lastBitFlags = new BitFlagSerializer; _lastBitFlags->_asInt = i; _lastBitFlags->_v0 = v; add(prop, _lastBitFlags); }

void addBitFlagValue(const std::string& v, unsigned int ui) { if (_lastBitFlags) { _lastBitFlags->_valueMap[v] = ui; } }

void endBitFlagSerializer() { _lastBitFlags = NULL; }

void setAssociates(const std::string& a) { splitAssociates(a); }

void add(const std::string& n, BaseSerializer* s);

void clear();

void setUpdatedVersion(int v) { _version = v; }

int getUpdatedVersion() const { return _version; }

void markSerializerAsRemoved(const std::string& name);

void markAssociateAsRemoved(const std::string& name);

void markAssociateAsAdded(const std::string& name);

Rewrapper() : _lastBitFlags(NULL), _lastEnum(NULL), _version(0) {}

void accept(RewrapperManager* manager, SerializerVisitor& v,

int inputVersion, bool includingAssociates = true);

protected:

virtual ~Rewrapper() {}

void splitAssociates(const std::string& associates);

typedef std::pair<std::string, osg::ref_ptr<BaseSerializer>> SerializerPair;

std::vector<SerializerPair> _serializers;

std::vector<WrapperAssociate> _associates;

BitFlagSerializer* _lastBitFlags;

EnumSerializer* _lastEnum; int _version;

};

class RewrapperManager

{

public:

static std::shared_ptr<RewrapperManager> instance();

virtual ~RewrapperManager();

void addRewrapper(const std::string& name, Rewrapper* r);

void removeRewrapper(const std::string& name);

Rewrapper* getRewrapper(const std::string& name);

typedef std::map<std::string, osg::ref_ptr<Rewrapper>> RewrapperMap;

const RewrapperMap& getRewrappers() const { return _rewrappers; }

protected:

RewrapperMap _rewrappers;

};

struct RegisterWrapperProxy

{

public:

typedef void (*AddPropFunc)(Rewrapper&);

RegisterWrapperProxy(const std::string& name, const std::string& associates, AddPropFunc func);

virtual ~RegisterWrapperProxy(); std::string _className;

};

struct RegisterWrapperFunctionProxy

{

RegisterWrapperFunctionProxy(WrapperLoadingFunction function) { (function)(); }

};

struct UpdateWrapperVersionProxy

{

UpdateWrapperVersionProxy(Rewrapper* w, int v) : _wrapper(w)

{ _lastVersion = w->getUpdatedVersion(); w->setUpdatedVersion(v); }

~UpdateWrapperVersionProxy() { _wrapper->setUpdatedVersion(_lastVersion); }

Rewrapper* _wrapper; int _lastVersion;

};