Application: gvSIG desktop

package org.gvsig.fmap.dal.store.simplereader.virtualrows;

import java.io.File;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.ByteBuffer;

import java.nio.MappedByteBuffer;

import java.nio.channels.FileChannel;

import java.sql.Timestamp;

import java.util.AbstractList;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.io.IOUtils;

import org.gvsig.fmap.dal.store.simplereader.virtualrows.RecordsFile.Record;

import static org.gvsig.fmap.dal.store.simplereader.virtualrows.RecordsFile.TYPE_BYTE;

import static org.gvsig.fmap.dal.store.simplereader.virtualrows.RecordsFile.TYPE_STRING;

import static org.gvsig.fmap.dal.store.simplereader.virtualrows.RecordsFile.TYPE_TIMESTAMP;

/**

 *

 * @author jjdelcerro

 */

public class RecordsFileImpl 

        extends AbstractList<Record>

        implements RecordsFile 

    {

    public static class RecordImpl implements Record {

        private final RecordType type;

        private final ByteBuffer buffer;

        public RecordImpl(RecordType type) {

            this.type = type;

            this.buffer = ByteBuffer.allocate(this.type.getSize());

        }

        @Override

        public RecordType getType() {

            return this.type;

        }

        @Override

        public byte[] getBytes() {

            return this.buffer.array();

        }

        @Override

        public ByteBuffer getBuffer() {

            return this.buffer;

        }

        @Override

        public void setBytes(byte[] bytes) {

            this.buffer.position(0);

            this.buffer.put(bytes);

        }

        @Override

        public int getInt(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            return this.buffer.getInt();

        }

        @Override

        public long getLong(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            return this.buffer.getLong();

        }

        @Override

        public double getDouble(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            return this.buffer.getDouble();

        }

        @Override

        public Timestamp getTimestamp(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            long l = this.buffer.getLong();

            return new Timestamp(l);

        }

        @Override

        public String getString(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            short sz = this.buffer.getShort();

            char[] chars = new char[sz];

            for (int i = 0; i < sz; i++) {

                chars[i] = this.buffer.getChar(i);

            }

            return new String(chars);

        }

        @Override

        public byte[] getBytes(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            int sz = this.buffer.getInt();

            byte[] bytes = new byte[sz];

            for (int i = 0; i < sz; i++) {

                bytes[i] = this.buffer.get(i);

            }

            return bytes;

        }

        @Override

        public int getByte(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            return this.buffer.get();

        }

        @Override

        public int getShort(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            return this.buffer.getShort();

        }

        @Override

        public void setByte(int n, byte v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.put(v);

        }

        @Override

        public void setShort(int n, short v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putShort(v);

        }

        @Override

        public void setInt(int n, int v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putInt(v);

        }

        @Override

        public void setLong(int n, long v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putLong(v);

        }

        @Override

        public void setDouble(int n, double v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putDouble(v);

        }

        @Override

        public void setTimestamp(int n, Timestamp v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putLong(v.getTime());

        }

        @Override

        public void setString(int n, String v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putShort((short) v.length());

            for (int i = 0; i < v.length(); i++) {

                this.buffer.putChar(v.charAt(i));

            }

        }

        @Override

        public void setBytes(int n, byte[] v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putInt(v.length);

            for (int i = 0; i < v.length; i++) {

                this.buffer.put(v[i]);

            }

        }

    }

    public static class RecordTypeImpl implements RecordType {

        private static class FieldType {

            public byte type;

            public int size;

            public int offset;

        }

        private final List<FieldType> fields;

        private int size;

        public RecordTypeImpl() {

            this.fields = new ArrayList<>();

            this.size = -1;

        }

        public void add(int type, int size) {

            FieldType field = new FieldType();

            field.size = size;

            field.type = (byte) type;

            this.size = -1;

            field.offset = this.getSize();

            this.fields.add(field);

            this.size = -1;

            this.size = this.getSize();

        }

        @Override

        public int getSize() {

            if( this.size<0 ) {

                int sz = 0;

                for (FieldType field : fields) {

                    switch(field.type) {

                        case TYPE_BYTE:

                            sz += 1;

                            break;

                        case TYPE_SHORT:

                            sz += 2;

                            break;

                        case TYPE_INTEGER:

                            sz += 4;

                            break;

                        case TYPE_TIMESTAMP:

                        case TYPE_LONG:

                            sz += 8;

                            break;

                        case TYPE_DOUBLE:

                            sz += 8;

                            break;

                        case TYPE_STRING:

                            sz += 2 + (field.size*2);

                            break;

                        case TYPE_BYTES:

                            sz += 4 + field.size;

                            break;

                    }

                }

                this.size = sz;

            }

            return this.size;

        }

        @Override

        public int getFieldCount() {

            return this.fields.size();

        }

        @Override

        public int getFieldType(int n) {

            return this.fields.get(n).type;

        }

        @Override

        public int getFieldSize(int n) {

            return this.fields.get(n).size;

        }

        @Override

        public int getFieldOffset(int n) {

            return this.fields.get(n).offset;

        }

        @Override

        public Record createRecord() {

            this.size = -1;

            this.size = this.getSize();

            return new RecordImpl(this);

        }

        @Override

        public byte[] toBytes() {

            ByteBuffer buffer = ByteBuffer.allocate(this.fields.size()*(1+4));

            for (FieldType field : fields) {

                buffer.put(field.type);

                buffer.putInt(field.size);

            }

            return buffer.array();

        }

        public static RecordType from(ByteBuffer bytes) {

            RecordTypeImpl recordType = new RecordTypeImpl();

            bytes.position(0);

            int len = bytes.limit()/(1+4);

            for (int i = 0; i < len; i++) {

                int type = bytes.get();

                int size = bytes.getInt();

                recordType.add(type, size);

            }

            return recordType;

        }

        public static RecordType from(byte[] bytes) {

            ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.length);

            buffer.put(bytes);

            return from(buffer);

        }

    }

    public static class RecordTypeBuilderImpl implements RecordTypeBuilder {

        private final RecordTypeImpl recordType;

        public RecordTypeBuilderImpl() {

            this.recordType = new RecordTypeImpl();

        }

        @Override

        public RecordTypeBuilder addbyte() {

            this.recordType.add(TYPE_BYTE, 0);

            return this;

        }

        @Override

        public RecordTypeBuilder addShort() {

            this.recordType.add(TYPE_SHORT, 0);

            return this;

        }

        @Override

        public RecordTypeBuilder addInteger() {

            this.recordType.add(TYPE_INTEGER, 0);

            return this;

        }

        @Override

        public RecordTypeBuilder addLong() {

            this.recordType.add(TYPE_LONG, 0);

            return this;

        }

        @Override

        public RecordTypeBuilder addDouble() {

            this.recordType.add(TYPE_DOUBLE, 0);

            return this;

        }

        @Override

        public RecordTypeBuilder addTimestamp() {

            this.recordType.add(TYPE_TIMESTAMP, 0);

            return this;

        }

        @Override

        public RecordTypeBuilder addString(int size) {

            this.recordType.add(TYPE_STRING, size);

            return this;

        }

        @Override

        public RecordTypeBuilder addBytes(int size) {

            this.recordType.add(TYPE_BYTES, size);

            return this;

        }

        @Override

        public RecordType build() {

            return this.recordType;

        }

        public static RecordTypeBuilder recordTypeBuilder() {

            return new RecordTypeBuilderImpl();

        }

    }

    private static final int HEADER_SIZE = 1024;

    private RandomAccessFile raf;

    private MappedByteBuffer fileByteBuffer;

    private long sz;

    private int header_size;

    private int type_size;

    private RecordType recordType;

    public RecordsFileImpl() {

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public RecordsFileImpl(File f) throws IOException {

        this.open(f);

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public RecordsFileImpl(RandomAccessFile raf) throws IOException {

        this.open(raf);

    }

    @Override

    public RecordType getRecordType() {

        return this.recordType;

    }

    @Override

    public void open(File f) throws IOException {

        RandomAccessFile theRaf = new RandomAccessFile(f,"r");

        this.open(theRaf);

    }

    @Override

    public void open(RandomAccessFile raf) throws IOException {

        this.raf = raf;

        this.closeByteBuffer();

        this.raf.seek(0);

        this.raf.readLong(); //For future use

        this.raf.readLong(); //For future use

        this.header_size = (int) this.raf.readLong(); //Header size

        this.type_size = (int) this.raf.readLong(); //Record length

        byte[] recordTypeBytes = new byte[this.type_size];

        this.raf.read(recordTypeBytes);

        this.recordType = RecordType.from(recordTypeBytes);

        this.sz = (this.raf.length()-this.header_size) / this.recordType.getSize();

        // TODO: meter en la cabecera el numero de registros para poder escribir datos al final

    }

    @Override

    public void create(File f, RecordType recordType) throws IOException {

        RandomAccessFile theRaf = new RandomAccessFile(f,"rw");

        this.create(theRaf,recordType);

    }

    @Override

    public void create(RandomAccessFile raf, RecordType recordType) throws IOException {

        this.raf = raf;

        this.recordType = recordType;

        this.header_size = HEADER_SIZE;

        this.closeByteBuffer();

        this.sz = 0;

        byte[] recordTypeBytes = this.recordType.toBytes();

        this.raf.seek(0);

        this.raf.writeLong(0); //For future use

        this.raf.writeLong(0); //For future use

        this.raf.writeLong(this.header_size); //Header size

        this.raf.writeLong(recordTypeBytes.length); //Record length

        this.raf.write(recordTypeBytes);

        this.raf.setLength(this.header_size);

    }

    @Override

    public void close() throws IOException {

        this.closeByteBuffer();

        IOUtils.closeQuietly(this.raf);

        this.raf = null;

        this.sz = -1;

    }

    @Override

    public boolean isOpen() {

        return this.raf!=null;

    }

    public Record get(int position) {

        position = checkIndex(position);

        Record record = this.recordType.createRecord();

        this.getByteBuffer().position(this.header_size+(position*this.recordType.getSize()));

        this.getByteBuffer().get(record.getBytes());

        return record;

    }

    public Record get64(long position) {

        position = checkIndex(position);

        Record record = this.recordType.createRecord();

        this.getByteBuffer().position((int) (this.header_size+(position*this.recordType.getSize())));

        this.getByteBuffer().get(record.getBytes());

        return record;

    }

    @Override

    public int size() {

        return (int) this.sz;

    }

    @Override

    public long size64() {

        return this.sz;

    }

    public Record set(int position, Record record) {

        try {

            closeByteBuffer();

            position = checkIndex(position);

            this.raf.seek(this.header_size + (position * this.recordType.getSize()));

            this.raf.write(record.getBytes());

            return record;

        } catch (IOException ex) {

            throw new RuntimeException("Can't add record", ex);

        }

    }

    private int checkIndex(long index) {

        if (this.raf == null) {

            throw new IllegalStateException("Index not open");

        }

        if( index < 0 ) {

            index = ((int)this.sz) + index;

        }

        if( index<0 || index>=this.sz) {

            throw new IllegalArgumentException("Index out of range ("+index+")");

        }

        return (int) index;

    }

    private MappedByteBuffer getByteBuffer() {

        try {

            if (this.fileByteBuffer == null) {

                this.fileByteBuffer = this.raf.getChannel().map(

                        FileChannel.MapMode.READ_ONLY,

                        0,

                        this.raf.length()

                );

            }

            return this.fileByteBuffer;

        } catch (IOException ex) {

            throw new RuntimeException("Can't add record", ex);

        }

    }

    private void closeByteBuffer() {

        if(this.fileByteBuffer != null){

            this.fileByteBuffer.force();

            this.fileByteBuffer = null;

        }

    }

    public boolean add(Record record) {

        try {

            this.raf.seek(this.raf.length());

            this.raf.write(record.getBytes());

            this.closeByteBuffer();

            this.sz++;

            return true;

        } catch (IOException ex) {

            throw new RuntimeException("Can't add record", ex);

        }

    }

}