예제 #1
0
        internal int UnpackObject(object obj, ClassDescriptor desc, bool recursiveLoading, byte[] body, int offs, IPersistent po)
        {
            ClassDescriptor.FieldDescriptor[] all = desc.allFields;
            ReflectionProvider provider = ClassDescriptor.ReflectionProvider;
            int len;

            for (int i = 0, n = all.Length; i < n; i++)
            {
                ClassDescriptor.FieldDescriptor fd = all[i];
                FieldInfo f = fd.field;

                if (f == null || obj == null)
                {
                    switch (fd.type)
                    {
                        case ClassDescriptor.tpBoolean:
                        case ClassDescriptor.tpByte:
                            offs += 1;
                            continue;

                        case ClassDescriptor.tpChar:
                        case ClassDescriptor.tpShort:
                            offs += 2;
                            continue;

                        case ClassDescriptor.tpInt:
                        case ClassDescriptor.tpFloat:
                        case ClassDescriptor.tpObject:
                            offs += 4;
                            continue;

                        case ClassDescriptor.tpLong:
                        case ClassDescriptor.tpDouble:
                        case ClassDescriptor.tpDate:
                            offs += 8;
                            continue;

                        case ClassDescriptor.tpString:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len > 0)
                            {
                                offs += len * 2;
                            }
                            else if (len < -1)
                            {
                                offs -= (len + 2);
                            }
                            continue;

                        case ClassDescriptor.tpValue:
                            offs = UnpackObject((object) null, fd.valueDesc, recursiveLoading, body, offs, po);
                            continue;

                        case ClassDescriptor.tpRaw:
                        case ClassDescriptor.tpArrayOfByte:
                        case ClassDescriptor.tpArrayOfBoolean:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len > 0)
                            {
                                offs += len;
                            }
                            else if (len < -1)
                            {
                                offs += ClassDescriptor.Sizeof[-2 - len];
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfShort:
                        case ClassDescriptor.tpArrayOfChar:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len > 0)
                            {
                                offs += len * 2;
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfInt:
                        case ClassDescriptor.tpArrayOfFloat:
                        case ClassDescriptor.tpArrayOfObject:
                        case ClassDescriptor.tpLink:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len > 0)
                            {
                                offs += len * 4;
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfLong:
                        case ClassDescriptor.tpArrayOfDouble:
                        case ClassDescriptor.tpArrayOfDate:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len > 0)
                            {
                                offs += len * 8;
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfString:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len > 0)
                            {
                                for (int j = 0; j < len; j++)
                                {
                                    int strlen = Bytes.Unpack4(body, offs);
                                    offs += 4;
                                    if (strlen > 0)
                                    {
                                        offs += strlen * 2;
                                    }
                                    else if (strlen < -1)
                                    {
                                        offs -= (strlen + 2);
                                    }
                                }
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfValue:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len > 0)
                            {
                                ClassDescriptor valueDesc = fd.valueDesc;
                                for (int j = 0; j < len; j++)
                                {
                                    offs = UnpackObject((object) null, valueDesc, recursiveLoading, body, offs, po);
                                }
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfRaw:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len > 0)
                            {
                                for (int j = 0; j < len; j++)
                                {
                                    int rawlen = Bytes.Unpack4(body, offs);
                                    offs += 4;
                                    if (rawlen > 0)
                                    {
                                        offs += rawlen;
                                    }
                                    else if (rawlen < -1)
                                    {
                                        offs += ClassDescriptor.Sizeof[-2 - rawlen];
                                    }
                                }
                            }
                            continue;
                        }
                }
                else
                {
                    switch (fd.type)
                    {
                        case ClassDescriptor.tpBoolean:
                            provider.SetBoolean(f, obj, body[offs++] != 0);
                            continue;

                        case ClassDescriptor.tpByte:
                            provider.SetByte(f, obj, body[offs++]);
                            continue;

                        case ClassDescriptor.tpChar:
                            provider.SetChar(f, obj, (char) Bytes.Unpack2(body, offs));
                            offs += 2;
                            continue;

                        case ClassDescriptor.tpShort:
                            provider.SetShort(f, obj, Bytes.Unpack2(body, offs));
                            offs += 2;
                            continue;

                        case ClassDescriptor.tpInt:
                            provider.SetInt(f, obj, Bytes.Unpack4(body, offs));
                            offs += 4;
                            continue;

                        case ClassDescriptor.tpLong:
                            provider.SetLong(f, obj, Bytes.Unpack8(body, offs));
                            offs += 8;
                            continue;

                        case ClassDescriptor.tpFloat:
                            provider.SetFloat(f, obj, Bytes.UnpackF4(body, offs));
                            offs += 4;
                            continue;

                        case ClassDescriptor.tpDouble:
                            provider.SetDouble(f, obj, Bytes.UnpackF8(body, offs));
                            offs += 8;
                            continue;

                        case ClassDescriptor.tpString:
                        {
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            string str = null;
                            if (len >= 0)
                            {
                                char[] chars = new char[len];
                                for (int j = 0; j < len; j++)
                                {
                                    chars[j] = (char) Bytes.Unpack2(body, offs);
                                    offs += 2;
                                }
                                str = new string(chars);
                            }
                            else if (len < -1)
                            {
                                if (encoding != null)
                                {
                                    string tempStr;
                                    //UPGRADE_TODO: The differences in the Format of parameters for constructor 'java.lang.String.String' may cause compilation errors.
                                    tempStr = System.Text.Encoding.GetEncoding(encoding).GetString(body);
                                    str = new string(tempStr.ToCharArray(), offs, -2 - len);
                                }
                                else
                                {
                                    str = new string(SupportClass.ToCharArray(body), offs, -2 - len);
                                }
                                offs -= (2 + len);
                            }
                            provider.Set(f, obj, str);
                            continue;
                        }

                        case ClassDescriptor.tpDate:
                        {
                            long msec = Bytes.Unpack8(body, offs);
                            offs += 8;
                            //UPGRADE_TODO: The 'System.DateTime' structure does not have an equivalent to NULL.
                            DateTime date; // = null;
                            if (msec >= 0)
                            {
                                //UPGRADE_TODO: Constructor 'java.util.Date.Date' was converted to 'DateTime.DateTime' which has a different behavior.
                                date = new DateTime(msec);
                            }
                            else
                                date = new DateTime();
                            provider.Set(f, obj, date);
                            continue;
                        }

                        case ClassDescriptor.tpObject:
                        {
                            provider.Set(f, obj, Unswizzle(Bytes.Unpack4(body, offs), f.FieldType, recursiveLoading));
                            offs += 4;
                            continue;
                        }

                        case ClassDescriptor.tpValue:
                        {
                            object val = fd.valueDesc.NewInstance();
                            offs = UnpackObject(val, fd.valueDesc, recursiveLoading, body, offs, po);
                            provider.Set(f, obj, val);
                            continue;
                        }

                        case ClassDescriptor.tpRaw:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len >= 0)
                            {
                                System.IO.MemoryStream streamIn = new System.IO.MemoryStream(body, offs, len);
                                BinaryFormatter formatter = new BinaryFormatter();
                                object val = formatter.Deserialize(streamIn);
                                provider.Set(f, obj, val);
                                streamIn.Close();
                                offs += len;
                            }
                            else if (len < 0)
                            {
                                object val = null;
                                switch (-2 - len)
                                {
                                    case ClassDescriptor.tpBoolean:
                                        val = Convert.ToBoolean(body[offs++]);
                                        break;

                                    case ClassDescriptor.tpByte:
                                        val = (byte) body[offs++];
                                        break;

                                    case ClassDescriptor.tpChar:
                                        val = (char) Bytes.Unpack2(body, offs);
                                        offs += 2;
                                        break;

                                    case ClassDescriptor.tpShort:
                                        val = (short) Bytes.Unpack2(body, offs);
                                        offs += 2;
                                        break;

                                    case ClassDescriptor.tpInt:
                                        val = (Int32) Bytes.Unpack4(body, offs);
                                        offs += 4;
                                        break;

                                    case ClassDescriptor.tpLong:
                                        val = (long) Bytes.Unpack8(body, offs);
                                        offs += 8;
                                        break;

                                    case ClassDescriptor.tpFloat:
                                        val = Bytes.UnpackF4(body, offs);
                                        break;

                                    case ClassDescriptor.tpDouble:
                                        val = Bytes.UnpackF8(body, offs);
                                        offs += 8;
                                        break;

                                    case ClassDescriptor.tpDate:
                                        //UPGRADE_TODO: Constructor 'java.util.Date.Date' was converted to 'DateTime.DateTime' which has a different behavior.
                                        val = new DateTime(Bytes.Unpack8(body, offs));
                                        offs += 8;
                                        break;

                                    case ClassDescriptor.tpObject:
                                        val = Unswizzle(Bytes.Unpack4(body, offs), typeof(Persistent), recursiveLoading);
                                        offs += 4;
                                        break;
                                    }
                                provider.Set(f, obj, val);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfByte:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                byte[] arr = new byte[len];
                                Array.Copy(body, offs, arr, 0, len);
                                offs += len;
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfBoolean:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                bool[] arr = new bool[len];
                                for (int j = 0; j < len; j++)
                                {
                                    arr[j] = body[offs++] != 0;
                                }
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfShort:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                short[] arr = new short[len];
                                for (int j = 0; j < len; j++)
                                {
                                    arr[j] = Bytes.Unpack2(body, offs);
                                    offs += 2;
                                }
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfChar:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                char[] arr = new char[len];
                                for (int j = 0; j < len; j++)
                                {
                                    arr[j] = (char) Bytes.Unpack2(body, offs);
                                    offs += 2;
                                }
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfInt:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                int[] arr = new int[len];
                                for (int j = 0; j < len; j++)
                                {
                                    arr[j] = Bytes.Unpack4(body, offs);
                                    offs += 4;
                                }
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfLong:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                long[] arr = new long[len];
                                for (int j = 0; j < len; j++)
                                {
                                    arr[j] = Bytes.Unpack8(body, offs);
                                    offs += 8;
                                }
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfFloat:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                float[] arr = new float[len];
                                for (int j = 0; j < len; j++)
                                {
                                    arr[j] = Bytes.UnpackF4(body, offs);
                                    offs += 4;
                                }
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfDouble:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                double[] arr = new double[len];
                                for (int j = 0; j < len; j++)
                                {
                                    arr[j] = Bytes.UnpackF8(body, offs);
                                    offs += 8;
                                }
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfDate:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                DateTime[] arr = new DateTime[len];
                                for (int j = 0; j < len; j++)
                                {
                                    long msec = Bytes.Unpack8(body, offs);
                                    offs += 8;
                                    if (msec >= 0)
                                    {
                                        //UPGRADE_TODO: Constructor 'java.util.Date.Date' was converted to 'DateTime.DateTime' which has a different behavior.
                                        arr[j] = new DateTime(msec);
                                    }
                                }
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfString:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                string[] arr = new string[len];
                                for (int j = 0; j < len; j++)
                                {
                                    int strlen = Bytes.Unpack4(body, offs);
                                    offs += 4;
                                    if (strlen >= 0)
                                    {
                                        char[] chars = new char[strlen];
                                        for (int k = 0; k < strlen; k++)
                                        {
                                            chars[k] = (char) Bytes.Unpack2(body, offs);
                                            offs += 2;
                                        }
                                        arr[j] = new string(chars);
                                    }
                                    else if (strlen < -1)
                                    {
                                        if (encoding != null)
                                        {
                                            string tempStr2;
                                            //UPGRADE_TODO: The differences in the Format of parameters for constructor 'java.lang.String.String' may cause compilation errors.
                                            tempStr2 = System.Text.Encoding.GetEncoding(encoding).GetString(body);
                                            arr[j] = new string(tempStr2.ToCharArray(), offs, -2 - strlen);
                                        }
                                        else
                                        {
                                            arr[j] = new string(SupportClass.ToCharArray(body), offs, -2 - strlen);
                                        }
                                        offs -= (2 + strlen);
                                    }
                                }
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfObject:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                Type elemType = f.FieldType.GetElementType();
                                IPersistent[] arr = (IPersistent[]) System.Array.CreateInstance(elemType, len);
                                for (int j = 0; j < len; j++)
                                {
                                    arr[j] = Unswizzle(Bytes.Unpack4(body, offs), elemType, recursiveLoading);
                                    offs += 4;
                                }
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfValue:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                Type elemType = f.FieldType.GetElementType();
                                object[] arr = (object[]) System.Array.CreateInstance(elemType, len);
                                ClassDescriptor valueDesc = fd.valueDesc;
                                for (int j = 0; j < len; j++)
                                {
                                    object val = valueDesc.NewInstance();
                                    offs = UnpackObject(val, valueDesc, recursiveLoading, body, offs, po);
                                    arr[j] = val;
                                }
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpArrayOfRaw:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                Type elemType = f.FieldType.GetElementType();
                                object[] arr = (object[]) System.Array.CreateInstance(elemType, len);
                                for (int j = 0; j < len; j++)
                                {
                                    int rawlen = Bytes.Unpack4(body, offs);
                                    offs += 4;
                                    if (rawlen >= 0)
                                    {
                                        // TODOPORT:
                                        System.IO.MemoryStream streamIn = new System.IO.MemoryStream(body, offs, rawlen);
                                        //UPGRADE_TODO: Class 'java.io.ObjectInputStream' was converted to 'System.IO.BinaryReader' which has a different behavior.
                                        //System.IO.BinaryReader streamIn = new PersistentObjectInputStream(this, bin);
                                        //UPGRADE_WARNING: Method 'java.io.ObjectInputStream.readObject' was converted to 'SupportClass.Deserialize' which may throw an exception.
                                        BinaryFormatter formatter = new BinaryFormatter();
                                        object val = formatter.Deserialize(streamIn);
                                        arr[j] = val;
                                        streamIn.Close();
                                        offs += rawlen;
                                    }
                                    else
                                    {
                                        object val = null;
                                        switch (-2 - rawlen)
                                        {
                                            case ClassDescriptor.tpBoolean:
                                                val = Convert.ToBoolean(body[offs++]);
                                                break;

                                            case ClassDescriptor.tpByte:
                                                val = (byte) body[offs++];
                                                break;

                                            case ClassDescriptor.tpChar:
                                                val = (char) Bytes.Unpack2(body, offs);
                                                offs += 2;
                                                break;

                                            case ClassDescriptor.tpShort:
                                                val = (short) Bytes.Unpack2(body, offs);
                                                offs += 2;
                                                break;

                                            case ClassDescriptor.tpInt:
                                                val = (Int32) Bytes.Unpack4(body, offs);
                                                offs += 4;
                                                break;

                                            case ClassDescriptor.tpLong:
                                                val = (long) Bytes.Unpack8(body, offs);
                                                offs += 8;
                                                break;

                                            case ClassDescriptor.tpFloat:
                                                val = Bytes.UnpackF4(body, offs);
                                                offs += 4;
                                                break;

                                            case ClassDescriptor.tpDouble:
                                                val = Bytes.UnpackF8(body, offs);
                                                offs += 8;
                                                break;

                                            case ClassDescriptor.tpDate:
                                                //UPGRADE_TODO: Constructor 'java.util.Date.Date' was converted to 'DateTime.DateTime' which has a different behavior.
                                                val = new DateTime(Bytes.Unpack8(body, offs));
                                                offs += 8;
                                                break;

                                            case ClassDescriptor.tpObject:
                                                val = Unswizzle(Bytes.Unpack4(body, offs), typeof(Persistent), recursiveLoading);
                                                offs += 4;
                                                break;
                                            }
                                        arr[j] = val;
                                    }
                                }
                                provider.Set(f, obj, arr);
                            }
                            continue;

                        case ClassDescriptor.tpLink:
                            len = Bytes.Unpack4(body, offs);
                            offs += 4;
                            if (len < 0)
                            {
                                provider.Set(f, obj, (object) null);
                            }
                            else
                            {
                                IPersistent[] arr = new IPersistent[len];
                                for (int j = 0; j < len; j++)
                                {
                                    int elemOid = Bytes.Unpack4(body, offs);
                                    offs += 4;
                                    if (elemOid != 0)
                                    {
                                        arr[j] = new PersistentStub(this, elemOid);
                                    }
                                }
                                provider.Set(f, obj, new LinkImpl(arr, po));
                            }
                            break;
                        }
                }
            }
            return offs;
        }
