xmlimporter.cs

Perst开源实时数据库

namespace Perst.Impl
{
    using System;
    using System.Collections;
    using System.Reflection;
    using Perst;
	
    public class XMLImporter
    {
        public XMLImporter(StorageImpl storage, System.IO.StreamReader reader)
        {
            this.storage = storage;
            scanner = new XMLScanner(reader);
            classMap = new Hashtable();
        }
		
        public virtual void  importDatabase()
        {
            if (scanner.scan() != XMLScanner.Token.LT || scanner.scan() != XMLScanner.Token.IDENT || !scanner.Identifier.Equals("database"))
            {
                throwException("No root element");
            }
            if (scanner.scan() != XMLScanner.Token.IDENT || !scanner.Identifier.Equals("root") || scanner.scan() != XMLScanner.Token.EQ || scanner.scan() != XMLScanner.Token.SCONST || scanner.scan() != XMLScanner.Token.GT)
            {
                throwException("Database element should have \"root\" attribute");
            }
            int rootId = 0;
            try
            {
                rootId = System.Int32.Parse(scanner.String);
            }
            catch (System.FormatException)
            {
                throwException("Incorrect root object specification");
            }
            idMap = new int[rootId * 2];
            idMap[rootId] = storage.allocateId();
            storage.header.root[1 - storage.currIndex].rootObject = idMap[rootId];
			
            XMLScanner.Token tkn;
            while ((tkn = scanner.scan()) == XMLScanner.Token.LT)
            {
                if (scanner.scan() != XMLScanner.Token.IDENT)
                {
                    throwException("Element name expected");
                }
                System.String elemName = scanner.Identifier;
                if (elemName.StartsWith("Perst.Impl.Btree") 
                    || elemName.StartsWith("Perst.Impl.BitIndexImpl")
                    || elemName.StartsWith("Perst.Impl.PersistentSet") 
                    || elemName.StartsWith("Perst.Impl.BtreeFieldIndex") 
                    || elemName.StartsWith("Perst.Impl.BtreeCompoundIndex") 
                    || elemName.StartsWith("Perst.Impl.BtreeMultiFieldIndex"))
                {
                    createIndex(elemName);
                }
                else
                {
                    createObject(readElement(elemName));
                }
            }
            if (tkn != XMLScanner.Token.LTS || scanner.scan() != XMLScanner.Token.IDENT || !scanner.Identifier.Equals("database") || scanner.scan() != XMLScanner.Token.GT)
            {
                throwException("Root element is not closed");
            }
        }
		
        internal class XMLElement
        {
            internal XMLElement NextSibling
            {
                get
                {
                    return next;
                }
				
            }
            internal int Counter
            {
                get
                {
                    return counter;
                }
				
            }
            internal long IntValue
            {
                get
                {
                    return ivalue;
                }
				
                set
                {
                    ivalue = value;
                    valueType = XMLValueType.INT_VALUE;
                }
				
            }
            internal double RealValue
            {
                get
                {
                    return rvalue;
                }
				
                set
                {
                    rvalue = value;
                    valueType = XMLValueType.REAL_VALUE;
                }
				
            }
            internal String StringValue
            {
                get
                {
                    return svalue;
                }
				
                set
                {
                    svalue = value;
                    valueType = XMLValueType.STRING_VALUE;
                }
				
            }
            internal String Name
            {
                get
                {
                    return name;

                }
            }

            private XMLElement   next;
            private XMLElement   prev;
            private String       name;
            private Hashtable    siblings;
            private Hashtable    attributes;
            private String       svalue;
            private long         ivalue;
            private double       rvalue;
            private XMLValueType valueType;
            private int          counter;
			
            enum XMLValueType 
            { 
                NO_VALUE,
                STRING_VALUE,
                INT_VALUE,
                REAL_VALUE,
                NULL_VALUE
            }
			
            internal XMLElement(System.String name)
            {
                this.name = name;
                valueType = XMLValueType.NO_VALUE;
            }
			
            internal void  addSibling(XMLElement elem)
            {
                if (siblings == null)
                {
                    siblings = new Hashtable();
                }
                XMLElement head = (XMLElement) siblings[elem.name];
                if (head != null)
                {
                    elem.next = null;
                    elem.prev = head.prev;
                    head.prev.next = elem;
                    head.prev = elem;
                    head.counter += 1;
                }
                else
                {
                    elem.prev = elem;
                    siblings[elem.name] = elem;
                    elem.counter = 1;
                }
            }
			
            internal void  addAttribute(System.String name, System.String val)
            {
                if (attributes == null)
                {
                    attributes = new Hashtable();
                }
                attributes[name] = val;
            }
			
            internal XMLElement getSibling(System.String name)
            {
                if (siblings != null)
                {
                    return (XMLElement)siblings[name];
                }
                return null;
            }
			
			
			
            internal System.String getAttribute(System.String name)
            {
                return attributes != null?(System.String) attributes[name]:null;
            }
			
			
			
			
            internal void  setNullValue()
            {
                valueType = XMLValueType.NULL_VALUE;
            }
			
            internal bool isIntValue()
            {
                return valueType == XMLValueType.INT_VALUE;
            }
			
            internal bool isRealValue()
            {
                return valueType == XMLValueType.REAL_VALUE;
            }
			
            internal bool isStringValue()
            {
                return valueType == XMLValueType.STRING_VALUE;
            }
			
            internal bool isNullValue()
            {
                return valueType == XMLValueType.NULL_VALUE;
            }
        }
		
        internal System.String getAttribute(XMLElement elem, String name)
        {
            System.String val = elem.getAttribute(name);
            if (val == null)
            {
                throwException("Attribute " + name + " is not set");
            }
            return val;
        }
		
		
        internal int getIntAttribute(XMLElement elem, String name)
        {
            System.String val = elem.getAttribute(name);
            if (val == null)
            {
                throwException("Attribute " + name + " is not set");
            }
            try
            {
                return System.Int32.Parse(val);
            }
            catch (System.FormatException)
            {
                throwException("Attribute " + name + " should has integer value");
            }
            return - 1;
        }
		
        internal int mapId(int id)
        {
            int oid = 0;
            if (id != 0)
            {
                if (id >= idMap.Length)
                {
                    int[] newMap = new int[id * 2];
                    Array.Copy(idMap, 0, newMap, 0, idMap.Length);
                    idMap = newMap;
                    idMap[id] = oid = storage.allocateId();
                }
                else
                {
                    oid = idMap[id];
                    if (oid == 0)
                    {
                        idMap[id] = oid = storage.allocateId();
                    }
                }
            }
            return oid;
        }
		
        internal ClassDescriptor.FieldType mapType(string signature)
        {
            try 
            { 
#if COMPACT_NET_FRAMEWORK
                return (ClassDescriptor.FieldType)ClassDescriptor.parseEnum(typeof(ClassDescriptor.FieldType), signature);
#else
                return (ClassDescriptor.FieldType)Enum.Parse(typeof(ClassDescriptor.FieldType), signature);
#endif
            } 
            catch (ArgumentException) 
            {
                throwException("Bad type");
                return ClassDescriptor.FieldType.tpObject;
            }
        }

        Key createCompoundKey(ClassDescriptor.FieldType[] types, String[] values) 
        {
            ByteBuffer buf = new ByteBuffer(null);
            int dst = 0;

            for (int i = 0; i < types.Length; i++) 
            { 
                String val = values[i];
                switch (types[i]) 
                { 
                    case ClassDescriptor.FieldType.tpBoolean: