BVB Source Codes

CRYENGINE Show XMLScriptLoader.cpp Source code

Return Download CRYENGINE: download XMLScriptLoader.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "XMLScriptLoader.h"
  5. #include <CrySystem/XML/IReadWriteXMLSink.h>
  6. #include <stack>
  7.  
  8. /*
  9.  * Load an XML file to a script table
  10.  */
  11.  
  12. class CXmlScriptLoad : public IReadXMLSink
  13. {
  14. public:
  15.         CXmlScriptLoad();
  16.  
  17.         SmartScriptTable GetTable() { CRY_ASSERT(m_tableStack.size() == 1); return m_tableStack.top(); }
  18.  
  19.         // IReadXMLSink
  20.         virtual void            AddRef();
  21.         virtual void            Release();
  22.  
  23.         virtual IReadXMLSinkPtr BeginTable(const char* name, const XmlNodeRef& definition);
  24.         virtual IReadXMLSinkPtr BeginTableAt(int elem, const XmlNodeRef& definition);
  25.         virtual bool            SetValue(const char* name, const TValue& value, const XmlNodeRef& definition);
  26.         virtual bool            EndTableAt(int elem);
  27.         virtual bool            EndTable(const char* name);
  28.  
  29.         virtual IReadXMLSinkPtr BeginArray(const char* name, const XmlNodeRef& definition);
  30.         virtual bool            SetAt(int elem, const TValue& value, const XmlNodeRef& definition);
  31.         virtual bool            EndArray(const char* name);
  32.  
  33.         virtual bool            IsCreationMode()                       { return false; }
  34.         virtual void            SetCreationNode(XmlNodeRef definition) {}
  35.         virtual XmlNodeRef      GetCreationNode()                      { return XmlNodeRef(0); }
  36.  
  37.         virtual bool            Complete();
  38.         // ~IReadXMLSink
  39.  
  40. private:
  41.         int                          m_nRefs;
  42.         IScriptSystem*               m_pSS;
  43.         std::stack<SmartScriptTable> m_tableStack;
  44.  
  45.         IScriptTable* CurTable() { CRY_ASSERT(!m_tableStack.empty()); return m_tableStack.top().GetPtr(); }
  46.  
  47.         class SSetValueVisitor
  48.         {
  49.         public:
  50.                 SSetValueVisitor(IScriptTable* pTable, const char* name) : m_pTable(pTable), m_name(name) {}
  51.  
  52.                 template<class T>
  53.                 void Visit(const T& value)
  54.                 {
  55.                         m_pTable->SetValue(m_name, value);
  56.                 }
  57.  
  58.                 template<class T>
  59.                 void operator()(const T& type)
  60.                 {
  61.                         Visit(type);
  62.                 }
  63.  
  64.                 void operator()(const SReadWriteXMLCommon::TValue& var)
  65.                 {
  66.                         VisitVariant(var);
  67.                 }
  68.  
  69.         private:
  70.                 template<size_t I = 0>
  71.                 void VisitVariant(const SReadWriteXMLCommon::TValue& var)
  72.                 {
  73.                         if (var.index() == I)
  74.                         {
  75.                                 Visit(stl::get<I>(var));
  76.                         }
  77.                         else
  78.                         {
  79.                                 VisitVariant<I + 1>(var);
  80.                         }
  81.                 }
  82.  
  83.                 IScriptTable* m_pTable;
  84.                 const char*   m_name;
  85.         };
  86.         class SSetValueAtVisitor
  87.         {
  88.         public:
  89.                 SSetValueAtVisitor(IScriptTable* pTable, int elem) : m_pTable(pTable), m_elem(elem) {}
  90.  
  91.                 template<class T>
  92.                 void Visit(const T& value)
  93.                 {
  94.                         m_pTable->SetAt(m_elem, value);
  95.                 }
  96.  
  97.                 template<class T>
  98.                 void operator()(const T& type)
  99.                 {
  100.                         Visit(type);
  101.                 }
  102.  
  103.                 void operator()(const SReadWriteXMLCommon::TValue& var)
  104.                 {
  105.                         VisitVariant(var);
  106.                 }
  107.  
  108.         private:
  109.                 template<size_t I = 0>
  110.                 void VisitVariant(const SReadWriteXMLCommon::TValue& var)
  111.                 {
  112.                         if (var.index() == I)
  113.                         {
  114.                                 Visit(stl::get<I>(var));
  115.                         }
  116.                         else
  117.                         {
  118.                                 VisitVariant<I + 1>(var);
  119.                         }
  120.                 }
  121.  
  122.                 IScriptTable* m_pTable;
  123.                 int           m_elem;
  124.         };
  125. };
  126. template<>
  127. void CXmlScriptLoad::SSetValueVisitor::VisitVariant<stl::variant_size<SReadWriteXMLCommon::TValue>::value>(const SReadWriteXMLCommon::TValue& var)
  128. {
  129.         CRY_ASSERT_MESSAGE(false, "Invalid variant index.");
  130. }
  131. template<>
  132. void CXmlScriptLoad::SSetValueAtVisitor::VisitVariant<stl::variant_size<SReadWriteXMLCommon::TValue>::value>(const SReadWriteXMLCommon::TValue& var)
  133. {
  134.         CRY_ASSERT_MESSAGE(false, "Invalid variant index.");
  135. }
  136.  
  137. TYPEDEF_AUTOPTR(CXmlScriptLoad);
  138. typedef CXmlScriptLoad_AutoPtr CXmlScriptLoadPtr;
  139.  
  140. CXmlScriptLoad::CXmlScriptLoad() : m_nRefs(0), m_pSS(gEnv->pScriptSystem)
  141. {
  142.         m_tableStack.push(SmartScriptTable(m_pSS));
  143. }
  144.  
  145. void CXmlScriptLoad::AddRef()
  146. {
  147.         ++m_nRefs;
  148. }
  149.  
  150. void CXmlScriptLoad::Release()
  151. {
  152.         if (0 == --m_nRefs)
  153.                 delete this;
  154. }
  155.  
  156. IReadXMLSinkPtr CXmlScriptLoad::BeginTable(const char* name, const XmlNodeRef& definition)
  157. {
  158.         m_tableStack.push(SmartScriptTable(m_pSS));
  159.         return this;
  160. }
  161.  
  162. IReadXMLSinkPtr CXmlScriptLoad::BeginTableAt(int elem, const XmlNodeRef& definition)
  163. {
  164.         return BeginTable(NULL, definition);
  165. }
  166.  
  167. bool CXmlScriptLoad::SetValue(const char* name, const TValue& value, const XmlNodeRef& definition)
  168. {
  169.         SSetValueVisitor visitor(CurTable(), name);
  170.         stl::visit(visitor, value);
  171.         return true;
  172. }
  173.  
  174. bool CXmlScriptLoad::EndTable(const char* name)
  175. {
  176.         SmartScriptTable newTable = CurTable();
  177.         m_tableStack.pop();
  178.         CurTable()->SetValue(name, newTable);
  179.         return true;
  180. }
  181.  
  182. bool CXmlScriptLoad::EndTableAt(int elem)
  183. {
  184.         SmartScriptTable newTable = CurTable();
  185.         m_tableStack.pop();
  186.         CurTable()->SetAt(elem, newTable);
  187.         return true;
  188. }
  189.  
  190. IReadXMLSinkPtr CXmlScriptLoad::BeginArray(const char* name, const XmlNodeRef& definition)
  191. {
  192.         m_tableStack.push(SmartScriptTable(m_pSS));
  193.         return this;
  194. }
  195.  
  196. bool CXmlScriptLoad::SetAt(int elem, const TValue& value, const XmlNodeRef& definition)
  197. {
  198.         SSetValueAtVisitor visitor(CurTable(), elem);
  199.         stl::visit(visitor, value);
  200.         return true;
  201. }
  202.  
  203. bool CXmlScriptLoad::EndArray(const char* name)
  204. {
  205.         return EndTable(name);
  206. }
  207.  
  208. bool CXmlScriptLoad::Complete()
  209. {
  210.         return m_tableStack.size() == 1;
  211. }
  212.  
  213. SmartScriptTable XmlScriptLoad(const char* definitionFile, XmlNodeRef data)
  214. {
  215.         CXmlScriptLoadPtr pLoader(new CXmlScriptLoad);
  216.         if (GetISystem()->GetXmlUtils()->GetIReadWriteXMLSink()->ReadXML(definitionFile, data, &*pLoader))
  217.                 return pLoader->GetTable();
  218.         else
  219.                 return NULL;
  220. }
  221.  
  222. SmartScriptTable XmlScriptLoad(const char* definitionFile, const char* dataFile)
  223. {
  224.         CXmlScriptLoadPtr pLoader(new CXmlScriptLoad);
  225.         if (GetISystem()->GetXmlUtils()->GetIReadWriteXMLSink()->ReadXML(definitionFile, dataFile, &*pLoader))
  226.                 return pLoader->GetTable();
  227.         else
  228.                 return NULL;
  229. }
  230.  
  231. /*
  232.  * Save an XML file from a script table
  233.  */
  234.  
  235. class CXmlScriptSaver : public IWriteXMLSource
  236. {
  237. public:
  238.         CXmlScriptSaver(SmartScriptTable pTable);
  239.  
  240.         // IWriteXMLSource
  241.         virtual void               AddRef();
  242.         virtual void               Release();
  243.  
  244.         virtual IWriteXMLSourcePtr BeginTable(const char* name);
  245.         virtual IWriteXMLSourcePtr BeginTableAt(int elem);
  246.         virtual bool               HaveValue(const char* name);
  247.         virtual bool               GetValue(const char* name, TValue& value, const XmlNodeRef& definition);
  248.         virtual bool               EndTableAt(int elem);
  249.         virtual bool               EndTable(const char* name);
  250.  
  251.         virtual IWriteXMLSourcePtr BeginArray(const char* name, size_t* numElems, const XmlNodeRef& definition);
  252.         virtual bool               HaveElemAt(int elem);
  253.         virtual bool               GetAt(int elem, TValue& value, const XmlNodeRef& definition);
  254.         virtual bool               EndArray(const char* name);
  255.  
  256.         virtual bool               Complete();
  257.         // ~IWriteXMLSource
  258.  
  259. private:
  260.         int                          m_nRefs;
  261.         std::stack<SmartScriptTable> m_tables;
  262.  
  263.         IScriptTable* CurTable() { return m_tables.top().GetPtr(); }
  264. };
  265.  
  266. TYPEDEF_AUTOPTR(CXmlScriptSaver);
  267. typedef CXmlScriptSaver_AutoPtr CXmlScriptSaverPtr;
  268.  
  269. void CXmlScriptSaver::AddRef()
  270. {
  271.         ++m_nRefs;
  272. }
  273.  
  274. void CXmlScriptSaver::Release()
  275. {
  276.         if (0 == --m_nRefs)
  277.                 delete this;
  278. }
  279.  
  280. IWriteXMLSourcePtr CXmlScriptSaver::BeginTable(const char* name)
  281. {
  282.         SmartScriptTable childTable;
  283.         if (!CurTable()->GetValue(name, childTable))
  284.                 return NULL;
  285.         m_tables.push(childTable);
  286.         return this;
  287. }
  288.  
  289. IWriteXMLSourcePtr CXmlScriptSaver::BeginTableAt(int elem)
  290. {
  291.         SmartScriptTable childTable;
  292.         if (!CurTable()->GetAt(elem, childTable))
  293.                 return NULL;
  294.         m_tables.push(childTable);
  295.         return this;
  296. }
  297.  
  298. IWriteXMLSourcePtr CXmlScriptSaver::BeginArray(const char* name, size_t* numElems, const XmlNodeRef& definition)
  299. {
  300.         SmartScriptTable childTable;
  301.         if (!CurTable()->GetValue(name, childTable))
  302.                 return NULL;
  303.         *numElems = childTable->Count();
  304.         m_tables.push(childTable);
  305.         return this;
  306. }
  307.  
  308. bool CXmlScriptSaver::EndTable(const char* name)
  309. {
  310.         m_tables.pop();
  311.         return true;
  312. }
  313.  
  314. bool CXmlScriptSaver::EndTableAt(int elem)
  315. {
  316.         return EndTable(NULL);
  317. }
  318.  
  319. bool CXmlScriptSaver::EndArray(const char* name)
  320. {
  321.         return EndTable(name);
  322. }
  323.  
  324. namespace
  325. {
  326.  
  327. struct CGetValueVisitor
  328. {
  329. public:
  330.         CGetValueVisitor(IScriptTable* pTable, const char* name) : m_ok(false), m_pTable(pTable), m_name(name) {}
  331.  
  332.         template<class T>
  333.         void Visit(T& value)
  334.         {
  335.                 m_ok = m_pTable->GetValue(m_name, value);
  336.         }
  337.  
  338.         template<class T>
  339.         void operator()(T& type)
  340.         {
  341.                 Visit(type);
  342.         }
  343.  
  344.         void operator()(SReadWriteXMLCommon::TValue& var)
  345.         {
  346.                 VisitVariant(var);
  347.         }
  348.  
  349.         bool Ok()
  350.         {
  351.                 return m_ok;
  352.         }
  353.  
  354. private:
  355.         template<size_t I = 0>
  356.         void VisitVariant(SReadWriteXMLCommon::TValue& var)
  357.         {
  358.                 if (var.index() == I)
  359.                 {
  360.                         Visit(stl::get<I>(var));
  361.                 }
  362.                 else
  363.                 {
  364.                         VisitVariant<I + 1>(var);
  365.                 }
  366.         }
  367.  
  368.         bool          m_ok;
  369.         IScriptTable* m_pTable;
  370.         const char*   m_name;
  371. };
  372. template<>
  373. void CGetValueVisitor::VisitVariant<stl::variant_size<SReadWriteXMLCommon::TValue>::value>(SReadWriteXMLCommon::TValue& var)
  374. {
  375.         CRY_ASSERT_MESSAGE(false, "Invalid variant index.");
  376. }
  377.  
  378. struct CGetAtVisitor
  379. {
  380. public:
  381.         CGetAtVisitor(IScriptTable* pTable, int elem) : m_ok(false), m_pTable(pTable), m_elem(elem) {}
  382.  
  383.         template<class T>
  384.         void Visit(T& value)
  385.         {
  386.                 m_ok = m_pTable->GetAt(m_elem, value);
  387.         }
  388.  
  389.         template<class T>
  390.         void operator()(T& type)
  391.         {
  392.                 Visit(type);
  393.         }
  394.  
  395.         void operator()(SReadWriteXMLCommon::TValue& var)
  396.         {
  397.                 VisitVariant(var);
  398.         }
  399.  
  400.         bool Ok()
  401.         {
  402.                 return m_ok;
  403.         }
  404.  
  405. private:
  406.         template<size_t I = 0>
  407.         void VisitVariant(SReadWriteXMLCommon::TValue& var)
  408.         {
  409.                 if (var.index() == I)
  410.                 {
  411.                         Visit(stl::get<I>(var));
  412.                 }
  413.                 else
  414.                 {
  415.                         VisitVariant<I + 1>(var);
  416.                 }
  417.         }
  418.  
  419.         bool          m_ok;
  420.         IScriptTable* m_pTable;
  421.         int           m_elem;
  422. };
  423. template<>
  424. void CGetAtVisitor::VisitVariant<stl::variant_size<SReadWriteXMLCommon::TValue>::value>(SReadWriteXMLCommon::TValue& var)
  425. {
  426.         CRY_ASSERT_MESSAGE(false, "Invalid variant index.");
  427. }
  428. }
  429.  
  430. bool CXmlScriptSaver::GetValue(const char* name, TValue& value, const XmlNodeRef& definition)
  431. {
  432.         CGetValueVisitor visitor(CurTable(), name);
  433.         stl::visit(visitor, value);
  434.         return visitor.Ok();
  435. }
  436.  
  437. bool CXmlScriptSaver::GetAt(int elem, TValue& value, const XmlNodeRef& definition)
  438. {
  439.         CGetAtVisitor visitor(CurTable(), elem);
  440.         stl::visit(visitor, value);
  441.         return visitor.Ok();
  442. }
  443.  
  444. bool CXmlScriptSaver::HaveElemAt(int elem)
  445. {
  446.         ScriptAnyValue value;
  447.         if (CurTable()->GetAtAny(elem, value))
  448.                 if (value.GetVarType() != svtNull)
  449.                         return true;
  450.         return false;
  451. }
  452.  
  453. bool CXmlScriptSaver::HaveValue(const char* name)
  454. {
  455.         ScriptAnyValue value;
  456.         if (CurTable()->GetValueAny(name, value))
  457.                 if (value.GetVarType() != svtNull)
  458.                         return true;
  459.         return false;
  460. }
  461.  
  462. bool CXmlScriptSaver::Complete()
  463. {
  464.         return true;
  465. }
  466.  
  467. CXmlScriptSaver::CXmlScriptSaver(SmartScriptTable pTable) : m_nRefs(0)
  468. {
  469.         m_tables.push(pTable);
  470. }
  471.  
  472. XmlNodeRef XmlScriptSave(const char* definitionFile, SmartScriptTable scriptTable)
  473. {
  474.         CXmlScriptSaverPtr pSaver(new CXmlScriptSaver(scriptTable));
  475.         return GetISystem()->GetXmlUtils()->GetIReadWriteXMLSink()->CreateXMLFromSource(definitionFile, &*pSaver);
  476. }
  477.  
  478. bool XmlScriptSave(const char* definitionFile, const char* dataFile, SmartScriptTable scriptTable)
  479. {
  480.         CXmlScriptSaverPtr pSaver(new CXmlScriptSaver(scriptTable));
  481.         return GetISystem()->GetXmlUtils()->GetIReadWriteXMLSink()->WriteXML(definitionFile, dataFile, &*pSaver);
  482. }
  483.  
downloadXMLScriptLoader.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top