예제 #2
0
 public virtual void Close()
 {
     lock (backgroundGcMonitor)
     {
         Commit();
         opened = false;
     }
     if (gcThread != null)
     {
         gcThread.Activate();
         try
         {
             gcThread.Join();
         }
         catch (System.Threading.ThreadInterruptedException)
         {
         }
     }
     if (IsDirty())
     {
         Page pg = pool.PutPage(0);
         header.Pack(pg.data);
         pool.Flush();
         pool.Modify(pg);
         header.dirty = false;
         header.Pack(pg.data);
         pool.Unfix(pg);
         pool.Flush();
     }
     pool.Close();
     // make GC easier
     pool = null;
     objectCache = null;
     classDescMap = null;
     bitmapPageAvailableSpace = null;
     dirtyPagesMap = null;
     descList = null;
 }
예제 #3
0
 internal void RegisterClassDescriptor(ClassDescriptor desc)
 {
     classDescMap[desc.cls] = desc;
     desc.next = descList;
     descList = desc;
     CheckIfFinal(desc);
     StoreObject0(desc);
     header.root[1 - currIndex].classDescList = desc.Oid;
     modified = true;
 }
예제 #4
0
 internal void ReloadScheme()
 {
     classDescMap.Clear();
     int descListOid = header.root[1 - currIndex].classDescList;
     classDescMap[typeof(ClassDescriptor)] = new ClassDescriptor(this, typeof(ClassDescriptor));
     classDescMap[typeof(ClassDescriptor.FieldDescriptor)] = new ClassDescriptor(this, typeof(ClassDescriptor.FieldDescriptor));
     if (descListOid != 0)
     {
         ClassDescriptor desc;
         descList = FindClassDescriptor(descListOid);
         for (desc = descList; desc != null; desc = desc.next)
         {
             desc.Load();
         }
         for (desc = descList; desc != null; desc = desc.next)
         {
             //UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior.
             if (classDescMap[desc.cls] == desc)
             {
                 desc.Resolve();
             }
             CheckIfFinal(desc);
         }
     }
     else
     {
         descList = null;
     }
 }
