rndbtree.cs

Perst开源实时数据库

                get
                {
                    return data;
                }
                
            }
            internal int[] data;
            
            const int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 4);
            
            
            internal override Key getKey(int i)
            {
                return new Key(data[i]);
            }
            
            internal override object getKeyValue(int i)
            {
                return data[i];
            }
            
            internal override BtreePage clonePage()
            {
                return new BtreePageOfInt(Storage);
            }
            
            internal override int compare(Key key, int i)
            {
                return key.ival - data[i];
            }
            
            internal override void  insert(BtreeKey key, int i)
            {
                items[i] = key.node;
                data[i] = key.key.ival;
            }
            
            internal BtreePageOfInt(Storage s):base(s, MAX_ITEMS)
            {
                data = new int[MAX_ITEMS];
            }
            
            internal BtreePageOfInt()
            {
            }
        }
        
        class BtreePageOfUInt:BtreePage
        {
            override internal Array Data
            {
                get
                {
                    return data;
                }
                
            }
            internal uint[] data;
            
            const int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 4);
            
            
            internal override Key getKey(int i)
            {
                return new Key(data[i]);
            }
            
            internal override object getKeyValue(int i)
            {
                return data[i];
            }
            
            internal override BtreePage clonePage()
            {
                return new BtreePageOfUInt(Storage);
            }
            
            internal override int compare(Key key, int i)
            {
                return (uint) key.ival < data[i] ? -1 : (uint) key.ival == data[i] ? 0 : 1;
            }
            
            internal override void  insert(BtreeKey key, int i)
            {
                items[i] = key.node;
                data[i] = (uint) key.key.ival;
            }
            
            internal BtreePageOfUInt(Storage s):base(s, MAX_ITEMS)
            {
                data = new uint[MAX_ITEMS];
            }
            
            internal BtreePageOfUInt()
            {
            }
        }
        
        class BtreePageOfLong:BtreePage
        {
            override internal Array Data
            {
                get
                {
                    return data;
                }
                
            }
            internal long[] data;
            
            const int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 8);
            
            
            internal override Key getKey(int i)
            {
                return new Key(data[i]);
            }
            
            internal override object getKeyValue(int i)
            {
                return data[i];
            }
            
            internal override BtreePage clonePage()
            {
                return new BtreePageOfLong(Storage);
            }
            
            internal override int compare(Key key, int i)
            {
                return key.lval < data[i] ? -1 : key.lval == data[i] ? 0 : 1;
            }
            
            internal override void  insert(BtreeKey key, int i)
            {
                items[i] = key.node;
                data[i] = key.key.lval;
            }
            
            internal BtreePageOfLong(Storage s):base(s, MAX_ITEMS)
            {
                data = new long[MAX_ITEMS];
            }
            
            internal BtreePageOfLong()
            {
            }
        }
        
        class BtreePageOfULong:BtreePage
        {
            override internal Array Data
            {
                get
                {
                    return data;
                }
                
            }
            internal ulong[] data;
            
            const int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 8);
            
            
            internal override Key getKey(int i)
            {
                return new Key(data[i]);
            }
            
            internal override object getKeyValue(int i)
            {
                return data[i];
            }
            
            internal override BtreePage clonePage()
            {
                return new BtreePageOfULong(Storage);
            }
            
            internal override int compare(Key key, int i)
            {
                return (ulong)key.lval < data[i] ? -1 : (ulong)key.lval == data[i] ? 0 : 1;
            }
            
            internal override void  insert(BtreeKey key, int i)
            {
                items[i] = key.node;
                data[i] = (ulong)key.key.lval;
            }
            
            internal BtreePageOfULong(Storage s):base(s, MAX_ITEMS)
            {
                data = new ulong[MAX_ITEMS];
            }
            
            internal BtreePageOfULong()
            {
            }
        }
        
        class BtreePageOfFloat:BtreePage
        {
            override internal Array Data
            {
                get
                {
                    return data;
                }
                
            }
            internal float[] data;
            
            const int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 4);
            
            
            internal override Key getKey(int i)
            {
                return new Key(data[i]);
            }
            
            internal override object getKeyValue(int i)
            {
                return data[i];
            }
            
            internal override BtreePage clonePage()
            {
                return new BtreePageOfFloat(Storage);
            }
            
            internal override int compare(Key key, int i)
            {
                return (float) key.dval < data[i]?- 1:(float) key.dval == data[i]?0:1;
            }
            
            internal override void  insert(BtreeKey key, int i)
            {
                items[i] = key.node;
                data[i] = (float) key.key.dval;
            }
            
            internal BtreePageOfFloat(Storage s):base(s, MAX_ITEMS)
            {
                data = new float[MAX_ITEMS];
            }
            
            internal BtreePageOfFloat()
            {
            }
        }
        
        class BtreePageOfDouble:BtreePage
        {
            override internal Array Data
            {
                get
                {
                    return data;
                }
                
            }
            internal double[] data;
            
            const int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 8);
            
            
            internal override Key getKey(int i)
            {
                return new Key(data[i]);
            }
            
            internal override object getKeyValue(int i)
            {
                return data[i];
            }
            
            internal override BtreePage clonePage()
            {
                return new BtreePageOfDouble(Storage);
            }
            
            internal override int compare(Key key, int i)
            {
                return key.dval < data[i]?- 1:key.dval == data[i]?0:1;
            }
            
            internal override void  insert(BtreeKey key, int i)
            {
                items[i] = key.node;
                data[i] = key.key.dval;
            }
            
            internal BtreePageOfDouble(Storage s):base(s, MAX_ITEMS)
            {
                data = new double[MAX_ITEMS];
            }
            
            internal BtreePageOfDouble()
            {
            }
        }
        
        class BtreePageOfGuid:BtreePage
        {
            override internal Array Data
            {
                get
                {
                    return data;
                }
                
            }
            internal Guid[] data;
            
            const int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 16);
            
            
            internal override Key getKey(int i)
            {
                return new Key(data[i]);
            }
            
            internal override object getKeyValue(int i)
            {
                return data[i];
            }
            
            internal override BtreePage clonePage()
            {
                return new BtreePageOfGuid(Storage);
            }
            
            internal override int compare(Key key, int i)
            {
                return key.guid.CompareTo(data[i]);
            }
            
            internal override void  insert(BtreeKey key, int i)
            {
                items[i] = key.node;
                data[i] = key.key.guid;
            }
            
            internal BtreePageOfGuid(Storage s):base(s, MAX_ITEMS)
            {
                data = new Guid[MAX_ITEMS];
            }
            
            internal BtreePageOfGuid()
            {
            }
        }
        
        class BtreePageOfDecimal:BtreePage
        {
            override internal Array Data
            {
                get
                {
                    return data;
                }
                
            }
            internal decimal[] data;
            
            const int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 16);
            
            
            internal override Key getKey(int i)
            {
                return new Key(data[i]);
            }
            
            internal override object getKeyValue(int i)
            {
                return data[i];
            }
            
            internal override BtreePage clonePage()
            {
                return new BtreePageOfDecimal(Storage);
            }
            
            internal override int compare(Key key, int i)
            {
                return key.dec.CompareTo(data[i]);
            }
            
            internal override void  insert(BtreeKey key, int i)
            {
                items[i] = key.node;
                data[i] = key.key.dec;
            }
            
            internal BtreePageOfDecimal(Storage s):base(s, MAX_ITEMS)
            {
                data = new decimal[MAX_ITEMS];
            }
            
            internal BtreePageOfDecimal()
            {
            }
        }
        
        class BtreePageOfObject:BtreePage
        {
            override internal Array Data
            {
                get
                {
                    return data.ToRawArray();
                }
                
            }
            internal Link data;
            
            const int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 4);
            
            
            internal override Key getKey(int i)
            {
                return new Key(data.GetRaw(i));
            }