luaObjectSerializer.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2013 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once

#include <vrfLua/vrfLuaDefines.h>

#include <vlutil/vlString.h>
#include <map>
#include <set>
#include <vrfLua/luaUtils.h>
#include <vrfutil/asciiSerializable.h>
#include "vlutil/vlExceptions.h"

struct lua_State;
class DtSimulationServices;
class DtLocalObject;

typedef DtAsciiSerializable* (*DtSerializableCreatorFunc)();
typedef luabind::object (*DtDeserializerFunc)(lua_State* state, const DtString& typeName, const DtString& serializedString, DtLocalObject*);
typedef bool (*DtSerializerFunc)(const luabind::object&, DtString& serializedString);

class DT_DLL_vrfLua DtLuaObjectSerializer
{
protected:
   DtLuaObjectSerializer(DtSimulationServices* simManager);
   DtLuaObjectSerializer(const DtLuaObjectSerializer& other);
   DtLuaObjectSerializer& operator=(const DtLuaObjectSerializer& other);

public:
   virtual ~DtLuaObjectSerializer();

   static DtLuaObjectSerializer* instance();

   virtual DtAsciiSerializable* createInstance(const DtString& typeName, const DtString& serializedString, DtLocalObject* owner);

   virtual void registerCreatorFunc(const DtString& typeName, DtSerializableCreatorFunc func);

   virtual void registerDeserializerFunc(const DtString& typeName, DtDeserializerFunc func);

   virtual void registerSerializerFunc(const DtString& typeName, DtSerializerFunc func);

   virtual bool serializeObject(const luabind::object& lobj, std::string& buffer, std::vector<luabind::object> stackParameters);

   virtual const char* deserializeObject(lua_State* state, const char* buffer, luabind::object& lobj, DtLocalObject* owner);

   virtual bool doesSerializerExist(const DtString& type);

   static DtLuaObjectSerializer* create(DtSimulationServices* simManager);
   static void setFactory( DtLuaObjectSerializer* factory );

   virtual bool saveLuaScriptGlobals(lua_State* state, std::string &buffer);

   virtual bool saveLuaScriptTable(lua_State* state, const std::string& key, const luabind::object& lobj, std::string &buffer);

   virtual bool loadLuaScriptGlobals(lua_State* state, const DtString& buffer, DtLocalObject* owner);

   typedef DtTemplatedException<300> DtStateParseException;

   virtual void addKeyToIgnore(const std::string&);

   virtual void removeKeyToIgnore(const std::string&);

protected:
   virtual const char* parseBufferToTableKeyVals(lua_State* state, luabind::object& table, const char* buffer, DtLocalObject* owner);

   virtual void parseTableKeyValsToBuffer(const luabind::object&, std::string& buffer,
      std::vector<luabind::object> stackParameters);

   virtual bool needsEscaping(const DtString& buffer) const;
   virtual void applyStandardEscapes(DtString& buffer);
   virtual bool needsUnescaping(DtString& buffer) const;
   virtual void unapplyStandardEscapes(DtString& buffer);
   virtual  bool isKeyToIgnore(const DtString& keyName);
   virtual bool IsALoadedPackage(lua_State * L, const char * tableName);

   virtual const char* nextToken(char separator, const char* buf, DtString& tok);

   std::map<DtString, DtSerializableCreatorFunc> myCreators;
   std::map<DtString, DtSerializerFunc> mySerializers;
   std::map<DtString, DtDeserializerFunc> myDeserializers;
   DtSimulationServices* mySimulationServices;
   static DtLuaObjectSerializer* theInstance;

   std::set<std::string> myKeysToIgnore;
};

namespace vrfLua
{
   template<typename T>
   bool DtAsciiSerializeLua(const luabind::object& lobj, DtString& serializedString)
   {
      if (lobj)
      {
         T* obj = luaTypeCastNoThrow<T>(lobj);

         if (obj)
         {
            serializedString += obj->serialize();
            return true;
         }
      }
      return false;
   }

   template<typename T, typename Parent>
   bool DtAsciiSerializeLua(const luabind::object& lobj, DtString& serializedString)
   {
      if (lobj)
      {
         Parent* pobj = luaTypeCastNoThrow<Parent>(lobj);
         T* obj = dynamic_cast<T*>(pobj);

         if (obj)
         {
            serializedString += obj->serialize();
            return true;
         }
      }
      return false;
   }

   template<typename T>
   luabind::object DtAsciiDeserializeLua(lua_State* state, const DtString& typeName, const DtString& serializedString, DtLocalObject* owner)
   {
      DtLuaObjectSerializer* deserializer = DtLuaObjectSerializer::instance();
      if (deserializer)
      {
         DtAsciiSerializable* obj = deserializer->createInstance(typeName, serializedString, owner);
         if (obj && (obj->objectType() == typeName))
         {
            obj->deserialize(serializedString);
            luabind::object lobj(state, *(dynamic_cast<T*>(obj)));

            delete obj;

            return lobj;
         }

         delete obj;
      }

      return luabind::object();
   }

   template<typename T>
   luabind::object DtAsciiDeserializeLuaSharedPtr(
      lua_State* state, const DtString& typeName, const DtString& serializedString, DtLocalObject* owner)
   {
      DtLuaObjectSerializer* deserializer = DtLuaObjectSerializer::instance();
      if (deserializer)
      {
         std::shared_ptr<T> obj(static_cast<T*>(deserializer->createInstance(typeName, serializedString, owner)));
         if (obj.get() && obj->objectType() == typeName)
         {
            obj->deserialize(serializedString);
            return luabind::object(state, obj);
         }
      }

      return luabind::object();
   }
}