Пример #1
0
        /// <summary>
        /// Load a Cry Binary XML buffer into memory and return the NodeRef for the root element
        /// </summary>
        /// <param name="filename">The byte buffer to read</param>
        /// <param name="result">Read result</param>
        /// <returns>The NodeRef of the root element or NULL</returns>
        public CryXmlNodeRef LoadFromBuffer(byte[] binBuffer, out EResult result)
        {
            m_errorDescription = "";
            result             = EResult.Error;

            UInt32 fileSize = ( UInt32 )binBuffer.Length;

            try {
                if (fileSize < CryXMLHeader.MySize( ))
                {
                    result = EResult.NotBinXml;
                    SetErrorDescription("File is not a binary XML file (file size is too small).");
                    return(null);
                }

                // read from binary file and map the content into the memory
                CryXmlBinContext pData = Create(binBuffer, out result);

                if (result != EResult.Success)
                {
                    return(null);                     // Well...
                }
                // Return first node
                CryXmlNodeRef n = pData.pBinaryNodes[0];
                return(n);
            } catch {
                result = EResult.NotBinXml;
                SetErrorDescription("Exception in buffer reader");
                return(null);
            }
        }
Пример #2
0
        /// <summary>
        /// Load a Cry Binary XML file into memory and return the NodeRef for the root element
        /// </summary>
        /// <param name="filename">The file to read</param>
        /// <param name="result">Read result</param>
        /// <returns>The NodeRef of the root element or NULL</returns>
        public CryXmlNodeRef LoadFromFile(string filename, out EResult result)
        {
            m_errorDescription = "";
            result             = EResult.Error;

            if (!File.Exists(filename))
            {
                SetErrorDescription("Can't open file (file not found).");
                return(null);
            }

            using (BinaryReader binReader = new BinaryReader(File.Open(filename, FileMode.Open))) {
                try {
                    UInt32 fileSize = ( UInt32 )binReader.BaseStream.Length;

                    if (fileSize < CryXMLHeader.MySize( ))
                    {
                        result = EResult.NotBinXml;
                        SetErrorDescription("File is not a binary XML file (file size is too small).");
                        return(null);
                    }

                    // read from binary file and map the content into the memory
                    CryXmlBinContext pData = Create(binReader, fileSize, out result);

                    if (result != EResult.Success)
                    {
                        return(null);                   // Well...
                    }
                    // Return first node
                    CryXmlNodeRef n = pData.pBinaryNodes[0];
                    return(n);
                } catch {
                    result = EResult.NotBinXml;
                    SetErrorDescription("Exception in BinaryReader.");
                    return(null);
                }
            }
        }
Пример #3
0
        /// <summary>
        /// Reads the binary buffer into the internal structures
        ///  Note: use GetErrorDescription() if the result is not Success
        /// </summary>
        /// <param name="fileContents">An filled byte buffer</param>
        /// <param name="result">Out: the result of the collection of file content</param>
        /// <returns>A valid memory context or null</returns>
        private CryXmlBinContext Create(byte[] fileContents, out EResult result)
        {
            result = EResult.Error;

            CryXmlBinContext pData = new CryXmlBinContext( );

            if (pData == null)
            {
                SetErrorDescription("Can't allocate memory for binary XML object.");
                return(null);
            }

            CryXMLHeader header = Conversions.ByteToType <CryXMLHeader>(fileContents); // reads the header, mapping from binary to struct

            if (!header.HasCorrectSignature)
            {
                SetErrorDescription("File is not a binary XML object (wrong header signature).");
                return(null);
            }

            // Create binary nodes to wrap the ones to read later
            pData.pBinaryNodes = new List <CryXmlBinNode>( ); // dynamic list used, not an array
            for (int i = 0; i < header.nNodeCount; i++)
            {
                pData.pBinaryNodes.Add(new CryXmlBinNode( ));
            }

            // map file content to binary.. here we really allocate arrays of elements and copy rather than the original which worked well with ptrs in c++

            try {
                pData.pAttributes = ( CryXMLAttribute[] )Array.CreateInstance(typeof(CryXMLAttribute), header.nAttributeCount); // alloc enough
                UInt32 incr = CryXMLAttribute.MySize( );                                                                        // size of one element to read
                for (UInt32 aIdx = 0; aIdx < header.nAttributeCount; aIdx++)
                {
                    pData.pAttributes[aIdx] = Conversions.ByteToType <CryXMLAttribute>(fileContents, header.nAttributeTablePosition + aIdx * incr);
                }
            } catch (Exception e) {
                SetErrorDescription(string.Format("EXC Attributes: {0}", e.Message));
                return(null);
            }

            try {
                pData.pChildIndices = ( CryXMLNodeIndex[] )Array.CreateInstance(typeof(CryXMLNodeIndex), header.nChildCount); // alloc enough
                UInt32 incr = CryXMLNodeIndex.MySize( );                                                                      // size of one element to read
                for (UInt32 aIdx = 0; aIdx < header.nChildCount; aIdx++)
                {
                    pData.pChildIndices[aIdx] = Conversions.ByteToType <CryXMLNodeIndex>(fileContents, header.nChildTablePosition + aIdx * incr);
                }
            } catch (Exception e) {
                SetErrorDescription(string.Format("EXC ChildIndices: {0}", e.Message));
                return(null);
            }

            try {
                pData.pNodes = ( CryXMLNode[] )Array.CreateInstance(typeof(CryXMLNode), header.nNodeCount); // alloc enough
                UInt32 incr = CryXMLNode.MySize( );                                                         // size of one element to read
                for (UInt32 aIdx = 0; aIdx < header.nNodeCount; aIdx++)
                {
                    pData.pNodes[aIdx] = Conversions.ByteToType <CryXMLNode>(fileContents, header.nNodeTablePosition + aIdx * incr);
                }
            } catch (Exception e) {
                SetErrorDescription(string.Format("EXC Nodes: {0}", e.Message));
                return(null);
            }

            try {
                pData.pStringDataLength = header.nStringDataSize;
                pData.pStringData       = fileContents.SliceL(header.nStringDataPosition, header.nStringDataSize);
            } catch (Exception e) {
                SetErrorDescription(string.Format("EXC StringData: {0}", e.Message));
                return(null);
            }

            // init binary nodes
            for (UInt32 nNode = 0; nNode < header.nNodeCount; ++nNode)
            {
                pData.pBinaryNodes[( int )nNode].m_pData      = pData; // add data space
                pData.pBinaryNodes[( int )nNode].m_pNodeIndex = nNode; // self ref..
            }

            // and back..
            result = EResult.Success;
            return(pData);
        }