--- /dev/null
+/*******************************************************************************\r
+ * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
+ * in Industry THTH ry.\r
+ * All rights reserved. This program and the accompanying materials\r
+ * are made available under the terms of the Eclipse Public License v1.0\r
+ * which accompanies this distribution, and is available at\r
+ * http://www.eclipse.org/legal/epl-v10.html\r
+ *\r
+ * Contributors:\r
+ * VTT Technical Research Centre of Finland - initial API and implementation\r
+ *******************************************************************************/\r
+package org.simantics.db.impl;\r
+\r
+import org.simantics.db.exception.DatabaseException;\r
+import org.simantics.db.impl.ClusterI.Procedure;\r
+import org.simantics.db.service.Bytes;\r
+\r
+interface TableFactoryI<TableType> {\r
+ TableType newTable(int size);\r
+ boolean isEqual(TableType t1, int t1Start, int size, TableType t2, int t2Start);\r
+}\r
+\r
+class ByteFactory implements TableFactoryI<byte[]> {\r
+ @Override\r
+ public byte[] newTable(int size) {\r
+ return new byte[size];\r
+ }\r
+\r
+ @Override\r
+ public boolean isEqual(byte[] t1, int start, int size, byte[] t2, int start2) {\r
+ for (int i=0; i<size; ++i)\r
+ if (t1[start + i] != t2[start2 + i])\r
+ return false;\r
+ return true;\r
+ }\r
+}\r
+\r
+class IntFactory implements TableFactoryI<int[]> {\r
+ @Override\r
+ public int[] newTable(int size) {\r
+ return new int[size];\r
+ }\r
+\r
+ @Override\r
+ public boolean isEqual(int[] t1, int start, int size, int[] t2, int start2) {\r
+ for (int i=0; i<size; ++i)\r
+ if (t1[start + i] != t2[start2 + i])\r
+ return false;\r
+ return true;\r
+ }\r
+}\r
+\r
+class LongFactory implements TableFactoryI<long[]> {\r
+ @Override\r
+ public long[] newTable(int size) {\r
+ return new long[size];\r
+ }\r
+\r
+ @Override\r
+ public boolean isEqual(long[] t1, int start, int size, long[] t2, int start2) {\r
+ for (int i=0; i<size; ++i)\r
+ if (t1[start + i] != t2[start2 + i])\r
+ return false;\r
+ return true;\r
+ }\r
+}\r
+\r
+public abstract class Table<TableType> {\r
+ private static final int INITIAL_SIZE = 100; // Initial size of the table. Must be greater or equal than header_size;\r
+ private static final int INCREMENT_SIZE = 1000; // Minimum increment size of the table.\r
+ protected static final int ZERO_SHIFT = 1; // Indexes are guaranteed not to be zero.\r
+ final private TableHeader header;\r
+ final private TableFactoryI<TableType> factory;\r
+ final private TableSizeListener sizeListener;\r
+ public int offset; // Offset of table in containing array.\r
+ public TableType table;\r
+ protected Table(TableFactoryI<TableType> factory, TableSizeListener sizeListener, int[] header, int headerBase) {\r
+ this.factory = factory;\r
+ this.sizeListener = sizeListener;\r
+ this.header = new TableHeader(header, headerBase);\r
+ this.offset = -ZERO_SHIFT;\r
+ newTable(INITIAL_SIZE);\r
+ this.header.setSize(0);\r
+ this.header.setCount(0);\r
+ this.header.setOffset(offset);\r
+ }\r
+\r
+// final int size(Object bytes) {\r
+// if(bytes instanceof byte[]) return ((byte[])bytes).length;\r
+// if(bytes instanceof int[]) return ((int[])bytes).length;\r
+// if(bytes instanceof long[]) return ((long[])bytes).length;\r
+// return 0;\r
+// }\r
+\r
+ protected Table(TableFactoryI<TableType> factory, TableSizeListener sizeListener, int[] header, int headerBase, TableType bytes) {\r
+// System.out.println("Table size=" + size(bytes) + " header = " + Arrays.toString(Arrays.copyOfRange(header, headerBase, headerBase + 4)));\r
+ this.factory = factory;\r
+ this.sizeListener = sizeListener;\r
+ this.header = new TableHeader(header, headerBase);\r
+ offset = this.header.getOffset();\r
+ this.table = bytes;\r
+ }\r
+ /**\r
+ * Create and initialize this with a new table.\r
+ *\r
+ * @param capacity of the table. How many elements the table can hold without allocating new space.\r
+ * @param size of the table. How many elements have been used.\r
+ * @param count of how many segments has been have been allocated.\r
+ * @return old table.\r
+ */\r
+ final protected TableType createNewTable(int capacity, int size, int count) {\r
+ TableType t = table;\r
+ this.offset = -ZERO_SHIFT;\r
+ newTable(capacity);\r
+ sizeListener.resized();\r
+ header.setSize(size);\r
+ header.setCount(count);\r
+ header.setOffset(offset);\r
+ return t;\r
+ }\r
+ public final int getTableCapacity() {\r
+ return header.getCapacity();\r
+ }\r
+ public final int getTableSize() {\r
+ return header.getSize();\r
+ }\r
+ public final int getTableCount() {\r
+ return header.getCount();\r
+ }\r
+ protected int convertRealIndexToTableIndex(int realIndex) {\r
+ return realIndex - offset;\r
+ }\r
+ protected final int checkIndexAndGetRealIndex(int index, int size) {\r
+ if (index < ZERO_SHIFT)\r
+ throw new IllegalArgumentException("Underflow, index=" + index);\r
+ if ((size > 0 && index - ZERO_SHIFT + size > header.getSize()))\r
+ throw new IllegalArgumentException("Overflow, index=" + index + " size=" + size);\r
+ return index + offset;\r
+ }\r
+ protected final int checkIndexAndGetRealIndexEx(int index, int size) {\r
+ if (index < ZERO_SHIFT || size < 1)\r
+ throw new IllegalArgumentException("Underflow, index=" + index + " size=" + size);\r
+ if (index - ZERO_SHIFT + size < header.getSize())\r
+ return index + offset;\r
+ else if (index - ZERO_SHIFT + size == header.getSize())\r
+ return -1;\r
+ else\r
+ throw new IllegalArgumentException("Underflow, index=" + index + " size=" + size);\r
+ }\r
+ final protected void getCopy(int index, byte[] to, int start, int size) {\r
+ int realIndex = checkIndexAndGetRealIndex(index, size);\r
+ if (size < 0)\r
+ throw new IllegalArgumentException("Illgal table size " + size);\r
+ System.arraycopy(table, realIndex, to, start, size);\r
+ }\r
+ final protected void getCopy(int index, char[] to, int start, int size) {\r
+// int realIndex = checkIndexAndGetRealIndex(index, size);\r
+// if (size < 0)\r
+// throw new IllegalArgumentException("Illgal table size " + size);\r
+ byte[] bs = (byte[])table;\r
+ start += index+offset+1;\r
+ for(int i=0;i<size;i++) to[i] = (char)bs[start++];\r
+// System.arraycopy(table, realIndex, to, start, size);\r
+ }\r
+ final protected void setCopy(int index, int size, TableType from, int fromStartIndex) {\r
+// System.out.println("setCopy index=" + index + " size=" + size + "fromStartIndex=" + fromStartIndex + "from.length=" + ((byte[])from).length + "table.length=" + ((byte[])table).length);\r
+ int realIndex = checkIndexAndGetRealIndex(index, size);\r
+ System.arraycopy(from, fromStartIndex, table, realIndex, size);\r
+ }\r
+ final protected boolean isEqual(int index, TableType to, int toStartIndex, int toSize) {\r
+ int realIndex = checkIndexAndGetRealIndex(index, toSize);\r
+ return factory.isEqual(table, realIndex, toSize, to, toStartIndex);\r
+ }\r
+ /**\r
+ * @param size of the element (how many table slots is allocated).\r
+ * @return table index not the real index. To get real index use checkIndexAndGetRealIndex.\r
+ */\r
+ final protected int createNewElement(int size) {\r
+ if (size < 0)\r
+ throw new IllegalArgumentException("Illegal table size " + size);\r
+ if (0 == size)\r
+ return ZERO_SHIFT;\r
+ int oldSize = header.getSize();\r
+ int newSize = oldSize + size;\r
+ if (newSize > header.getCapacity())\r
+ realloc(newSize);\r
+ header.setSize(newSize);\r
+ header.setCount(header.getCount()+1);\r
+ return ZERO_SHIFT + oldSize;\r
+ }\r
+ final protected void deleteOldElement(int index, int size) {\r
+ checkIndexAndGetRealIndex(index, size);\r
+ header.setCount(header.getCount()-1);\r
+ }\r
+ final protected TableHeader getHeader() {\r
+ return header;\r
+ }\r
+ final protected int getTableBase() {\r
+ return offset + ZERO_SHIFT;\r
+ }\r
+ final protected TableType getTable() {\r
+ return table;\r
+ }\r
+ final protected int getExtra(int index) {\r
+ return header.getExtra(index);\r
+ }\r
+ final protected void setExtra(int index, int value) {\r
+ header.setExtra(index, value);\r
+ }\r
+ final private void realloc(int newSize) {\r
+ int realCapacity = newSize + Math.max(INCREMENT_SIZE, newSize/10);\r
+ TableType oldTable = table;\r
+ newTable(realCapacity);\r
+ sizeListener.resized();\r
+ int oldBase = getTableBase();\r
+ offset = -ZERO_SHIFT;\r
+ header.setOffset(offset);\r
+ int oldSize = header.getSize();\r
+ // If zero can cause ArrayIndexOutOfBoundsException because oldBase\r
+ // (index) can be out of bounds in this case and it is checked even\r
+ // if olsSize is zero (i.e. number of copied bytes is zero).\r
+ if (oldSize > 0) {\r
+ System.arraycopy(oldTable, oldBase, table, 0, oldSize);\r
+ }\r
+ }\r
+ final private void newTable(int capacity) {\r
+ table = factory.newTable(capacity);\r
+ header.setCapacity(capacity);\r
+ }\r
+ \r
+ public <T> int store(T _ret, int retPos) {\r
+ \r
+ int off = retPos;\r
+ \r
+ if(table instanceof byte[]) {\r
+ System.arraycopy(table, getTableBase(), _ret, retPos, getHeader().getSize());\r
+ retPos += getHeader().getSize();\r
+ } else if(table instanceof int[]) {\r
+ int[] t = (int[])table;\r
+ int[] ret = (int[])_ret;\r
+ for(int i=getTableBase();i<getTableBase() + getHeader().getSize();i++) {\r
+ int v = t[i];\r
+ ret[retPos++] = v;\r
+// Bytes.writeLE(ret, retPos, v);\r
+// retPos += 4;\r
+ }\r
+ } else if(table instanceof long[]) {\r
+ long[] t = (long[])table;\r
+ long[] ret = (long[])_ret;\r
+ for(int i=getTableBase();i<getTableBase() + getHeader().getSize();i++) {\r
+ long v = t[i];\r
+ ret[retPos++] = v;\r
+// Bytes.writeLE8(ret, retPos, v);\r
+// retPos += 8;\r
+ }\r
+ }\r
+ getHeader().setOffset(off-1);\r
+ getHeader().setCapacity(getHeader().getSize());\r
+ return retPos;\r
+ }\r
+ \r
+ public <T> int storeBytes(byte[] _ret, int off, int retPos) {\r
+ \r
+ //int off = retPos;\r
+ \r
+ if(table instanceof byte[]) {\r
+ System.arraycopy(table, getTableBase(), _ret, retPos, getHeader().getSize());\r
+ retPos += getHeader().getSize();\r
+ } else if(table instanceof int[]) {\r
+ int[] t = (int[])table;\r
+ for(int i=getTableBase();i<getTableBase() + getHeader().getSize();i++) {\r
+ int v = t[i];\r
+// ret[retPos++] = v;\r
+ Bytes.writeLE(_ret, retPos, v);\r
+ retPos += 4;\r
+ }\r
+ } else if(table instanceof long[]) {\r
+ long[] t = (long[])table;\r
+ for(int i=getTableBase();i<getTableBase() + getHeader().getSize();i++) {\r
+ long v = t[i];\r
+ Bytes.writeLE8(_ret, retPos, v);\r
+ retPos += 8;\r
+ }\r
+ }\r
+ \r
+ getHeader().setOffset(off-1);\r
+ getHeader().setCapacity(getHeader().getSize());\r
+ return retPos;\r
+ \r
+ }\r
+ \r
+ public abstract <Context> boolean foreach(int setIndex, Procedure procedure, final Context context, final ClusterSupport support, Modifier modifier) throws DatabaseException;\r
+ \r
+}\r
Code Review / simantics / platform.git / blobdiff