BVB Source Codes

CRYENGINE Show SerializeReaderXMLCPBin.cpp Source code

Return Download CRYENGINE: download SerializeReaderXMLCPBin.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 "SerializeReaderXMLCPBin.h"
  5. #include <CrySystem/ISystem.h>
  6. #include <CryEntitySystem/IEntitySystem.h>
  7.  
  8. static const size_t MAX_NODE_STACK_DEPTH = 40;
  9.  
  10. #define TAG_SCRIPT_VALUE "v"
  11. #define TAG_SCRIPT_TYPE  "t"
  12. #define TAG_SCRIPT_NAME  "n"
  13.  
  14. CSerializeReaderXMLCPBin::CSerializeReaderXMLCPBin(XMLCPB::CNodeLiveReaderRef nodeRef, XMLCPB::CReaderInterface& binReader)
  15.         : m_nErrors(0)
  16.         , m_binReader(binReader)
  17. {
  18.         //m_curTime = gEnv->pTimer->GetFrameStartTime();
  19.         assert(nodeRef.IsValid());
  20.         m_nodeStack.reserve(MAX_NODE_STACK_DEPTH);
  21.         m_nodeStack.push_back(nodeRef);
  22. }
  23.  
  24. //////////////////////////////////////////////////////////////////////////
  25.  
  26. bool CSerializeReaderXMLCPBin::Value(const char* name, ScriptAnyValue& value)
  27. {
  28.         DefaultValue(value); // Set input value to default.
  29.         if (m_nErrors)
  30.                 return false;
  31.  
  32.         XMLCPB::CNodeLiveReaderRef nodeRef = CurNode()->GetChildNode(name);
  33.         if (!nodeRef.IsValid())
  34.         {
  35.                 CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "Unable to read attribute %s (invalid type?)", name);
  36.                 Failed();
  37.                 return false;
  38.         }
  39.         else if (!ReadScript(nodeRef, value))
  40.                 Failed();
  41.         return true;
  42. }
  43.  
  44. //////////////////////////////////////////////////////////////////////////
  45.  
  46. bool CSerializeReaderXMLCPBin::ReadScript(XMLCPB::CNodeLiveReaderRef nodeRef, ScriptAnyValue& value)
  47. {
  48.         if (m_nErrors)
  49.                 return false;
  50.         const char* type;
  51.         nodeRef->ReadAttr(TAG_SCRIPT_TYPE, type);
  52.         bool convertOk = false;
  53.         if (0 == strcmp(type, "nil"))
  54.         {
  55.                 value = ScriptAnyValue();
  56.                 convertOk = true;
  57.         }
  58.         else if (0 == strcmp(type, "b"))
  59.         {
  60.                 bool x = false;
  61.                 convertOk = nodeRef->ReadAttr(TAG_SCRIPT_VALUE, x);
  62.                 value = ScriptAnyValue(x);
  63.         }
  64.         else if (0 == strcmp(type, "h"))
  65.         {
  66.                 ScriptHandle x;
  67.  
  68.                 // We are always reading uint64 for handles. In x86, this is a bit inefficient. But when dealing
  69.                 //      with writing in x86 and reading in x64 (or vice versa), this ensures we don't have to guess which DWORD
  70.                 //      to cast from when reading (especially for Endian).
  71.                 uint64 handle = 0;
  72.                 convertOk = nodeRef->ReadAttr(TAG_SCRIPT_VALUE, handle);
  73.                 x.n = (UINT_PTR)handle;
  74.  
  75.                 value = ScriptAnyValue(x);
  76.         }
  77.         else if (0 == strcmp(type, "n"))
  78.         {
  79.                 float x;
  80.                 convertOk = nodeRef->ReadAttr(TAG_SCRIPT_VALUE, x);
  81.                 value = ScriptAnyValue(x);
  82.         }
  83.         else if (0 == strcmp(type, "s"))
  84.         {
  85.                 convertOk = nodeRef->HaveAttr(TAG_SCRIPT_VALUE);
  86.                 const char* pVal = NULL;
  87.                 nodeRef->ReadAttr(TAG_SCRIPT_VALUE, pVal);
  88.                 value = ScriptAnyValue(pVal);
  89.         }
  90.         else if (0 == strcmp(type, "vec"))
  91.         {
  92.                 Vec3 x;
  93.                 convertOk = nodeRef->ReadAttr(TAG_SCRIPT_VALUE, x);
  94.                 value = ScriptAnyValue(x);
  95.         }
  96.         else if (0 == strcmp(type, "entityId"))
  97.         {
  98.                 EntityId id;
  99.                 SmartScriptTable tbl;
  100.                 if (nodeRef->ReadAttr(TAG_SCRIPT_VALUE, id))
  101.                         if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(id))
  102.                                 tbl = pEntity->GetScriptTable();
  103.                 convertOk = tbl.GetPtr() != 0;
  104.                 if (convertOk)
  105.                         value = ScriptAnyValue(tbl);
  106.         }
  107.         else if (0 == strcmp(type, "table"))
  108.         {
  109.                 if (nodeRef->HaveAttr("count"))
  110.                 {
  111.                         int arrayCount = 0;
  112.                         nodeRef->ReadAttr("count", arrayCount);
  113.                         int childCount = nodeRef->GetNumChildren();
  114.                         int arrayIndex = 0;
  115.                         SmartScriptTable tbl;
  116.                         if (value.type == ANY_TTABLE && value.table)
  117.                                 tbl = value.table;
  118.                         else
  119.                                 tbl = SmartScriptTable(gEnv->pScriptSystem);
  120.                         int nCount = min(arrayCount, childCount);
  121.                         for (int i = 0; i < nCount; i++)
  122.                         {
  123.                                 XMLCPB::CNodeLiveReaderRef childRef = nodeRef->GetChildNode(i);
  124.                                 ScriptAnyValue elemValue;
  125.                                 ++arrayIndex;
  126.                                 tbl->GetAtAny(arrayIndex, elemValue);
  127.                                 if (!ReadScript(childRef, elemValue))
  128.                                         return false;
  129.                                 tbl->SetAtAny(arrayIndex, elemValue);
  130.                         }
  131.                         while (arrayIndex <= arrayCount)
  132.                                 tbl->SetNullAt(++arrayIndex);
  133.                         value = SmartScriptTable(tbl);
  134.                         convertOk = true;
  135.                 }
  136.                 else
  137.                 {
  138.                         int childCount = nodeRef->GetNumChildren();
  139.                         SmartScriptTable tbl;
  140.                         if (value.type == ANY_TTABLE && value.table)
  141.                                 tbl = value.table;
  142.                         else
  143.                                 tbl = SmartScriptTable(gEnv->pScriptSystem);
  144.                         for (int i = 0; i < childCount; i++)
  145.                         {
  146.                                 XMLCPB::CNodeLiveReaderRef childRef = nodeRef->GetChildNode(i);
  147.                                 ScriptAnyValue elemValue;
  148.                                 const char* elemName = NULL;
  149.                                 childRef->ReadAttr(TAG_SCRIPT_NAME, elemName);
  150.                                 tbl->GetValueAny(elemName, elemValue);
  151.                                 if (!ReadScript(childRef, elemValue))
  152.                                         return false;
  153.                                 tbl->SetValueAny(elemName, elemValue);
  154.                         }
  155.                         value = SmartScriptTable(tbl);
  156.                         convertOk = true;
  157.                 }
  158.         }
  159.         else
  160.         {
  161.                 //CryWarning( VALIDATOR_MODULE_SYSTEM,VALIDATOR_WARNING,"Unknown script type '%s' for value '%s'", type, value);
  162.                 CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "Unknown script type '%s'", type);
  163.                 return false;
  164.         }
  165.         if (!convertOk)
  166.         {
  167.                 if (nodeRef->HaveAttr(TAG_SCRIPT_VALUE))
  168.                 {
  169.                         string val;
  170.                         nodeRef->ReadAttrAsString(TAG_SCRIPT_VALUE, val);
  171.                         CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "Couldn't convert '%s' to type '%s'", val.c_str(), type);
  172.                 }
  173.                 else
  174.                         CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "No 'value' tag for value of type '%s'", type);
  175.                 return false;
  176.         }
  177.         return true;
  178. }
  179.  
  180. bool CSerializeReaderXMLCPBin::Value(const char* name, int8& value)
  181. {
  182.         DefaultValue(value); // Set input value to default.
  183.         if (m_nErrors)
  184.                 return false;
  185.         int temp;
  186.         bool bResult = Value(name, temp);
  187.         if (temp < -128 || temp > 127)
  188.         {
  189.                 CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "Attribute %s is out of range (%d)", name, temp);
  190.                 Failed();
  191.                 bResult = false;
  192.         }
  193.         else
  194.                 value = temp;
  195.         return bResult;
  196. }
  197.  
  198. bool CSerializeReaderXMLCPBin::Value(const char* name, string& value)
  199. {
  200.         DefaultValue(value); // Set input value to default.
  201.         if (m_nErrors)
  202.                 return false;
  203.         if (!CurNode()->HaveAttr(name))
  204.         {
  205.                 // the attrs are not saved if they already had the default value
  206.                 return false;
  207.         }
  208.         else
  209.         {
  210.                 const char* pVal = NULL;
  211.                 CurNode()->ReadAttr(name, pVal);
  212.                 value = pVal;
  213.         }
  214.         return true;
  215. }
  216.  
  217. bool CSerializeReaderXMLCPBin::Value(const char* name, CTimeValue& value)
  218. {
  219.         DefaultValue(value); // Set input value to default.
  220.         if (m_nErrors)
  221.                 return false;
  222.         XMLCPB::CNodeLiveReaderRef nodeRef = CurNode();
  223.         if (!nodeRef.IsValid())
  224.                 return false;
  225.  
  226.         const char* pVal = NULL;
  227.         if (nodeRef->HaveAttr(name) && nodeRef->ObtainAttr(name).GetBasicDataType() == XMLCPB::DT_STR)
  228.                 nodeRef->ReadAttr(name, pVal);
  229.  
  230.         bool isZero = pVal ? 0 == strcmp("zero", pVal) : false;
  231.  
  232.         if (isZero)
  233.                 value = CTimeValue(0.0f);
  234.         else
  235.         {
  236.                 float delta;
  237.                 if (!GetAttr(nodeRef, name, delta))
  238.                 {
  239.                         value = gEnv->pTimer->GetFrameStartTime(); // in case we don't find the node, it was assumed to be the default value (0.0)
  240.                         // 0.0 means current time, whereas "zero" really means CTimeValue(0.0), see above
  241.                         return false;
  242.                 }
  243.                 else
  244.                 {
  245.                         value = CTimeValue(gEnv->pTimer->GetFrameStartTime() + delta);
  246.                 }
  247.         }
  248.         return true;
  249. }
  250.  
  251. void CSerializeReaderXMLCPBin::RecursiveReadIntoXmlNodeRef(XMLCPB::CNodeLiveReaderRef BNode, XmlNodeRef& xmlNode)
  252. {
  253.         for (int i = 0; i < BNode->GetNumAttrs(); ++i)
  254.         {
  255.                 XMLCPB::CAttrReader attr = BNode->ObtainAttr(i);
  256.                 const char* pVal = NULL;
  257.                 attr.Get(pVal);
  258.                 xmlNode->setAttr(attr.GetName(), pVal);
  259.         }
  260.  
  261.         for (int i = 0; i < BNode->GetNumChildren(); ++i)
  262.         {
  263.                 XMLCPB::CNodeLiveReaderRef BChild = BNode->GetChildNode(i);
  264.                 XmlNodeRef child = xmlNode->createNode(BChild->GetTag());
  265.                 xmlNode->addChild(child);
  266.                 RecursiveReadIntoXmlNodeRef(BChild, child);
  267.         }
  268. }
  269.  
  270. bool CSerializeReaderXMLCPBin::Value(const char* name, XmlNodeRef& value)
  271. {
  272.         XMLCPB::CNodeLiveReaderRef BNode = CurNode()->GetChildNode(name);
  273.  
  274.         if (value)
  275.         {
  276.                 value->removeAllAttributes();
  277.                 value->removeAllChilds();
  278.         }
  279.  
  280.         if (!BNode.IsValid())
  281.         {
  282.                 value = NULL;
  283.                 return false;
  284.         }
  285.  
  286.         assert(BNode->GetNumChildren() == 1);
  287.         BNode = BNode->GetChildNode(uint32(0));
  288.  
  289.         if (!value)
  290.                 value = GetISystem()->CreateXmlNode(BNode->GetTag());
  291.  
  292.         RecursiveReadIntoXmlNodeRef(BNode, value);
  293.  
  294.         return true;
  295. }
  296.  
  297. bool CSerializeReaderXMLCPBin::ValueByteArray(const char* name, uint8*& rdata, uint32& outSize)
  298. {
  299.         DefaultValue(rdata, outSize);
  300.         if (m_nErrors)
  301.                 return false;
  302.         if (!CurNode()->HaveAttr(name))
  303.         {
  304.                 // the attrs are not saved if they already had the default value
  305.                 return false;
  306.         }
  307.         else
  308.         {
  309.                 assert(outSize == 0);
  310.                 CurNode()->ReadAttr(name, rdata, outSize);
  311.         }
  312.         return true;
  313. }
  314.  
  315. void CSerializeReaderXMLCPBin::DefaultValue(uint8*& rdata, uint32& outSize) const
  316. {
  317.         // rdata remains untouched. If the attribute is found in ReadAttr, it'll be realloced to match the new size.
  318.         //      outSize is set to 0, so if no data is found, we return back a 0'd amount read. rdata will still contain its
  319.         //      previous data, to cut down on memory fragmentation for future reads.
  320.         outSize = 0;
  321. }
  322.  
  323. //////////////////////////////////////////////////////////////////////////
  324.  
  325. void CSerializeReaderXMLCPBin::BeginGroup(const char* szName)
  326. {
  327.         if (m_nErrors)
  328.         {
  329.                 m_nErrors++;
  330.         }
  331.         else
  332.         {
  333.                 XMLCPB::CNodeLiveReaderRef node = CurNode()->GetChildNode(szName);
  334.                 if (node.IsValid())
  335.                 {
  336.                         m_nodeStack.push_back(node);
  337.                 }
  338.                 else
  339.                 {
  340.                         CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "!BeginGroup( %s ) not found", szName);
  341.                         m_nErrors++;
  342.                 }
  343.         }
  344. }
  345.  
  346. bool CSerializeReaderXMLCPBin::BeginOptionalGroup(const char* szName, bool condition)
  347. {
  348.         if (m_nErrors)
  349.         {
  350.                 m_nErrors++;
  351.         }
  352.         XMLCPB::CNodeLiveReaderRef node = CurNode()->GetChildNode(szName);
  353.         if (node.IsValid())
  354.         {
  355.                 m_nodeStack.push_back(node);
  356.                 return true;
  357.         }
  358.         else
  359.                 return false;
  360. }
  361.  
  362. void CSerializeReaderXMLCPBin::EndGroup()
  363. {
  364.         if (m_nErrors)
  365.                 m_nErrors--;
  366.         else
  367.         {
  368.                 m_nodeStack.pop_back();
  369.         }
  370.         assert(!m_nodeStack.empty());
  371. }
  372.  
  373. //////////////////////////////////////////////////////////////////////////
  374. const char* CSerializeReaderXMLCPBin::GetStackInfo() const
  375. {
  376.         static string str;
  377.         str.assign("");
  378.         for (int i = 0; i < (int)m_nodeStack.size(); i++)
  379.         {
  380.                 const char* name;
  381.                 m_nodeStack[i]->ReadAttr(TAG_SCRIPT_NAME, name);
  382.                 if (name && name[0])
  383.                         str += name;
  384.                 else
  385.                         str += m_nodeStack[i]->GetTag();
  386.                 if (i != m_nodeStack.size() - 1)
  387.                         str += "/";
  388.         }
  389.         return str.c_str();
  390. }
  391.  
downloadSerializeReaderXMLCPBin.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