rndbtree.java

这个是perst-269.zip下面的SOURCECODE,和大家分享了。

                    pos = ((BtreePage)items.get(i)).traverseForward(height, result, pos);
                }
            } else { 
                for (i = 0; i < n; i++) { 
                    result[pos++] = items.get(i);
                }
            }
            return pos;
        }

        BtreePage(Storage s, int n) 
        { 
            super(s);
            items = s.createLink(n);
            items.setSize(n);
            nChildren = new int[n];
        }

        public BtreePage() {}            
    }


    static class BtreePageOfByte extends BtreePage { 
        byte[] data; 

        public void writeObject(IOutputStream out) {
            super.writeObject(out);
            out.writeArrayOfByte(data);
        }
        
        public void readObject(IInputStream in) {
            super.readObject(in);
            data = in.readArrayOfByte();
        }

         static final int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 1);
            
        Object getData() { 
            return data;
        }

        Object getKeyValue(int i) { 
            return new Byte(data[i]);
        }

        Key getKey(int i) { 
            return new Key(data[i]);
        }

        BtreePage clonePage() { 
            return new BtreePageOfByte(getStorage());
        }

        int compare(Key key, int i) {
            return (byte)key.ival - data[i];
        }

        void insert(BtreeKey key, int i) { 
            items.set(i, key.node);
            data[i] = (byte)key.key.ival;
        }

        BtreePageOfByte(Storage s) {
            super(s, MAX_ITEMS);
            data = new byte[MAX_ITEMS];
        }

        public BtreePageOfByte() {}
    }

    static class BtreePageOfBoolean extends BtreePageOfByte { 
        Key getKey(int i) { 
            return new Key(data[i] != 0);
        }

        Object getKeyValue(int i) { 
            return (data[i] != 0) ? Boolean.TRUE : Boolean.FALSE;
        }

        BtreePage clonePage() { 
            return new BtreePageOfBoolean(getStorage());
        }

        public BtreePageOfBoolean() {}
        
        BtreePageOfBoolean(Storage s) {
            super(s);
        }        
    }

    static class BtreePageOfShort extends BtreePage { 
        short[] data; 

        public void writeObject(IOutputStream out) {
            super.writeObject(out);
            out.writeArrayOfShort(data);
        }
        
        public void readObject(IInputStream in) {
            super.readObject(in);
            data = in.readArrayOfShort();
        }

        static final int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 2);
            
        Object getData() { 
            return data;
        }

        Key getKey(int i) { 
            return new Key(data[i]);
        }

        Object getKeyValue(int i) { 
            return new Short(data[i]);
        }

        BtreePage clonePage() { 
            return new BtreePageOfShort(getStorage());
        }

        int compare(Key key, int i) {
            return (short)key.ival - data[i];
        }

        void insert(BtreeKey key, int i) { 
            items.set(i, key.node);
            data[i] = (short)key.key.ival;
        }

        BtreePageOfShort(Storage s) {
            super(s, MAX_ITEMS);
            data = new short[MAX_ITEMS];
        }

        public BtreePageOfShort() {}
    }

    static class BtreePageOfChar extends BtreePage { 
        char[] data; 

        public void writeObject(IOutputStream out) {
            super.writeObject(out);
            out.writeArrayOfChar(data);
        }
        
        public void readObject(IInputStream in) {
            super.readObject(in);
            data = in.readArrayOfChar();
        }

        static final int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 2);
            
        Object getData() { 
            return data;
        }

        Key getKey(int i) { 
            return new Key(data[i]);
        }

        Object getKeyValue(int i) { 
            return new Character(data[i]);
        }

        BtreePage clonePage() { 
            return new BtreePageOfChar(getStorage());
        }

        int compare(Key key, int i) {
            return (char)key.ival - data[i];
        }

        void insert(BtreeKey key, int i) { 
            items.set(i, key.node);
            data[i] = (char)key.key.ival;
        }

        BtreePageOfChar(Storage s) {
            super(s, MAX_ITEMS);
            data = new char[MAX_ITEMS];
        }

        public BtreePageOfChar() {}
    }

    static class BtreePageOfInt extends BtreePage { 
        int[] data; 

        public void writeObject(IOutputStream out) {
            super.writeObject(out);
            out.writeArrayOfInt(data);
        }
        
        public void readObject(IInputStream in) {
            super.readObject(in);
            data = in.readArrayOfInt();
        }

        static final int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 4);
            
        Object getData() { 
            return data;
        }

        Key getKey(int i) { 
            return new Key(data[i]);
        }

        Object getKeyValue(int i) { 
            return new Integer(data[i]);
        }

        BtreePage clonePage() { 
            return new BtreePageOfInt(getStorage());
        }

        int compare(Key key, int i) {
            return key.ival - data[i];
        }

        void insert(BtreeKey key, int i) { 
            items.set(i, key.node);
            data[i] = key.key.ival;
        }

        BtreePageOfInt(Storage s) { 
            super(s, MAX_ITEMS);
            data = new int[MAX_ITEMS];
        }

        public BtreePageOfInt() {}
    }

    static class BtreePageOfLong extends BtreePage { 
        long[] data; 

        public void writeObject(IOutputStream out) {
            super.writeObject(out);
            out.writeArrayOfLong(data);
        }
        
        public void readObject(IInputStream in) {
            super.readObject(in);
            data = in.readArrayOfLong();
        }

        static final int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 8);
            
        Object getData() { 
            return data;
        }

        Key getKey(int i) { 
            return new Key(data[i]);
        }

        Object getKeyValue(int i) { 
            return new Long(data[i]);
        }

        BtreePage clonePage() { 
            return new BtreePageOfLong(getStorage());
        }

        int compare(Key key, int i) {
            return key.lval < data[i] ?  -1 : key.lval == data[i] ? 0 : 1;
        }

        void insert(BtreeKey key, int i) { 
            items.set(i, key.node);
            data[i] = key.key.lval;
        }

        BtreePageOfLong(Storage s) { 
            super(s, MAX_ITEMS);
            data = new long[MAX_ITEMS];
        }

        public BtreePageOfLong() {}
    }

    static class BtreePageOfFloat extends BtreePage { 
        float[] data; 

        public void writeObject(IOutputStream out) {
            super.writeObject(out);
            out.writeArrayOfFloat(data);
        }
        
        public void readObject(IInputStream in) {
            super.readObject(in);
            data = in.readArrayOfFloat();
        }

        static final int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 4);
            
        Object getData() { 
            return data;
        }

        Key getKey(int i) { 
            return new Key(data[i]);
        }

        Object getKeyValue(int i) { 
            return new Float(data[i]);
        }

        BtreePage clonePage() { 
            return new BtreePageOfFloat(getStorage());
        }

        int compare(Key key, int i) {
            return (float)key.dval < data[i] ? -1 : (float)key.dval == data[i] ? 0 : 1;
        }

        void insert(BtreeKey key, int i) { 
            items.set(i, key.node);
            data[i] = (float)key.key.dval;
        }

        BtreePageOfFloat(Storage s) {
            super(s, MAX_ITEMS);
            data = new float[MAX_ITEMS];
        }

        public BtreePageOfFloat() {}
    }

    static class BtreePageOfDouble extends BtreePage { 
        double[] data; 

        public void writeObject(IOutputStream out) {
            super.writeObject(out);
            out.writeArrayOfDouble(data);
        }
        
        public void readObject(IInputStream in) {
            super.readObject(in);
            data = in.readArrayOfDouble();
        }

        static final int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 8);
            
        Object getData() { 
            return data;
        }

        Key getKey(int i) { 
            return new Key(data[i]);
        }

        Object getKeyValue(int i) { 
            return new Double(data[i]);
        }

        BtreePage clonePage() { 
            return new BtreePageOfDouble(getStorage());
        }

        int compare(Key key, int i) {
            return key.dval < data[i] ? -1 : key.dval == data[i] ? 0 : 1;
        }

        void insert(BtreeKey key, int i) { 
            items.set(i, key.node);
            data[i] = key.key.dval;
        }

        BtreePageOfDouble(Storage s) {
            super(s, MAX_ITEMS);
            data = new double[MAX_ITEMS];
        }

        public BtreePageOfDouble() {}
    }


    static class BtreePageOfObject extends BtreePage { 
        Link data; 

        public void writeObject(IOutputStream out) {
            super.writeObject(out);
            out.writeLink(data);
        }
        
        public void readObject(IInputStream in) {
            super.readObject(in);
            data = in.readLink();
        }

        static final int MAX_ITEMS = BTREE_PAGE_SIZE / (4 + 4 + 4);
            
        Object getData() { 
            return data.toRawArray();
        }

        Key getKey(int i) { 
            return new Key(data.getRaw(i));
        }

        Object getKeyValue(int i) { 
            return data.get(i);
        }