예제 #5
0
        internal int MarkObject(byte[] obj, int offs, ClassDescriptor desc)
        {
            ClassDescriptor.FieldDescriptor[] all = desc.allFields;

            for (int i = 0, n = all.Length; i < n; i++)
            {
                ClassDescriptor.FieldDescriptor fd = all[i];
                switch (fd.type)
                {
                    case ClassDescriptor.tpBoolean:
                    case ClassDescriptor.tpByte:
                        offs += 1;
                        continue;

                    case ClassDescriptor.tpChar:
                    case ClassDescriptor.tpShort:
                        offs += 2;
                        continue;

                    case ClassDescriptor.tpInt:
                    case ClassDescriptor.tpFloat:
                        offs += 4;
                        continue;

                    case ClassDescriptor.tpLong:
                    case ClassDescriptor.tpDouble:
                    case ClassDescriptor.tpDate:
                        offs += 8;
                        continue;

                    case ClassDescriptor.tpString:
                    {
                        int strlen = Bytes.Unpack4(obj, offs);
                        offs += 4;
                        if (strlen > 0)
                        {
                            offs += strlen * 2;
                        }
                        else if (strlen < -1)
                        {
                            offs -= (strlen + 2);
                        }
                        continue;
                    }

                    case ClassDescriptor.tpObject:
                        MarkOid(Bytes.Unpack4(obj, offs));
                        offs += 4;
                        continue;

                    case ClassDescriptor.tpValue:
                        offs = MarkObject(obj, offs, fd.valueDesc);
                        continue;

                    case ClassDescriptor.tpRaw:
                    {
                        int len = Bytes.Unpack4(obj, offs);
                        offs += 4;
                        if (len > 0)
                        {
                            offs += len;
                        }
                        else if (len == -2 - ClassDescriptor.tpObject)
                        {
                            MarkOid(Bytes.Unpack4(obj, offs));
                            offs += 4;
                        }
                        else if (len < -1)
                        {
                            offs += ClassDescriptor.Sizeof[-2 - len];
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfByte:
                    case ClassDescriptor.tpArrayOfBoolean:
                    {
                        int len = Bytes.Unpack4(obj, offs);
                        offs += 4;
                        if (len > 0)
                        {
                            offs += len;
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfShort:
                    case ClassDescriptor.tpArrayOfChar:
                    {
                        int len = Bytes.Unpack4(obj, offs);
                        offs += 4;
                        if (len > 0)
                        {
                            offs += len * 2;
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfInt:
                    case ClassDescriptor.tpArrayOfFloat:
                    {
                        int len = Bytes.Unpack4(obj, offs);
                        offs += 4;
                        if (len > 0)
                        {
                            offs += len * 4;
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfLong:
                    case ClassDescriptor.tpArrayOfDouble:
                    case ClassDescriptor.tpArrayOfDate:
                    {
                        int len = Bytes.Unpack4(obj, offs);
                        offs += 4;
                        if (len > 0)
                        {
                            offs += len * 8;
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfString:
                    {
                        int len = Bytes.Unpack4(obj, offs);
                        offs += 4;
                        while (--len >= 0)
                        {
                            int strlen = Bytes.Unpack4(obj, offs);
                            offs += 4;
                            if (strlen > 0)
                            {
                                offs += strlen * 2;
                            }
                            else if (strlen < -1)
                            {
                                offs -= (strlen + 2);
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfObject:
                    case ClassDescriptor.tpLink:
                    {
                        int len = Bytes.Unpack4(obj, offs);
                        offs += 4;
                        while (--len >= 0)
                        {
                            MarkOid(Bytes.Unpack4(obj, offs));
                            offs += 4;
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfValue:
                    {
                        int len = Bytes.Unpack4(obj, offs);
                        offs += 4;
                        ClassDescriptor valueDesc = fd.valueDesc;
                        while (--len >= 0)
                        {
                            offs = MarkObject(obj, offs, valueDesc);
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfRaw:
                    {
                        int len = Bytes.Unpack4(obj, offs);
                        offs += 4;
                        while (--len >= 0)
                        {
                            int rawlen = Bytes.Unpack4(obj, offs);
                            offs += 4;
                            if (rawlen >= 0)
                            {
                                offs += rawlen;
                            }
                            else if (rawlen == -2 - ClassDescriptor.tpObject)
                            {
                                MarkOid(Bytes.Unpack4(obj, offs));
                                offs += 4;
                            }
                            else if (rawlen < -1)
                            {
                                offs += ClassDescriptor.Sizeof[-2 - rawlen];
                            }
                            continue;
                        }
                        continue;
                    }
                    }
            }
            return offs;
        }
예제 #6
0
        internal int PackObject(object obj, ClassDescriptor desc, int offs, ByteBuffer buf, IPersistent po)
        {
            ClassDescriptor.FieldDescriptor[] flds = desc.allFields;
            for (int i = 0, n = flds.Length; i < n; i++)
            {
                ClassDescriptor.FieldDescriptor fd = flds[i];
                FieldInfo f = fd.field;
                switch (fd.type)
                {
                    case ClassDescriptor.tpByte:
                        buf.Extend(offs + 1);
                        buf.arr[offs++] = (byte) f.GetValue(obj);
                        continue;

                    case ClassDescriptor.tpBoolean:
                        buf.Extend(offs + 1);
                        buf.arr[offs++] = (byte) ((bool) f.GetValue(obj) ? 1 : 0);
                        continue;

                    case ClassDescriptor.tpShort:
                        buf.Extend(offs + 2);
                        Bytes.Pack2(buf.arr, offs, (short) f.GetValue(obj));
                        offs += 2;
                        continue;

                    case ClassDescriptor.tpChar:
                        buf.Extend(offs + 2);
                        Bytes.Pack2(buf.arr, offs, (short) f.GetValue(obj));
                        offs += 2;
                        continue;

                    case ClassDescriptor.tpInt:
                        buf.Extend(offs + 4);
                        Bytes.Pack4(buf.arr, offs, (int) f.GetValue(obj));
                        offs += 4;
                        continue;

                    case ClassDescriptor.tpLong:
                        buf.Extend(offs + 8);
                        Bytes.Pack8(buf.arr, offs, (long) f.GetValue(obj));
                        offs += 8;
                        continue;

                    case ClassDescriptor.tpFloat:
                        buf.Extend(offs + 4);
                        Bytes.PackF4(buf.arr, offs, (float) f.GetValue(obj));
                        offs += 4;
                        continue;

                    case ClassDescriptor.tpDouble:
                        buf.Extend(offs + 8);
                        Bytes.PackF8(buf.arr, offs, (double) f.GetValue(obj));
                        offs += 8;
                        continue;

                    case ClassDescriptor.tpDate:
                    {
                        buf.Extend(offs + 8);
                        DateTime d = (DateTime) f.GetValue(obj);
                        //UPGRADE_TODO: The 'System.DateTime' structure does not have an equivalent to NULL.
                        //UPGRADE_TODO: Method 'java.util.Date.getTime' was converted to 'DateTime.Ticks' which has a different behavior.
                        long msec = (d == null) ? -1 : d.Ticks;
                        Bytes.Pack8(buf.arr, offs, msec);
                        offs += 8;
                        continue;
                    }

                    case ClassDescriptor.tpString:
                        offs = buf.PackString(offs, (string) f.GetValue(obj), encoding);
                        continue;

                    case ClassDescriptor.tpObject:
                    {
                        buf.Extend(offs + 4);
                        Bytes.Pack4(buf.arr, offs, Swizzle((IPersistent) f.GetValue(obj)));
                        offs += 4;
                        continue;
                    }

                    case ClassDescriptor.tpValue:
                    {
                        object val = f.GetValue(obj);
                        if (val == null)
                        {
                            throw new StorageError(StorageError.NULL_VALUE, fd.fieldName);
                        }
                        else if (val is IPersistent)
                        {
                            throw new StorageError(StorageError.SERIALIZE_PERSISTENT);
                        }
                        offs = PackObject(val, fd.valueDesc, offs, buf, po);
                        continue;
                    }

                    case ClassDescriptor.tpRaw:
                        offs = PackValue(f.GetValue(obj), offs, buf);
                        continue;

                    case ClassDescriptor.tpArrayOfByte:
                    {
                        byte[] arr = (byte[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4 + len);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            Array.Copy(arr, 0, buf.arr, offs, len);
                            offs += len;
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfBoolean:
                    {
                        bool[] arr = (bool[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4 + len);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            for (int j = 0; j < len; j++, offs++)
                            {
                                buf.arr[offs] = (byte) (arr[j] ? 1 : 0);
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfShort:
                    {
                        short[] arr = (short[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4 + len * 2);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            for (int j = 0; j < len; j++)
                            {
                                Bytes.Pack2(buf.arr, offs, arr[j]);
                                offs += 2;
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfChar:
                    {
                        char[] arr = (char[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4 + len * 2);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            for (int j = 0; j < len; j++)
                            {
                                Bytes.Pack2(buf.arr, offs, (short) arr[j]);
                                offs += 2;
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfInt:
                    {
                        int[] arr = (int[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4 + len * 4);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            for (int j = 0; j < len; j++)
                            {
                                Bytes.Pack4(buf.arr, offs, arr[j]);
                                offs += 4;
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfLong:
                    {
                        long[] arr = (long[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4 + len * 8);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            for (int j = 0; j < len; j++)
                            {
                                Bytes.Pack8(buf.arr, offs, arr[j]);
                                offs += 8;
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfFloat:
                    {
                        float[] arr = (float[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4 + len * 4);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            for (int j = 0; j < len; j++)
                            {
                                Bytes.PackF4(buf.arr, offs, arr[j]);
                                offs += 4;
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfDouble:
                    {
                        double[] arr = (double[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4 + len * 8);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            for (int j = 0; j < len; j++)
                            {
                                Bytes.PackF8(buf.arr, offs, arr[j]);
                                offs += 8;
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfDate:
                    {
                        DateTime[] arr = (DateTime[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4 + len * 8);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            for (int j = 0; j < len; j++)
                            {
                                DateTime d = arr[j];
                                //UPGRADE_TODO: The 'System.DateTime' structure does not have an equivalent to NULL.
                                //UPGRADE_TODO: Method 'java.util.Date.getTime' was converted to 'DateTime.Ticks' which has a different behavior.
                                long msec = (d == null) ? -1 : d.Ticks;
                                Bytes.Pack8(buf.arr, offs, msec);
                                offs += 8;
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfString:
                    {
                        string[] arr = (string[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            for (int j = 0; j < len; j++)
                            {
                                offs = buf.PackString(offs, (string) arr[j], encoding);
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfObject:
                    {
                        IPersistent[] arr = (IPersistent[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4 + len * 4);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            for (int j = 0; j < len; j++)
                            {
                                Bytes.Pack4(buf.arr, offs, Swizzle(arr[j]));
                                offs += 4;
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfValue:
                    {
                        object[] arr = (object[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            ClassDescriptor elemDesc = fd.valueDesc;
                            for (int j = 0; j < len; j++)
                            {
                                object val = arr[j];
                                if (val == null)
                                    throw new StorageError(StorageError.NULL_VALUE, fd.fieldName);

                                offs = PackObject(val, elemDesc, offs, buf, po);
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpArrayOfRaw:
                    {
                        object[] arr = (object[]) f.GetValue(obj);
                        if (arr == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            int len = arr.Length;
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            for (int j = 0; j < len; j++)
                            {
                                offs = PackValue(arr[j], offs, buf);
                            }
                        }
                        continue;
                    }

                    case ClassDescriptor.tpLink:
                    {
                        LinkImpl link = (LinkImpl) f.GetValue(obj);
                        if (link == null)
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            link.owner = po;
                            int len = link.Size;
                            buf.Extend(offs + 4 + len * 4);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            for (int j = 0; j < len; j++)
                            {
                                Bytes.Pack4(buf.arr, offs, Swizzle(link.GetRaw(j)));
                                offs += 4;
                            }
                            link.Unpin();
                        }
                        continue;
                    }
                    }
            }
            return offs;
        }
예제 #7
0
 internal static void CheckIfFinal(ClassDescriptor desc)
 {
     Type cls = desc.cls;
     for (ClassDescriptor next = desc.next; next != null; next = next.next)
     {
         next.Load();
         if (cls.IsAssignableFrom(next.cls))
         {
             desc.hasSubclasses = true;
         }
         else if (next.cls.IsAssignableFrom(cls))
         {
             next.hasSubclasses = true;
         }
     }
 }
예제 #8
0
 internal ClassDescriptor GetClassDescriptor(Type cls)
 {
     //UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior.
     ClassDescriptor desc = (ClassDescriptor) classDescMap[cls];
     if (desc == null)
     {
         desc = new ClassDescriptor(this, cls);
         RegisterClassDescriptor(desc);
     }
     return desc;
 }
예제 #9
0
        public virtual void Open(IFile file, int pagePoolSize)
        {
            lock (this)
            {
                if (opened)
                {
                    throw new StorageError(StorageError.STORAGE_ALREADY_OPENED);
                }
                if (lockFile)
                {
                    if (!file.Lock())
                    {
                        throw new StorageError(StorageError.STORAGE_IS_USED);
                    }
                }
                Page pg;
                int i;
                int indexSize = initIndexSize;
                if (indexSize < dbFirstUserId)
                {
                    indexSize = dbFirstUserId;
                }
                indexSize = (indexSize + dbHandlesPerPage - 1) & ~ (dbHandlesPerPage - 1);

                dirtyPagesMap = new int[dbDirtyPageBitmapSize / 4 + 1];
                gcThreshold = Int64.MaxValue;
                backgroundGcMonitor = new object();
                backgroundGcStartMonitor = new object();
                gcThread = null;
                gcActive = false;
                gcDone = false;
                allocatedDelta = 0;

                nNestedTransactions = 0;
                nBlockedTransactions = 0;
                nCommittedTransactions = 0;
                scheduledCommitTime = Int64.MaxValue;
                transactionMonitor = new object();
                transactionLock = new PersistentResource();

                modified = false;

                objectCache = CreateObjectCache(cacheKind, pagePoolSize, objectCacheInitSize);

                //UPGRADE_TODO: Class 'java.util.HashMap' was converted to 'System.Collections.Hashtable' which has a different behavior.
                classDescMap = new Hashtable();
                descList = null;

                header = new Header();
                byte[] buf = new byte[Header.Sizeof];
                int rc = file.Read(0, buf);
                if (rc > 0 && rc < Header.Sizeof)
                {
                    throw new StorageError(StorageError.DATABASE_CORRUPTED);
                }

                header.Unpack(buf);
                if (header.curr < 0 || header.curr > 1)
                {
                    throw new StorageError(StorageError.DATABASE_CORRUPTED);
                }

                if (pool == null)
                {
                    pool = new PagePool(pagePoolSize / Page.pageSize);
                    pool.Open(file);
                }

                if (!header.initialized)
                {
                    header.curr = currIndex = 0;
                    long used = Page.pageSize;
                    header.root[0].index = used;
                    header.root[0].indexSize = indexSize;
                    header.root[0].indexUsed = dbFirstUserId;
                    header.root[0].freeList = 0;
                    used += indexSize * 8L;
                    header.root[1].index = used;
                    header.root[1].indexSize = indexSize;
                    header.root[1].indexUsed = dbFirstUserId;
                    header.root[1].freeList = 0;
                    used += indexSize * 8L;

                    header.root[0].shadowIndex = header.root[1].index;
                    header.root[1].shadowIndex = header.root[0].index;
                    header.root[0].shadowIndexSize = indexSize;
                    header.root[1].shadowIndexSize = indexSize;

                    int bitmapPages = (int) ((used + Page.pageSize * (dbAllocationQuantum * 8 - 1) - 1) / (Page.pageSize * (dbAllocationQuantum * 8 - 1)));
                    long bitmapSize = (long) bitmapPages * Page.pageSize;
                    int usedBitmapSize = (int) (SupportClass.URShift((used + bitmapSize), (dbAllocationQuantumBits + 3)));

                    for (i = 0; i < bitmapPages; i++)
                    {
                        pg = pool.PutPage(used + (long) i * Page.pageSize);
                        byte[] bitmap = pg.data;
                        int n = usedBitmapSize > Page.pageSize ? Page.pageSize : usedBitmapSize;
                        for (int j = 0; j < n; j++)
                        {
                            bitmap[j] = (byte) 0xFF;
                        }
                        usedBitmapSize -= Page.pageSize;
                        pool.Unfix(pg);
                    }

                    int bitmapIndexSize = ((dbBitmapId + dbBitmapPages) * 8 + Page.pageSize - 1) & ~ (Page.pageSize - 1);
                    byte[] index = new byte[bitmapIndexSize];
                    Bytes.Pack8(index, dbInvalidId * 8, dbFreeHandleFlag);
                    for (i = 0; i < bitmapPages; i++)
                    {
                        Bytes.Pack8(index, (dbBitmapId + i) * 8, used | dbPageObjectFlag);
                        used += Page.pageSize;
                    }
                    header.root[0].bitmapEnd = dbBitmapId + i;
                    header.root[1].bitmapEnd = dbBitmapId + i;
                    while (i < dbBitmapPages)
                    {
                        Bytes.Pack8(index, (dbBitmapId + i) * 8, dbFreeHandleFlag);
                        i += 1;
                    }

                    header.root[0].size = used;
                    header.root[1].size = used;
                    usedSize = used;
                    committedIndexSize = currIndexSize = dbFirstUserId;

                    pool.Write(header.root[1].index, index);
                    pool.Write(header.root[0].index, index);

                    header.dirty = true;
                    header.root[0].size = header.root[1].size;
                    pg = pool.PutPage(0);
                    header.Pack(pg.data);
                    pool.Flush();
                    pool.Modify(pg);
                    header.initialized = true;
                    header.Pack(pg.data);
                    pool.Unfix(pg);
                    pool.Flush();
                }
                else
                {
                    int curr = header.curr;
                    currIndex = curr;
                    if (header.root[curr].indexSize != header.root[curr].shadowIndexSize)
                    {
                        throw new StorageError(StorageError.DATABASE_CORRUPTED);
                    }

                    if (IsDirty())
                    {
                        if (listener != null)
                        {
                            listener.DatabaseCorrupted();
                        }

                        Console.Error.WriteLine("Database was not normally closed: start recovery");
                        header.root[1 - curr].size = header.root[curr].size;
                        header.root[1 - curr].indexUsed = header.root[curr].indexUsed;
                        header.root[1 - curr].freeList = header.root[curr].freeList;
                        header.root[1 - curr].index = header.root[curr].shadowIndex;
                        header.root[1 - curr].indexSize = header.root[curr].shadowIndexSize;
                        header.root[1 - curr].shadowIndex = header.root[curr].index;
                        header.root[1 - curr].shadowIndexSize = header.root[curr].indexSize;
                        header.root[1 - curr].bitmapEnd = header.root[curr].bitmapEnd;
                        header.root[1 - curr].rootObject = header.root[curr].rootObject;
                        header.root[1 - curr].classDescList = header.root[curr].classDescList;
                        header.root[1 - curr].bitmapExtent = header.root[curr].bitmapExtent;

                        pg = pool.PutPage(0);
                        header.Pack(pg.data);
                        pool.Unfix(pg);

                        pool.Copy(header.root[1 - curr].index, header.root[curr].index, (header.root[curr].indexUsed * 8L + Page.pageSize - 1) & ~(Page.pageSize - 1));
                        if (listener != null)
                        {
                            listener.RecoveryCompleted();
                        }
                        Console.Error.WriteLine("Recovery completed");
                    }
                    currIndexSize = header.root[1 - curr].indexUsed;
                    committedIndexSize = currIndexSize;
                    usedSize = header.root[curr].size;
                }
                int bitmapSize2 = header.root[1 - currIndex].bitmapExtent == 0 ? dbBitmapPages : dbLargeBitmapPages;
                bitmapPageAvailableSpace = new int[bitmapSize2];
                for (i = 0; i < bitmapPageAvailableSpace.Length; i++)
                {
                    bitmapPageAvailableSpace[i] = Int32.MaxValue;
                }

                currRBitmapPage = currPBitmapPage = 0;
                currRBitmapOffs = currPBitmapOffs = 0;

                opened = true;
                ReloadScheme();
            }
        }
예제 #10
0
        internal int PackObject(XMLElement objElem, ClassDescriptor desc, int offs, ByteBuffer buf)
        {
            ClassDescriptor.FieldDescriptor[] flds = desc.allFields;
            for (int i = 0, n = flds.Length; i < n; i++)
            {
                ClassDescriptor.FieldDescriptor fd = flds[i];
                string fieldName = fd.fieldName;
                XMLElement elem = (objElem != null) ? objElem.GetSibling(fieldName) : null;

                switch (fd.type)
                {
                    case ClassDescriptor.tpByte:
                        buf.Extend(offs + 1);
                        if (elem != null)
                        {
                            if (elem.IsIntValue())
                            {
                                buf.arr[offs] = (byte) elem.GetIntValue();
                            }
                            else if (elem.IsRealValue())
                            {
                                //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions.
                                buf.arr[offs] = (byte) elem.GetRealValue();
                            }
                            else
                            {
                                ThrowException("Conversion for field " + fieldName + " is not possible");
                            }
                        }
                        offs += 1;
                        continue;

                    case ClassDescriptor.tpBoolean:
                        buf.Extend(offs + 1);
                        if (elem != null)
                        {
                            if (elem.IsIntValue())
                            {
                                buf.arr[offs] = (byte) (elem.GetIntValue() != 0 ? 1 : 0);
                            }
                            else if (elem.IsRealValue())
                            {
                                buf.arr[offs] = (byte) (elem.GetRealValue() != 0.0 ? 1 : 0);
                            }
                            else
                            {
                                ThrowException("Conversion for field " + fieldName + " is not possible");
                            }
                        }
                        offs += 1;
                        continue;

                    case ClassDescriptor.tpShort:
                    case ClassDescriptor.tpChar:
                        buf.Extend(offs + 2);
                        if (elem != null)
                        {
                            if (elem.IsIntValue())
                            {
                                Bytes.Pack2(buf.arr, offs, (short) elem.GetIntValue());
                            }
                            else if (elem.IsRealValue())
                            {
                                //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions.
                                Bytes.Pack2(buf.arr, offs, (short) elem.GetRealValue());
                            }
                            else
                            {
                                ThrowException("Conversion for field " + fieldName + " is not possible");
                            }
                        }
                        offs += 2;
                        continue;

                    case ClassDescriptor.tpInt:
                        buf.Extend(offs + 4);
                        if (elem != null)
                        {
                            if (elem.IsIntValue())
                            {
                                Bytes.Pack4(buf.arr, offs, (int) elem.GetIntValue());
                            }
                            else if (elem.IsRealValue())
                            {
                                //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions.
                                Bytes.Pack4(buf.arr, offs, (int) elem.GetRealValue());
                            }
                            else
                            {
                                ThrowException("Conversion for field " + fieldName + " is not possible");
                            }
                        }
                        offs += 4;
                        continue;

                    case ClassDescriptor.tpLong:
                        buf.Extend(offs + 8);
                        if (elem != null)
                        {
                            if (elem.IsIntValue())
                            {
                                Bytes.Pack8(buf.arr, offs, elem.GetIntValue());
                            }
                            else if (elem.IsRealValue())
                            {
                                //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions.
                                Bytes.Pack8(buf.arr, offs, (long) elem.GetRealValue());
                            }
                            else
                            {
                                ThrowException("Conversion for field " + fieldName + " is not possible");
                            }
                        }
                        offs += 8;
                        continue;

                    case ClassDescriptor.tpFloat:
                        buf.Extend(offs + 4);
                        if (elem != null)
                        {
                            if (elem.IsIntValue())
                            {
                                Bytes.PackF4(buf.arr, offs, (float) elem.GetIntValue());
                            }
                            else if (elem.IsRealValue())
                            {
                                Bytes.PackF4(buf.arr, offs, (float) elem.GetRealValue());
                            }
                            else
                            {
                                ThrowException("Conversion for field " + fieldName + " is not possible");
                            }
                        }
                        offs += 4;
                        continue;

                    case ClassDescriptor.tpDouble:
                        buf.Extend(offs + 8);
                        if (elem != null)
                        {
                            if (elem.IsIntValue())
                            {
                                //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions.
                                Bytes.PackF8(buf.arr, offs, (double) elem.GetIntValue());
                            }
                            else if (elem.IsRealValue())
                            {
                                Bytes.PackF8(buf.arr, offs, (double) elem.GetRealValue());
                            }
                            else
                            {
                                ThrowException("Conversion for field " + fieldName + " is not possible");
                            }
                        }
                        offs += 8;
                        continue;

                    case ClassDescriptor.tpDate:
                        buf.Extend(offs + 8);
                        if (elem != null)
                        {
                            if (elem.IsIntValue())
                            {
                                Bytes.Pack8(buf.arr, offs, elem.GetIntValue());
                            }
                            else if (elem.IsNullValue())
                            {
                                Bytes.Pack8(buf.arr, offs, -1);
                            }
                            else if (elem.IsStringValue())
                            {
                                /* TODOPORT:
                                //UPGRADE_ISSUE: Method 'java.text.DateFormat.parse' was not converted.
                                DateTime date = httpFormatter.parse(elem.GetStringValue(), 0);
                                //UPGRADE_TODO: The 'System.DateTime' structure does not have an equivalent to NULL.
                                if (date == null)
                                {
                                    ThrowException("Invalid date");
                                }
                                //UPGRADE_TODO: Method 'java.util.Date.getTime' was converted to 'DateTime.Ticks' which has a different behavior.
                                Bytes.Pack8(buf.arr, offs, date.Ticks);
                                */
                                ThrowException("Not implemented");
                            }
                            else
                            {
                                ThrowException("Conversion for field " + fieldName + " is not possible");
                            }
                        }
                        offs += 8;
                        continue;

                    case ClassDescriptor.tpString:
                        if (elem != null)
                        {
                            string val = null;
                            if (elem.IsIntValue())
                            {
                                val = Convert.ToString(elem.GetIntValue());
                            }
                            else if (elem.IsRealValue())
                            {
                                val = elem.GetRealValue().ToString();
                            }
                            else if (elem.IsStringValue())
                            {
                                val = elem.GetStringValue();
                            }
                            else if (elem.IsNullValue())
                            {
                                val = null;
                            }
                            else
                            {
                                ThrowException("Conversion for field " + fieldName + " is not possible");
                            }
                            offs = buf.PackString(offs, val, storage.encoding);
                            continue;
                        }

                        buf.Extend(offs + 4);
                        Bytes.Pack4(buf.arr, offs, -1);
                        offs += 4;
                        continue;

                    case ClassDescriptor.tpObject:
                    {
                        int oid = 0;
                        if (elem != null)
                        {
                            XMLElement ref_Renamed = elem.GetSibling("ref");
                            if (ref_Renamed == null)
                            {
                                ThrowException("<ref> element expected");
                            }
                            oid = MapId(GetIntAttribute(ref_Renamed, "id"));
                        }
                        buf.Extend(offs + 4);
                        Bytes.Pack4(buf.arr, offs, oid);
                        offs += 4;
                        continue;
                    }

                    case ClassDescriptor.tpValue:
                        offs = PackObject(elem, fd.valueDesc, offs, buf);
                        continue;

                    case ClassDescriptor.tpRaw:
                    case ClassDescriptor.tpArrayOfByte:
                        offs = ImportBinary(elem, offs, buf, fieldName);
                        continue;

                    case ClassDescriptor.tpArrayOfBoolean:
                        if (elem == null || elem.IsNullValue())
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            XMLElement item = elem.GetSibling("element");
                            int len = (item == null) ? 0 : item.Counter;
                            buf.Extend(offs + 4 + len);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            while (--len >= 0)
                            {
                                if (item.IsIntValue())
                                {
                                    buf.arr[offs] = (byte) (item.GetIntValue() != 0 ? 1 : 0);
                                }
                                else if (item.IsRealValue())
                                {
                                    buf.arr[offs] = (byte) (item.GetRealValue() != 0.0 ? 1 : 0);
                                }
                                else
                                {
                                    ThrowException("Conversion for field " + fieldName + " is not possible");
                                }
                                item = item.NextSibling;
                                offs += 1;
                            }
                        }
                        continue;

                    case ClassDescriptor.tpArrayOfChar:
                    case ClassDescriptor.tpArrayOfShort:
                        if (elem == null || elem.IsNullValue())
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            XMLElement item = elem.GetSibling("element");
                            int len = (item == null) ? 0 : item.Counter;
                            buf.Extend(offs + 4 + len * 2);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            while (--len >= 0)
                            {
                                if (item.IsIntValue())
                                {
                                    Bytes.Pack2(buf.arr, offs, (short) item.GetIntValue());
                                }
                                else if (item.IsRealValue())
                                {
                                    //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions.
                                    Bytes.Pack2(buf.arr, offs, (short) item.GetRealValue());
                                }
                                else
                                {
                                    ThrowException("Conversion for field " + fieldName + " is not possible");
                                }
                                item = item.NextSibling;
                                offs += 2;
                            }
                        }
                        continue;

                    case ClassDescriptor.tpArrayOfInt:
                        if (elem == null || elem.IsNullValue())
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            XMLElement item = elem.GetSibling("element");
                            int len = (item == null) ? 0 : item.Counter;
                            buf.Extend(offs + 4 + len * 4);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            while (--len >= 0)
                            {
                                if (item.IsIntValue())
                                {
                                    Bytes.Pack4(buf.arr, offs, (int) item.GetIntValue());
                                }
                                else if (item.IsRealValue())
                                {
                                    //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions.
                                    Bytes.Pack4(buf.arr, offs, (int) item.GetRealValue());
                                }
                                else
                                {
                                    ThrowException("Conversion for field " + fieldName + " is not possible");
                                }
                                item = item.NextSibling;
                                offs += 4;
                            }
                        }
                        continue;

                    case ClassDescriptor.tpArrayOfLong:
                        if (elem == null || elem.IsNullValue())
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            XMLElement item = elem.GetSibling("element");
                            int len = (item == null) ? 0 : item.Counter;
                            buf.Extend(offs + 4 + len * 8);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            while (--len >= 0)
                            {
                                if (item.IsIntValue())
                                {
                                    Bytes.Pack8(buf.arr, offs, item.GetIntValue());
                                }
                                else if (item.IsRealValue())
                                {
                                    //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions.
                                    Bytes.Pack8(buf.arr, offs, (long) item.GetRealValue());
                                }
                                else
                                {
                                    ThrowException("Conversion for field " + fieldName + " is not possible");
                                }
                                item = item.NextSibling;
                                offs += 8;
                            }
                        }
                        continue;

                    case ClassDescriptor.tpArrayOfFloat:
                        if (elem == null || elem.IsNullValue())
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            XMLElement item = elem.GetSibling("element");
                            int len = (item == null) ? 0 : item.Counter;
                            buf.Extend(offs + 4 + len * 4);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            while (--len >= 0)
                            {
                                if (item.IsIntValue())
                                {
                                    Bytes.PackF4(buf.arr, offs, (float) item.GetIntValue());
                                }
                                else if (item.IsRealValue())
                                {
                                    Bytes.PackF4(buf.arr, offs, (float) item.GetRealValue());
                                }
                                else
                                {
                                    ThrowException("Conversion for field " + fieldName + " is not possible");
                                }
                                item = item.NextSibling;
                                offs += 4;
                            }
                        }
                        continue;

                    case ClassDescriptor.tpArrayOfDouble:
                        if (elem == null || elem.IsNullValue())
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            XMLElement item = elem.GetSibling("element");
                            int len = (item == null) ? 0 : item.Counter;
                            buf.Extend(offs + 4 + len * 8);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            while (--len >= 0)
                            {
                                if (item.IsIntValue())
                                {
                                    //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions.
                                    Bytes.PackF8(buf.arr, offs, (double) item.GetIntValue());
                                }
                                else if (item.IsRealValue())
                                {
                                    Bytes.PackF8(buf.arr, offs, (double) item.GetRealValue());
                                }
                                else
                                {
                                    ThrowException("Conversion for field " + fieldName + " is not possible");
                                }
                                item = item.NextSibling;
                                offs += 8;
                            }
                        }
                        continue;

                    case ClassDescriptor.tpArrayOfDate:
                        if (elem == null || elem.IsNullValue())
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            XMLElement item = elem.GetSibling("element");
                            int len = (item == null) ? 0 : item.Counter;
                            buf.Extend(offs + 4 + len * 8);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            while (--len >= 0)
                            {
                                if (item.IsNullValue())
                                {
                                    Bytes.Pack8(buf.arr, offs, -1);
                                }
                                else if (item.IsStringValue())
                                {
                                    /* TODOPORT:
                                    //UPGRADE_ISSUE: Method 'java.text.DateFormat.parse' was not converted.
                                    DateTime date = httpFormatter.parse(item.GetStringValue(), 0);
                                    //UPGRADE_TODO: The 'System.DateTime' structure does not have an equivalent to NULL.
                                    if (date == null)
                                    {
                                        ThrowException("Invalid date");
                                    }
                                    //UPGRADE_TODO: Method 'java.util.Date.getTime' was converted to 'DateTime.Ticks' which has a different behavior.
                                    Bytes.Pack8(buf.arr, offs, date.Ticks);
                                    */
                                    ThrowException("Not implemented");
                                }
                                else
                                {
                                    ThrowException("Conversion for field " + fieldName + " is not possible");
                                }
                                item = item.NextSibling;
                                offs += 8;
                            }
                        }
                        continue;

                    case ClassDescriptor.tpArrayOfString:
                        if (elem == null || elem.IsNullValue())
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            XMLElement item = elem.GetSibling("element");
                            int len = (item == null) ? 0 : item.Counter;
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            while (--len >= 0)
                            {
                                string val = null;
                                if (item.IsIntValue())
                                {
                                    val = Convert.ToString(item.GetIntValue());
                                }
                                else if (item.IsRealValue())
                                {
                                    val = item.GetRealValue().ToString();
                                }
                                else if (item.IsStringValue())
                                {
                                    val = item.GetStringValue();
                                }
                                else if (elem.IsNullValue())
                                {
                                    val = null;
                                }
                                else
                                {
                                    ThrowException("Conversion for field " + fieldName + " is not possible");
                                }

                                offs = buf.PackString(offs, val, storage.encoding);
                                item = item.NextSibling;
                            }
                        }
                        continue;

                    case ClassDescriptor.tpArrayOfObject:
                    case ClassDescriptor.tpLink:
                        if (elem == null || elem.IsNullValue())
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            XMLElement item = elem.GetSibling("element");
                            int len = (item == null) ? 0 : item.Counter;
                            buf.Extend(offs + 4 + len * 4);
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            while (--len >= 0)
                            {
                                XMLElement ref_Renamed = item.GetSibling("ref");
                                if (ref_Renamed == null)
                                {
                                    ThrowException("<ref> element expected");
                                }
                                int oid = MapId(GetIntAttribute(ref_Renamed, "id"));
                                Bytes.Pack4(buf.arr, offs, oid);
                                item = item.NextSibling;
                                offs += 4;
                            }
                        }
                        continue;

                    case ClassDescriptor.tpArrayOfValue:
                        if (elem == null || elem.IsNullValue())
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            XMLElement item = elem.GetSibling("element");
                            int len = (item == null) ? 0 : item.Counter;
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            ClassDescriptor elemDesc = fd.valueDesc;
                            while (--len >= 0)
                            {
                                offs = PackObject(item, elemDesc, offs, buf);
                                item = item.NextSibling;
                            }
                        }
                        continue;

                    case ClassDescriptor.tpArrayOfRaw:
                        if (elem == null || elem.IsNullValue())
                        {
                            buf.Extend(offs + 4);
                            Bytes.Pack4(buf.arr, offs, -1);
                            offs += 4;
                        }
                        else
                        {
                            XMLElement item = elem.GetSibling("element");
                            int len = (item == null) ? 0 : item.Counter;
                            Bytes.Pack4(buf.arr, offs, len);
                            offs += 4;
                            while (--len >= 0)
                            {
                                offs = ImportBinary(item, offs, buf, fieldName);
                                item = item.NextSibling;
                            }
                        }
                        continue;
                    }
            }
            return offs;
        }
예제 #11
0
        internal int ExportObject(ClassDescriptor desc, byte[] body, int offs, int indent)
        {
            ClassDescriptor.FieldDescriptor[] all = desc.allFields;

            for (int i = 0, n = all.Length; i < n; i++)
            {
                ClassDescriptor.FieldDescriptor fd = all[i];
                Indentation(indent);
                string fieldName = ExportIdentifier(fd.fieldName);
                writer.Write("<" + fieldName + ">");
                switch (fd.type)
                {
                    case ClassDescriptor.tpBoolean:
                        writer.Write(body[offs++] != 0 ? "1" : "0");
                        break;

                    case ClassDescriptor.tpByte:
                        writer.Write(Convert.ToString((byte) body[offs++]));
                        break;

                    case ClassDescriptor.tpChar:
                        writer.Write(Convert.ToString((char) Bytes.Unpack2(body, offs)));
                        offs += 2;
                        break;

                    case ClassDescriptor.tpShort:
                        writer.Write(Convert.ToString(Bytes.Unpack2(body, offs)));
                        offs += 2;
                        break;

                    case ClassDescriptor.tpInt:
                        writer.Write(Convert.ToString(Bytes.Unpack4(body, offs)));
                        offs += 4;
                        break;

                    case ClassDescriptor.tpLong:
                        writer.Write(Convert.ToString(Bytes.Unpack8(body, offs)));
                        offs += 8;
                        break;

                    case ClassDescriptor.tpFloat:
                        float flt = Bytes.UnpackF4(body, offs);
                        writer.Write(flt.ToString());
                        offs += 4;
                        break;

                    case ClassDescriptor.tpDouble:
                        double dbl = Bytes.UnpackF8(body, offs);
                        writer.Write(dbl.ToString());
                        offs += 8;
                        break;

                    case ClassDescriptor.tpString:
                        offs = ExportString(body, offs);
                        break;

                    case ClassDescriptor.tpDate:
                    {
                        long msec = Bytes.Unpack8(body, offs);
                        offs += 8;
                        if (msec >= 0)
                        {
                            //UPGRADE_TODO: Constructor 'java.util.Date.Date' was converted to 'DateTime.DateTime' which has a different behavior.
                            // TODOPORT: writer.Write("\"" + SupportClass.FormatDateTime(XMLImporter.httpFormatter, new DateTime(msec)) + "\"");
                            throw new NotImplementedException();
                        }
                        else
                        {
                            writer.Write("null");
                        }
                        break;
                    }

                    case ClassDescriptor.tpObject:
                        ExportRef(Bytes.Unpack4(body, offs));
                        offs += 4;
                        break;

                    case ClassDescriptor.tpValue:
                        writer.Write('\n');
                        offs = ExportObject(fd.valueDesc, body, offs, indent + 1);
                        Indentation(indent);
                        break;

                    case ClassDescriptor.tpRaw:
                    case ClassDescriptor.tpArrayOfByte:
                        offs = ExportBinary(body, offs);
                        break;

                    case ClassDescriptor.tpArrayOfBoolean:
                    {
                        int len = Bytes.Unpack4(body, offs);
                        offs += 4;
                        if (len < 0)
                        {
                            writer.Write("null");
                        }
                        else
                        {
                            writer.Write('\n');
                            while (--len >= 0)
                            {
                                Indentation(indent + 1);
                                writer.Write("<element>" + (body[offs++] != 0 ? "1" : "0") + "</element>\n");
                            }
                            Indentation(indent);
                        }
                        break;
                    }

                    case ClassDescriptor.tpArrayOfChar:
                    {
                        int len = Bytes.Unpack4(body, offs);
                        offs += 4;
                        if (len < 0)
                        {
                            writer.Write("null");
                        }
                        else
                        {
                            writer.Write('\n');
                            while (--len >= 0)
                            {
                                Indentation(indent + 1);
                                writer.Write("<element>" + (Bytes.Unpack2(body, offs) & 0xFFFF) + "</element>\n");
                                offs += 2;
                            }
                            Indentation(indent);
                        }
                        break;
                    }

                    case ClassDescriptor.tpArrayOfShort:
                    {
                        int len = Bytes.Unpack4(body, offs);
                        offs += 4;
                        if (len < 0)
                        {
                            writer.Write("null");
                        }
                        else
                        {
                            writer.Write('\n');
                            while (--len >= 0)
                            {
                                Indentation(indent + 1);
                                writer.Write("<element>" + Bytes.Unpack2(body, offs) + "</element>\n");
                                offs += 2;
                            }
                            Indentation(indent);
                        }
                        break;
                    }

                    case ClassDescriptor.tpArrayOfInt:
                    {
                        int len = Bytes.Unpack4(body, offs);
                        offs += 4;
                        if (len < 0)
                        {
                            writer.Write("null");
                        }
                        else
                        {
                            writer.Write('\n');
                            while (--len >= 0)
                            {
                                Indentation(indent + 1);
                                writer.Write("<element>" + Bytes.Unpack4(body, offs) + "</element>\n");
                                offs += 4;
                            }
                            Indentation(indent);
                        }
                        break;
                    }

                    case ClassDescriptor.tpArrayOfLong:
                    {
                        int len = Bytes.Unpack4(body, offs);
                        offs += 4;
                        if (len < 0)
                        {
                            writer.Write("null");
                        }
                        else
                        {
                            writer.Write('\n');
                            while (--len >= 0)
                            {
                                Indentation(indent + 1);
                                writer.Write("<element>" + Bytes.Unpack8(body, offs) + "</element>\n");
                                offs += 8;
                            }
                            Indentation(indent);
                        }
                        break;
                    }

                    case ClassDescriptor.tpArrayOfFloat:
                    {
                        int len = Bytes.Unpack4(body, offs);
                        offs += 4;
                        if (len < 0)
                        {
                            writer.Write("null");
                        }
                        else
                        {
                            writer.Write('\n');
                            while (--len >= 0)
                            {
                                Indentation(indent + 1);
                                writer.Write("<element>" + Bytes.UnpackF4(body, offs) + "</element>\n");
                                offs += 4;
                            }
                            Indentation(indent);
                        }
                        break;
                    }

                    case ClassDescriptor.tpArrayOfDouble:
                    {
                        int len = Bytes.Unpack4(body, offs);
                        offs += 4;
                        if (len < 0)
                        {
                            writer.Write("null");
                        }
                        else
                        {
                            writer.Write('\n');
                            while (--len >= 0)
                            {
                                Indentation(indent + 1);
                                writer.Write("<element>" + Bytes.UnpackF8(body, offs) + "</element>\n");
                                offs += 8;
                            }
                            Indentation(indent);
                        }
                        break;
                    }

                    case ClassDescriptor.tpArrayOfDate:
                    {
                        int len = Bytes.Unpack4(body, offs);
                        offs += 4;
                        if (len < 0)
                        {
                            writer.Write("null");
                        }
                        else
                        {
                            writer.Write('\n');
                            while (--len >= 0)
                            {
                                Indentation(indent + 1);
                                long msec = Bytes.Unpack8(body, offs);
                                offs += 8;
                                if (msec >= 0)
                                {
                                    writer.Write("<element>\"");
                                    //UPGRADE_TODO: Constructor 'java.util.Date.Date' was converted to 'DateTime.DateTime' which has a different behavior.
                                    // TODOPORT: writer.Write(SupportClass.FormatDateTime(XMLImporter.httpFormatter, new DateTime(msec)));
                                    writer.Write("\"</element>\n");
                                    throw new NotImplementedException();
                                }
                                else
                                {
                                    writer.Write("<element>null</element>\n");
                                }
                            }
                        }
                        break;
                    }

                    case ClassDescriptor.tpArrayOfString:
                    {
                        int len = Bytes.Unpack4(body, offs);
                        offs += 4;
                        if (len < 0)
                        {
                            writer.Write("null");
                        }
                        else
                        {
                            writer.Write('\n');
                            while (--len >= 0)
                            {
                                Indentation(indent + 1);
                                writer.Write("<element>");
                                offs = ExportString(body, offs);
                                writer.Write("</element>\n");
                            }
                            Indentation(indent);
                        }
                        break;
                    }

                    case ClassDescriptor.tpLink:
                    case ClassDescriptor.tpArrayOfObject:
                    {
                        int len = Bytes.Unpack4(body, offs);
                        offs += 4;
                        if (len < 0)
                        {
                            writer.Write("null");
                        }
                        else
                        {
                            writer.Write('\n');
                            while (--len >= 0)
                            {
                                Indentation(indent + 1);
                                int oid = Bytes.Unpack4(body, offs);
                                if (oid != 0 && (exportedBitmap[oid >> 5] & (1 << (oid & 31))) == 0)
                                {
                                    markedBitmap[oid >> 5] |= 1 << (oid & 31);
                                }
                                writer.Write("<element><ref id=\"" + oid + "\"/></element>\n");
                                offs += 4;
                            }
                            Indentation(indent);
                        }
                        break;
                    }

                    case ClassDescriptor.tpArrayOfValue:
                    {
                        int len = Bytes.Unpack4(body, offs);
                        offs += 4;
                        if (len < 0)
                        {
                            writer.Write("null");
                        }
                        else
                        {
                            writer.Write('\n');
                            while (--len >= 0)
                            {
                                Indentation(indent + 1);
                                writer.Write("<element>\n");
                                offs = ExportObject(fd.valueDesc, body, offs, indent + 2);
                                Indentation(indent + 1);
                                writer.Write("</element>\n");
                            }
                            Indentation(indent);
                        }
                        break;
                    }

                    case ClassDescriptor.tpArrayOfRaw:
                    {
                        int len = Bytes.Unpack4(body, offs);
                        offs += 4;
                        if (len < 0)
                        {
                            writer.Write("null");
                        }
                        else
                        {
                            writer.Write('\n');
                            while (--len >= 0)
                            {
                                Indentation(indent + 1);
                                writer.Write("<element>");
                                offs = ExportBinary(body, offs);
                                writer.Write("</element>\n");
                            }
                            Indentation(indent);
                        }
                        break;
                    }
                    }
                writer.Write("</" + fieldName + ">\n");
            }
            return offs;
        }
예제 #12
0
        internal void Resolve()
        {
            if (resolved)
                return;

            StorageImpl classStorage = (StorageImpl) Storage;
            ClassDescriptor desc = new ClassDescriptor(classStorage, cls);
            resolved = true;
            if (!desc.Equals(this))
                classStorage.RegisterClassDescriptor(desc);
        }
예제 #13
0
        public bool Equals(ClassDescriptor cd)
        {
            if (cd == null || allFields.Length != cd.allFields.Length)
            {
                return false;
            }

            for (int i = 0; i < allFields.Length; i++)
            {
                if (!allFields[i].Equals(cd.allFields[i]))
                {
                    return false;
                }
            }
            return true;
        }