--- /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.procore.cluster;\r
+\r
+import java.util.ArrayList;\r
+\r
+import org.simantics.db.Resource;\r
+import org.simantics.db.common.utils.Logger;\r
+import org.simantics.db.exception.DatabaseException;\r
+import org.simantics.db.exception.ExternalValueException;\r
+import org.simantics.db.exception.ValidationException;\r
+import org.simantics.db.impl.ClusterBase;\r
+import org.simantics.db.impl.ClusterI;\r
+import org.simantics.db.impl.ClusterI.CompleteTypeEnum;\r
+import org.simantics.db.impl.ClusterI.ObjectProcedure;\r
+import org.simantics.db.impl.ClusterI.PredicateProcedure;\r
+import org.simantics.db.impl.ClusterI.Procedure;\r
+import org.simantics.db.impl.ClusterSupport;\r
+import org.simantics.db.impl.ClusterTraitsBase;\r
+import org.simantics.db.impl.Modifier;\r
+import org.simantics.db.impl.ResourceImpl;\r
+import org.simantics.db.impl.Table;\r
+import org.simantics.db.impl.TableFactory;\r
+import org.simantics.db.impl.TableSizeListener;\r
+import org.simantics.db.impl.graph.ReadGraphImpl;\r
+import org.simantics.db.procedure.AsyncContextMultiProcedure;\r
+import org.simantics.db.procedure.AsyncMultiProcedure;\r
+import org.simantics.db.procore.cluster.PredicateTable.Status;\r
+\r
+\r
+final class ResourceElement {\r
+ private static final boolean DEBUG = ClusterImpl.DEBUG;\r
+ private static final int DESCRIPTOR_OFFSET = 0; // predicate descriptor\r
+ private static final int VALUE_OFFSET = 1; // value descriptor\r
+ private static final int STM_OFFSET = 2; // first statement\r
+ private static final int SIZE_OF = 4;\r
+\r
+ static void construct(long[] table, int index) {\r
+ int i = DESCRIPTOR_OFFSET + index;\r
+ table[i++] = 0; // predicate capacity & index\r
+ table[i++] = 0; // value capacity & index\r
+ table[i++] = 0; // stm1\r
+ table[i++] = 0; // stm2\r
+ }\r
+\r
+ static void destruct(long[] table, int index) {\r
+ int i = DESCRIPTOR_OFFSET + index;\r
+ table[i++] = 0; // predicate capacity & index\r
+ table[i++] = 0; // value capacity & index\r
+ table[i++] = 0; // stm1\r
+ table[i++] = 0; // stm2\r
+ }\r
+\r
+ static boolean isUsed(long[] table, int index) {\r
+ int i = DESCRIPTOR_OFFSET + index;\r
+ if (table[i++] != 0)\r
+ return true;\r
+ if (table[i++] != 0)\r
+ return true;\r
+ if (table[i++] != 0)\r
+ return true;\r
+ if (table[i++] != 0)\r
+ return true;\r
+ return false;\r
+ }\r
+\r
+ static int getSizeOf() {\r
+ return SIZE_OF;\r
+ }\r
+\r
+ static int getCompleteObjectRef(long[] table, int index) {\r
+ int i = DESCRIPTOR_OFFSET + index;\r
+ return BitUtility.getHighInt(table[i]);\r
+ }\r
+\r
+ static void setCompleteObjectRef(long[] table, int index, int ref) {\r
+ int i = DESCRIPTOR_OFFSET + index;\r
+ table[i] = BitUtility.setHighInt(table[i], ref);\r
+ }\r
+\r
+ static int getPredicateIndex(long[] table, int index) {\r
+ int i = DESCRIPTOR_OFFSET + index;\r
+ int predicateIndex = BitUtility.getLowInt(table[i]);\r
+ assert (predicateIndex >= 0);\r
+ return predicateIndex;\r
+ }\r
+\r
+ static void setPredicateIndex(long[] table, int index, int predicateIndex) {\r
+ assert (predicateIndex >= 0);\r
+ int i = DESCRIPTOR_OFFSET + index;\r
+ table[i] = BitUtility.setLowInt(table[i], predicateIndex);\r
+ }\r
+\r
+ static int copyValue(ValueTable valueTable, long[] table, int index, byte[] byteTable, int byteSize, int byteBase,\r
+ int byteCurrent) {\r
+ int i = VALUE_OFFSET + index;\r
+ if (0 == table[i] || -1 == table[i])\r
+ return byteCurrent; // no value or external value\r
+ // getValueCapacity call optimized away\r
+ int capacity = BitUtility.getLowInt(table[i]);\r
+ int valueIndex = getValueIndex(table, index);\r
+ if (0 == valueIndex)\r
+ return byteCurrent;\r
+ valueTable.getValue(valueIndex, byteTable, byteCurrent, capacity);\r
+ valueIndex = byteCurrent - byteBase;\r
+ setValueIndex(table, index, valueIndex);\r
+ byteCurrent += capacity;\r
+ return byteCurrent;\r
+ }\r
+\r
+ static byte[] getValue(ValueTable valueTable, long[] table, int index)\r
+ throws DatabaseException {\r
+ int i = VALUE_OFFSET + index;\r
+ if (0 == table[i])\r
+ return null; // no value\r
+ if (-1 == table[i])\r
+ throw new ExternalValueException("Value stored externally.");\r
+ // getValueCapacity call optimized away\r
+ int capacity = BitUtility.getLowInt(table[i]);\r
+ byte[] t = new byte[capacity];\r
+ int valueIndex = getValueIndex(table, index);\r
+ valueTable.getValue(valueIndex, t, 0, capacity);\r
+ return t;\r
+ }\r
+\r
+// static int getString(ValueTable valueTable, long[] table, int index, char[] t)\r
+// throws DatabaseException {\r
+// long l = table[index + VALUE_OFFSET];\r
+// if (-1 == l)\r
+// throw new ExternalValueException("String stored externally.");\r
+// int capacity = (int)l;\r
+// int valueIndex = (int) (l >>> 32);\r
+//// char[] t = new char[capacity-1];\r
+// valueTable.getString(valueIndex, t, 0, capacity-1);\r
+// return capacity-1;\r
+// \r
+// }\r
+\r
+ static boolean hasValue(long[] table, int index) {\r
+ int i = VALUE_OFFSET + index;\r
+ return 0 != table[i];\r
+ }\r
+//KRAA:\r
+// static boolean hasValue(ValueTable valueTable, long[] table, int index, byte[] value) {\r
+// int i = VALUE_OFFSET + index;\r
+// if (0 == table[i])\r
+// return false;\r
+// // getValueCapacity call optimized away\r
+// int capacity = BitUtility.getLowInt(table[i]);\r
+// if (capacity != value.length)\r
+// return false;\r
+// int valueIndex = getValueIndex(table, index);\r
+// return valueTable.isEqual(valueIndex, value);\r
+// }\r
+\r
+ static boolean removeValue(ValueTable valueTable, long[] table, int index) {\r
+ int i = VALUE_OFFSET + index;\r
+ if (0 == table[i])\r
+ return false;\r
+ else if (-1 != table[i]) {\r
+ // getValueCapacity call optimized away\r
+ int capacity = BitUtility.getLowInt(table[i]);\r
+ int valueIndex = getValueIndex(table, index);\r
+ valueTable.removeValue(valueIndex, capacity);\r
+ }\r
+ //setValueCapacityAndIndex(table, index, 0, 0); optimized away\r
+ table[i] = 0;\r
+ return true;\r
+ }\r
+\r
+ public static void setValue(ValueTable valueTable, long[] table, int index, byte[] value, int length) {\r
+ int i = VALUE_OFFSET + index;\r
+ // getValueCapacity call optimized away\r
+ int capacity = BitUtility.getLowInt(table[i]); \r
+ int valueIndex = getValueIndex(table, index);\r
+ if (length <= capacity) {\r
+ valueTable.setValue(valueIndex, value, length);\r
+ // we "leak" memory TODO: add value size member to\r
+ // resource entry or value entry\r
+ setValueCapacity(table, index, length);\r
+ } else {\r
+ if (valueIndex != 0 && capacity > 0)\r
+ valueTable.removeValue(valueIndex, capacity);\r
+ valueIndex = valueTable.createValue(value, 0, length);\r
+ capacity = length;\r
+ setValueCapacityAndIndex(table, index, capacity, valueIndex);\r
+ }\r
+ return;\r
+ }\r
+ public static boolean isValueEx(ValueTable valueTable, long[] table, int index) {\r
+ int i = VALUE_OFFSET + index;\r
+ if (-1 == table[i])\r
+ return true;\r
+ else\r
+ return false;\r
+ }\r
+ public static void setValueEx(ValueTable valueTable, long[] table, int index) {\r
+ int i = VALUE_OFFSET + index;\r
+ if (-1 == table[i])\r
+ return;\r
+ else if (0 != table[i]) {\r
+ int capacity = BitUtility.getLowInt(table[i]);\r
+ int valueIndex = getValueIndex(table, index);\r
+ valueTable.removeValue(valueIndex, capacity);\r
+ }\r
+ //setValueCapacityAndIndex(table, index, 0, 0); optimized away\r
+ table[i] = -1;\r
+ }\r
+ static class ValueData {\r
+ int capacity;\r
+ int index;\r
+// ValueData(int capacity, int index) {\r
+// this.capacity = capacity;\r
+// this.index = index;\r
+// }\r
+ }\r
+ static void getValueCapacityAndIndex(ValueData vd, long[] table, int index) {\r
+ int i = VALUE_OFFSET + index;\r
+ // getValueCapacity call optimized away\r
+ vd.capacity = BitUtility.getLowInt(table[i]); \r
+ vd.index = getValueIndex(table, index);\r
+ \r
+ }\r
+ private static int getValueIndex(long[] table, int index) {\r
+ int i = VALUE_OFFSET + index;\r
+ return BitUtility.getHighInt(table[i]);\r
+ }\r
+\r
+ private static void setValueIndex(long[] table, int index, int valueIndex) {\r
+ int i = VALUE_OFFSET + index;\r
+ table[i] = BitUtility.setHighInt(table[i], valueIndex);\r
+ }\r
+\r
+ private static void setValueCapacity(long[] table, int index, int capacity) {\r
+ int i = VALUE_OFFSET + index;\r
+ table[i] = BitUtility.setLowInt(table[i], capacity);\r
+ }\r
+\r
+ private static void setValueCapacityAndIndex(long[] table, int index, int capacity, int valueIndex) {\r
+ int i = VALUE_OFFSET + index;\r
+ table[i] = BitUtility.setLowAndHighInt(table[i], capacity, valueIndex);\r
+ }\r
+\r
+ public static <Context> boolean foreachPredicate(long[] table, int index,\r
+ ClusterI.PredicateProcedure<Context> procedure,\r
+ Context context, ClusterSupport support, Modifier modifier,\r
+ CompleteTable ct)\r
+ throws DatabaseException {\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachPredicate: 1");\r
+ int completeRef = ResourceElement.getCompleteObjectRef(table, index);\r
+ if (0 != completeRef) {\r
+ if (ClusterTraits.completeReferenceIsMultiple(completeRef)) { // multiple complete type elements\r
+ boolean broken = ct.foreachPredicate(completeRef, procedure, context, support, modifier);\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachPredicate: multi-complete ci=" + completeRef + " break=" + broken);\r
+ if (broken)\r
+ return true; // loop broken by procedure\r
+ } else {\r
+ ClusterI.CompleteTypeEnum completeType = ClusterTraits.completeReferenceGetType(completeRef);\r
+ if (ClusterI.CompleteTypeEnum.NotComplete != completeType) {\r
+ int key = ClusterTraitsBase.getCompleteTypeResourceKeyFromEnum(completeType);\r
+ boolean broken = procedure.execute(context, key, 0);\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachPredicate: complete rk=" + key + " break=" + broken);\r
+ if (broken)\r
+ return true; // loop broken by procedure\r
+ }\r
+ }\r
+ }\r
+ // If predicate set is in use it will contain also these statements.\r
+ if (0 != ResourceElement.getPredicateIndex(table, index)) {\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachPredicate: more than 2 objects");\r
+ return false;\r
+ }\r
+ int i = STM_OFFSET + index;\r
+ int p1 = BitUtility.getHighInt(table[i]);\r
+ if (0 == p1) {\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachPredicate: empty cache");\r
+ return false; // loop finished, no statements\r
+ }\r
+ int externalRef;\r
+ if (null == modifier)\r
+ externalRef = p1;\r
+ else\r
+ externalRef = modifier.execute(p1);\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachPredicate: cache1 pk=" + externalRef);\r
+ if (procedure.execute(context, externalRef, 0))\r
+ return true; // loop broken by procedure\r
+ int p2 = BitUtility.getHighInt(table[++i]);\r
+ if (0 == p2 || p1 == p2) {\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachPredicate: cache2 empty");\r
+ return false; // loop finished, one statement\r
+ } if (null == modifier)\r
+ externalRef = p2;\r
+ else\r
+ externalRef = modifier.execute(p2);\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachPredicate: cache2 pk=" + externalRef);\r
+ if (procedure.execute(context, externalRef, 0))\r
+ return true; // loop broken by procedure\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachPredicate: not in cache");\r
+ return false; // loop finished, two statements\r
+ }\r
+\r
+ public static int getSingleObject(long[] table, int index, ClusterSupport support, final int pRef, final ClusterI.CompleteTypeEnum pCompleteType, CompleteTable ct, final Modifier modifier)\r
+ throws DatabaseException {\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.getSingleObject: index=" + index);\r
+ if (ClusterI.CompleteTypeEnum.NotComplete != pCompleteType) {\r
+ int completeRef = getCompleteObjectRef(table, index);\r
+ if (0 == completeRef)\r
+ return 0; // no objects for given complete type\r
+ if (ClusterTraits.completeReferenceIsMultiple(completeRef)) {\r
+ // Multiple complete type elements.\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.getSingleObject was complete 2");\r
+ class ForeachObject\r
+ implements ClusterI.ObjectProcedure<Integer> {\r
+ @Override\r
+ public boolean execute(Integer context, int completeRef)\r
+ throws DatabaseException {\r
+ ClusterI.CompleteTypeEnum oCompleteType = ClusterTraits.completeReferenceGetType(completeRef);\r
+ if (pCompleteType == oCompleteType) { // we have a match\r
+ if (context != 0) { // we have an old match\r
+ context = 0; // multiple objects for given type\r
+ return true; // break loop\r
+ }\r
+ int clusterIndex = ClusterTraits.completeReferenceGetForeignIndex(completeRef);\r
+ int resourceIndex = ClusterTraits.completeReferenceGetResourceIndex(completeRef);\r
+ if (0 == clusterIndex) {\r
+ context = modifier.execute(resourceIndex);\r
+ } else {\r
+ int externalRef = ClusterTraits.createForeignReference(clusterIndex, resourceIndex);\r
+ context = modifier.execute(externalRef);\r
+ }\r
+ }\r
+ return true; // continue looping\r
+ }\r
+ \r
+ }\r
+ ForeachObject t = new ForeachObject();\r
+ // CompleteRef is complete object set index.\r
+ Integer c = 0;\r
+ ct.foreachComplete(completeRef, t, c, support, modifier);\r
+ return c;\r
+ }\r
+ // one complete type element\r
+ ClusterI.CompleteTypeEnum completeType = ClusterTraits.completeReferenceGetType(completeRef);\r
+ if (pCompleteType != completeType)\r
+ return 0;\r
+ int clusterIndex = ClusterTraits.completeReferenceGetForeignIndex(completeRef);\r
+ int resourceIndex = ClusterTraits.completeReferenceGetResourceIndex(completeRef);\r
+ if (0 == clusterIndex) {\r
+ return modifier.execute(resourceIndex);\r
+ } else {\r
+ int externalRef = ClusterTraits.createForeignReference(clusterIndex, resourceIndex);\r
+ return modifier.execute(externalRef);\r
+ }\r
+ }\r
+ int i = STM_OFFSET + index;\r
+ int p1 = BitUtility.getHighInt(table[i]);\r
+ if (0 == p1)\r
+ return 0; // loop finished, no statements\r
+ int result = 0;\r
+ if (pRef == p1) {\r
+ int o1 = BitUtility.getLowInt(table[i]);\r
+ result = modifier.execute(o1);\r
+// procedure.execute(graph, new ResourceImpl(null, modifier.execute(o1)));\r
+// int externalRef;\r
+// if (null == modifier)\r
+// externalRef = o1;\r
+// else\r
+// externalRef = modifier.execute(callerThread, o1);\r
+// if (procedure.execute(callerThread, context, externalRef))\r
+// return true; // loop broken by procedure\r
+ }\r
+ int p2 = BitUtility.getHighInt(table[++i]);\r
+ if (0 == p2 || pRef != p2)\r
+ return result; // loop finished, one statements\r
+\r
+ // Many statements\r
+ if (result != 0) return -1;\r
+ \r
+ int o2 = BitUtility.getLowInt(table[i]);\r
+ return modifier.execute(o2);\r
+ \r
+// return 0;\r
+// int o2 = BitUtility.getLowInt(table[i]);\r
+// int externalRef;\r
+// if (null == modifier)\r
+// externalRef = o2;\r
+// else\r
+// externalRef = modifier.execute(callerThread, o2);\r
+// if (procedure.execute(callerThread, context, externalRef))\r
+// return true; // loop broken by procedure\r
+// return false; // loop finished\r
+// procedure.execute(graph, new ResourceImpl(null, modifier.execute(o2)));\r
+ }\r
+ \r
+ public static void foreachObject(long[] table, int index,\r
+ final ReadGraphImpl graph, final AsyncMultiProcedure<Resource> procedure,\r
+ final ClusterSupport support, final int pRef, final ClusterI.CompleteTypeEnum pCompleteType, CompleteTable ct, final Modifier modifier)\r
+ throws DatabaseException {\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachObject1: index=" + index);\r
+ if (ClusterI.CompleteTypeEnum.NotComplete != pCompleteType) {\r
+ int completeRef = getCompleteObjectRef(table, index);\r
+ if (0 == completeRef) {\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ return; // no objects for given complete type\r
+ }\r
+ if (ClusterTraits.completeReferenceIsMultiple(completeRef)) {\r
+ // Multiple complete type statements.\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.was complete 2");\r
+ class ForeachObject implements ClusterI.ObjectProcedure<Object> {\r
+ @Override\r
+ public boolean execute(Object context, int completeRef) throws DatabaseException {\r
+ ClusterI.CompleteTypeEnum oCompleteType = ClusterTraits.completeReferenceGetType(completeRef);\r
+ if (pCompleteType == oCompleteType) {\r
+ int clusterIndex = ClusterTraits.completeReferenceGetForeignIndex(completeRef);\r
+ int resourceIndex = ClusterTraits.completeReferenceGetResourceIndex(completeRef);\r
+ if (0 == clusterIndex) {\r
+ procedure.execute(graph, new ResourceImpl(graph.getResourceSupport(), modifier.execute(resourceIndex)));\r
+ } else {\r
+ int externalRef = ClusterTraits.createForeignReference(clusterIndex, resourceIndex);\r
+ procedure.execute(graph, new ResourceImpl(graph.getResourceSupport(), modifier.execute(externalRef)));\r
+ }\r
+ }\r
+ return false; // continue looping\r
+ }\r
+ \r
+ }\r
+ ForeachObject t = new ForeachObject();\r
+ // CompleteRef is complete object set index.\r
+ ct.foreachComplete(completeRef, t, null, support, modifier);\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ return; // loop finished\r
+ }\r
+ // one complete type element\r
+ ClusterI.CompleteTypeEnum completeType = ClusterTraits.completeReferenceGetType(completeRef);\r
+ if (pCompleteType != completeType) {\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ return;\r
+ }\r
+ int clusterIndex = ClusterTraits.completeReferenceGetForeignIndex(completeRef);\r
+ int resourceIndex = ClusterTraits.completeReferenceGetResourceIndex(completeRef);\r
+ if (0 == clusterIndex) {\r
+ procedure.execute(graph, new ResourceImpl(graph.getResourceSupport(), modifier.execute(resourceIndex)));\r
+ } else {\r
+ int externalRef = ClusterTraits.createForeignReference(clusterIndex, resourceIndex);\r
+ procedure.execute(graph, new ResourceImpl(graph.getResourceSupport(), modifier.execute(externalRef)));\r
+ }\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ return; // loop finished\r
+ }\r
+ int i = STM_OFFSET + index;\r
+ long l = table[i];\r
+ int p1 = (int) (l >>> 32);\r
+ if (0 == p1) {\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ return; // loop finished, no statements\r
+ }\r
+ if (pRef == p1) {\r
+ int o1 = (int)l;\r
+ procedure.execute(graph, new ResourceImpl(graph.getResourceSupport(), modifier.execute(o1)));\r
+// int externalRef;\r
+// if (null == modifier)\r
+// externalRef = o1;\r
+// else\r
+// externalRef = modifier.execute(callerThread, o1);\r
+// if (procedure.execute(callerThread, context, externalRef))\r
+// return true; // loop broken by procedure\r
+ }\r
+ long l2 = table[++i];\r
+ int p2 = (int) (l2 >>> 32);\r
+ if (pRef != p2) {\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ return; // loop finished, one statements\r
+ }\r
+ int o2 = (int)l2;\r
+ procedure.execute(graph, new ResourceImpl(graph.getResourceSupport(), modifier.execute(o2)));\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ }\r
+\r
+ public static <C> void foreachObject(long[] table, int index,\r
+ final ReadGraphImpl graph, final C context, final AsyncContextMultiProcedure<C, Resource> procedure,\r
+ final ClusterSupport support, final int pRef, final ClusterI.CompleteTypeEnum pCompleteType, CompleteTable ct, final Modifier modifier)\r
+ throws DatabaseException {\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachObject1: index=" + index);\r
+ if (ClusterI.CompleteTypeEnum.NotComplete != pCompleteType) {\r
+ int completeRef = getCompleteObjectRef(table, index);\r
+ if (0 == completeRef) {\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ return; // no objects for given complete type\r
+ }\r
+ if (ClusterTraits.completeReferenceIsMultiple(completeRef)) {\r
+ // Multiple complete type statements.\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.was complete 2");\r
+ class ForeachObject implements ClusterI.ObjectProcedure<Object> {\r
+ @Override\r
+ public boolean execute(Object _context, int completeRef) throws DatabaseException {\r
+ ClusterI.CompleteTypeEnum oCompleteType = ClusterTraits.completeReferenceGetType(completeRef);\r
+ if (pCompleteType == oCompleteType) {\r
+ int clusterIndex = ClusterTraits.completeReferenceGetForeignIndex(completeRef);\r
+ int resourceIndex = ClusterTraits.completeReferenceGetResourceIndex(completeRef);\r
+ if (0 == clusterIndex) {\r
+ procedure.execute(graph, context, new ResourceImpl(graph.getResourceSupport(), modifier.execute(resourceIndex)));\r
+ } else {\r
+ int externalRef = ClusterTraits.createForeignReference(clusterIndex, resourceIndex);\r
+ procedure.execute(graph, context, new ResourceImpl(graph.getResourceSupport(), modifier.execute(externalRef)));\r
+ }\r
+ }\r
+ return false; // continue looping\r
+ }\r
+ \r
+ }\r
+ ForeachObject t = new ForeachObject();\r
+ // CompleteRef is complete object set index.\r
+ ct.foreachComplete(completeRef, t, null, support, modifier);\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ return; // loop finished\r
+ }\r
+ // one complete type element\r
+ ClusterI.CompleteTypeEnum completeType = ClusterTraits.completeReferenceGetType(completeRef);\r
+ if (pCompleteType != completeType) {\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ return;\r
+ }\r
+ int clusterIndex = ClusterTraits.completeReferenceGetForeignIndex(completeRef);\r
+ int resourceIndex = ClusterTraits.completeReferenceGetResourceIndex(completeRef);\r
+ if (0 == clusterIndex) {\r
+ procedure.execute(graph, context, new ResourceImpl(graph.getResourceSupport(), modifier.execute(resourceIndex)));\r
+ } else {\r
+ int externalRef = ClusterTraits.createForeignReference(clusterIndex, resourceIndex);\r
+ procedure.execute(graph, context, new ResourceImpl(graph.getResourceSupport(), modifier.execute(externalRef)));\r
+ }\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ return; // loop finished\r
+ }\r
+ int i = STM_OFFSET + index;\r
+ long l = table[i];\r
+ int p1 = (int) (l >>> 32);\r
+ if (0 == p1) {\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ return; // loop finished, no statements\r
+ }\r
+ if (pRef == p1) {\r
+ int o1 = (int)l;\r
+ procedure.execute(graph, context, new ResourceImpl(graph.getResourceSupport(), modifier.execute(o1)));\r
+// int externalRef;\r
+// if (null == modifier)\r
+// externalRef = o1;\r
+// else\r
+// externalRef = modifier.execute(callerThread, o1);\r
+// if (procedure.execute(callerThread, context, externalRef))\r
+// return true; // loop broken by procedure\r
+ }\r
+ long l2 = table[++i];\r
+ int p2 = (int) (l2 >>> 32);\r
+ if (pRef != p2) {\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ return; // loop finished, one statements\r
+ }\r
+ int o2 = (int)l2;\r
+ procedure.execute(graph, context, new ResourceImpl(graph.getResourceSupport(), modifier.execute(o2)));\r
+ procedure.finished(graph);\r
+// graph.state.dec(0);\r
+ }\r
+ \r
+ public static <Context> boolean foreachObject(long[] table, int index\r
+ , ClusterI.ObjectProcedure<Context> procedure\r
+ , Context context, ClusterSupport support, Modifier modifier\r
+ , final int pRef, ClusterI.CompleteTypeEnum pCompleteType, CompleteTable ct)\r
+ throws DatabaseException {\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachObject2: 1 ");\r
+ if (ClusterI.CompleteTypeEnum.NotComplete != pCompleteType) {\r
+ int completeRef = getCompleteObjectRef(table, index);\r
+ if (0 == completeRef) {\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachObject2: no complete");\r
+ return false; // no objects for given complete type\r
+ }\r
+ if (ClusterTraits.completeReferenceIsMultiple(completeRef)) { // multiple complete type elements\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachObject2: multi-complete ci=" + completeRef);\r
+ return ct.foreachObject(completeRef, procedure, context, support, modifier, pCompleteType);\r
+ }\r
+ // one complete type element\r
+ ClusterI.CompleteTypeEnum completeType = ClusterTraits.completeReferenceGetType(completeRef);\r
+ if (pCompleteType != completeType) {\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachObject2: complete different predicate");\r
+ return false;\r
+ }\r
+ int clusterIndex = ClusterTraits.completeReferenceGetForeignIndex(completeRef);\r
+ int resourceIndex = ClusterTraits.completeReferenceGetResourceIndex(completeRef);\r
+ if (0 == clusterIndex) {\r
+ int externalRef;\r
+ if (null == modifier)\r
+ externalRef = resourceIndex;\r
+ else\r
+ externalRef = modifier.execute(resourceIndex);\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachObject2: complete ok=" + externalRef);\r
+ if (procedure.execute(context, externalRef))\r
+ return true; // loop broken by procedure\r
+ } else {\r
+ int externalRef = ClusterTraits.createForeignReference(clusterIndex, resourceIndex);\r
+ if (null != modifier)\r
+ externalRef = modifier.execute(externalRef);\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachObject2: complete ok=" + externalRef);\r
+ if (procedure.execute(context, externalRef))\r
+ return true; // loop broken by procedure\r
+ }\r
+ return false; // loop finished\r
+ }\r
+ int i = STM_OFFSET + index;\r
+ int p1 = BitUtility.getHighInt(table[i]);\r
+ if (0 == p1) {\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachObject2: empty cache=");\r
+ return false; // loop finished, no statements\r
+ }\r
+ if (pRef == p1) {\r
+ int o1 = BitUtility.getLowInt(table[i]);\r
+ int externalRef;\r
+ if (null == modifier)\r
+ externalRef = o1;\r
+ else\r
+ externalRef = modifier.execute(o1);\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachObject2: cache1 ok=" + externalRef);\r
+ if (procedure.execute(context, externalRef))\r
+ return true; // loop broken by procedure\r
+ }\r
+ int p2 = BitUtility.getHighInt(table[++i]);\r
+ if (0 == p2 || pRef != p2) {\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachObject2: not in cache1");\r
+ return false; // loop finished, one statements\r
+ }\r
+ int o2 = BitUtility.getLowInt(table[i]);\r
+ int externalRef;\r
+ if (null == modifier)\r
+ externalRef = o2;\r
+ else\r
+ externalRef = modifier.execute(o2);\r
+ if (DEBUG)\r
+ System.out.println("ResourceElement.foreachObject2: cache2 ok=" + externalRef);\r
+ return procedure.execute(context, externalRef);\r
+ }\r
+ static boolean isEmpty(long[] table, int index) {\r
+ return getStatementCount(table, index) == 0 && !hasValue(table, index);\r
+ }\r
+ static int getStatementCount(long[] table, int index) {\r
+ int i = STM_OFFSET + index;\r
+ int p1 = BitUtility.getHighInt(table[i]);\r
+ int p2 = BitUtility.getLowInt(table[++i]);\r
+ if (0 == p1)\r
+ return 0;\r
+ else if (0 == p2)\r
+ return 1;\r
+ int predicateIndex = getPredicateIndex(table, index);\r
+ if (0 == predicateIndex)\r
+ return 2;\r
+ return 3;\r
+ }\r
+ private static int makeCompleteObjectRef(int oRef, ClusterI.CompleteTypeEnum completeType) {\r
+ int ref;\r
+ if (oRef > 0) {\r
+ int resourceIndex = oRef; \r
+ int clusterIndex = 0;\r
+ ref = ClusterTraits.completeReferenceMake(completeType.getValue(), resourceIndex, clusterIndex);\r
+ } else {\r
+ assert(oRef < 0);\r
+ assert(!ClusterTraits.isFlat(oRef));\r
+ ref = (completeType.getValue() <<30) | (oRef & 0x3FFFFFFF);\r
+ }\r
+ return ref;\r
+ }\r
+ static int addStatement(long[] table, int index, int pRef, int oRef\r
+ , PredicateTable pt, ObjectTable ot\r
+ , ClusterI.CompleteTypeEnum completeType, CompleteTable ct)\r
+ throws DatabaseException {\r
+ assert (0 != pRef);\r
+ assert (0 != oRef);\r
+ if (ClusterI.CompleteTypeEnum.NotComplete != completeType) {\r
+ int cRef = makeCompleteObjectRef(oRef, completeType);\r
+ int ctr = getCompleteObjectRef(table, index);\r
+ if (0 == ctr)\r
+ setCompleteObjectRef(table, index, cRef);\r
+ else {\r
+ int nRef;\r
+ if (ctr == cRef)\r
+ return -1; // old complete\r
+ else if (ClusterTraits.completeReferenceIsMultiple(ctr)) {\r
+ nRef = ct.addComplete(ctr, cRef);\r
+ if (0 == nRef)\r
+ return -1; // old complete\r
+ } else {\r
+ nRef = ct.createCompleteArraySet(ctr, cRef);\r
+ }\r
+ setCompleteObjectRef(table, index, nRef);\r
+ }\r
+ return 0; // added to complete\r
+ }\r
+ int i = STM_OFFSET + index;\r
+ int p1 = BitUtility.getHighInt(table[i]);\r
+ int o1 = BitUtility.getLowInt(table[i]);\r
+ if (0 == p1) {\r
+ table[i] = BitUtility.setLowAndHighInt(table[i], oRef, pRef);\r
+ return 0; // added to stm cache\r
+ } else if (p1 == pRef && o1 == oRef)\r
+ return -1; // same statement\r
+ int p2 = BitUtility.getHighInt(table[++i]);\r
+ int o2 = BitUtility.getLowInt(table[i]);\r
+ if (0 == p2) {\r
+ table[i] = BitUtility.setLowAndHighInt(table[i], oRef, pRef);\r
+ return 0; // added to stm cache\r
+ } else if (p2 == pRef && o2 == oRef)\r
+ return -1; // same statement\r
+ int predicateIndex = getPredicateIndex(table, index);\r
+ if (0 == predicateIndex) {\r
+ if (p1 == p2) {\r
+ int objectIndex = ot.createObjectSet(o1, o2);\r
+ assert (0 != objectIndex);\r
+ int[] os = new int[1];\r
+ os[0] = ClusterTraits.statementIndexMake(objectIndex);\r
+ int[] ps = new int[1];\r
+ ps[0] = p1;\r
+ predicateIndex = pt.createPredicateSet(ps, os);\r
+ } else {\r
+ int[] os = new int[2];\r
+ os[0] = o1; \r
+ os[1] = o2;\r
+ int[] ps = new int[2];\r
+ ps[0] = p1;\r
+ ps[1] = p2;\r
+ predicateIndex = pt.createPredicateSet(ps, os);\r
+ }\r
+ assert (0 != predicateIndex);\r
+ setPredicateIndex(table, index, predicateIndex);\r
+ }\r
+ assert (0 != predicateIndex);\r
+ return predicateIndex;\r
+ }\r
+\r
+ static boolean removeStatement(long[] table, int index, int pRef, int oRef,\r
+ ClusterI.CompleteTypeEnum completeType, CompleteTable ct)\r
+ throws DatabaseException {\r
+ assert (0 != pRef);\r
+ assert (0 != oRef);\r
+ if (completeType != ClusterI.CompleteTypeEnum.NotComplete) {\r
+ int completeRef = ResourceElement.getCompleteObjectRef(table, index);\r
+ if (0 != completeRef) {\r
+ ClusterI.CompleteTypeEnum completeType2 = ClusterTraits.completeReferenceGetType(completeRef);\r
+ if (completeType == completeType2) {\r
+ int clusterIndex = ClusterTraits.completeReferenceGetForeignIndex(completeRef);\r
+ int resourceIndex = ClusterTraits.completeReferenceGetResourceIndex(completeRef);\r
+ if (0 == clusterIndex) {\r
+ if (oRef == resourceIndex) {\r
+ ResourceElement.setCompleteObjectRef(table, index, 0);\r
+ return true; // statement removed\r
+ }\r
+ } else {\r
+ int externalRef = ClusterTraits.createForeignReference(clusterIndex, resourceIndex);\r
+ if (oRef == externalRef) {\r
+ ResourceElement.setCompleteObjectRef(table, index, 0);\r
+ return true; // statement removed\r
+ }\r
+ }\r
+ } else if (completeType2 == ClusterI.CompleteTypeEnum.NotComplete) { // multiple complete type references \r
+ int cRef = makeCompleteObjectRef(oRef, completeType);\r
+ int oldSize = ct.getCompleteSetSize(completeRef);\r
+ int newSize = ct.removeComplete(completeRef, cRef);\r
+ if (oldSize == newSize)\r
+ return false; // not removed\r
+ else if (newSize == 1) {\r
+ cRef = ct.removeLast(completeRef);\r
+ ResourceElement.setCompleteObjectRef(table, index, cRef);\r
+ }\r
+ return true; \r
+ }\r
+ }\r
+ }\r
+ int i = STM_OFFSET + index;\r
+ int p1 = BitUtility.getHighInt(table[i]);\r
+ int o1 = BitUtility.getLowInt(table[i]);\r
+ if (0 == p1)\r
+ return false; // no statements cached\r
+ else if (p1 == pRef && o1 == oRef) {\r
+ table[i] = table[i + 1];\r
+ // BitUtility.setLowAndHighInt(table[i], 0, 0); optimized away\r
+ table[i + 1] = 0;\r
+ return true; // statement removed\r
+ }\r
+ int p2 = BitUtility.getHighInt(table[++i]);\r
+ int o2 = BitUtility.getLowInt(table[i]);\r
+ if (0 == p2)\r
+ return false; // no match\r
+ else if (p2 == pRef && o2 == oRef) {\r
+ // BitUtility.setLowAndHighInt(table[i], 0, 0); optimized away\r
+ table[i] = 0;\r
+ return true; // statement removed\r
+ }\r
+ return false;\r
+ }\r
+}\r
+\r
+public final class ResourceTable extends Table<long[]> {\r
+ public ResourceTable(TableSizeListener sizeListener, int[] header, int headerBase) {\r
+ super(TableFactory.getLongFactory(), sizeListener, header, headerBase);\r
+ }\r
+\r
+ public ResourceTable(TableSizeListener sizeListener, int[] header, int headerBase, long[] longs) {\r
+ super(TableFactory.getLongFactory(), sizeListener, header, headerBase, longs);\r
+ }\r
+\r
+ public int getUsedSize() {\r
+ return getTableCount();\r
+ }\r
+\r
+ public short createResource() {\r
+ final int INDEX = getTableCount();\r
+ final int SIZE = ResourceElement.getSizeOf();\r
+ int resourceIndex = createNewElement(SIZE);\r
+ assert (0 != resourceIndex);\r
+ final int REAL_INDEX = checkIndexAndGetRealIndex(resourceIndex, SIZE);\r
+ ResourceElement.construct(getTable(), REAL_INDEX);\r
+ incResourceCount();\r
+ return (short)(INDEX + ZERO_SHIFT);\r
+ }\r
+\r
+ void createResource(int resourceIndex) {\r
+ final int tableCount = getTableCount();\r
+ if (resourceIndex <= tableCount) { // old index\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ if (ResourceElement.isEmpty(getTable(), realIndex))\r
+ return;\r
+ } if (resourceIndex == tableCount+1) {\r
+ createResource();\r
+ return;\r
+ }\r
+ throw new InternalError("Trying to create resource with illegal index=" + resourceIndex);\r
+ }\r
+\r
+// void deleteResource(int resourceIndex) {\r
+// int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+// ResourceElement.destruct(getTable(), realIndex);\r
+// decResourceCount();\r
+// }\r
+\r
+ public int getCompleteObjectRef(int resourceIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElement.getCompleteObjectRef(getTable(), realIndex);\r
+ }\r
+ \r
+ public int getPredicateIndex(int resourceIndex) {\r
+ int i = (resourceIndex<<2) - 3 + offset;\r
+ return (int)table[i];\r
+ }\r
+\r
+ public void setPredicateIndex(int resourceIndex, int predicateIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ ResourceElement.setPredicateIndex(getTable(), realIndex, predicateIndex);\r
+ }\r
+\r
+ public byte[] getValue(ValueTable valueTable, int resourceIndex)\r
+ throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElement.getValue(valueTable, getTable(), realIndex);\r
+ }\r
+\r
+//KRAA:\r
+// int getString(ValueTable valueTable, int resourceIndex, char[] chars)\r
+// throws DatabaseException {\r
+// //int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+// return ResourceElement.getString(valueTable, getTable(), 4 * resourceIndex - 3 + offset, chars);\r
+// }\r
+\r
+ public boolean hasValue(int resourceIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElement.hasValue(getTable(), realIndex);\r
+ }\r
+\r
+// boolean hasValue(ValueTable valueTable, int resourceIndex, byte[] value) {\r
+// int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+// return ResourceElement.hasValue(valueTable, getTable(), realIndex, value);\r
+// }\r
+\r
+ public boolean removeValue(ValueTable valueTable, int resourceIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ boolean ret = ResourceElement.removeValue(valueTable, getTable(), realIndex);\r
+// if (ret && !ResourceElement.isUsed(getTable(), realIndex))\r
+// decResourceCount();\r
+ return ret;\r
+ }\r
+\r
+ public void setValue(ValueTable valueTable, int resourceIndex, byte[] value, int length) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ ResourceElement.setValue(valueTable, getTable(), realIndex, value, length);\r
+ }\r
+\r
+ public boolean isValueEx(ValueTable valueTable, int resourceIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElement.isValueEx(valueTable, getTable(), realIndex);\r
+ }\r
+\r
+ public void setValueEx(ValueTable valueTable, int resourceIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ ResourceElement.setValueEx(valueTable, getTable(), realIndex);\r
+ }\r
+\r
+ static final int RESOURCE_COUNT_INDEX = 0;\r
+ static final int FOREIGN_COUNT_INDEX = 1; // Reserved by server.\r
+ static final int CLUSTER_STATUS_INDEX = 2;\r
+\r
+ int incResourceCount() {\r
+ int count = getExtra(RESOURCE_COUNT_INDEX) + 1;\r
+ setExtra(RESOURCE_COUNT_INDEX, count);\r
+ return count;\r
+ }\r
+\r
+// int decResourceCount() {\r
+// int count = getExtra(RESOURCE_COUNT_INDEX) - 1;\r
+// setExtra(RESOURCE_COUNT_INDEX, count);\r
+// return count;\r
+// }\r
+\r
+ public int getResourceCount() {\r
+ return getExtra(RESOURCE_COUNT_INDEX);\r
+ }\r
+ public int getClusterStatus() {\r
+ return getExtra(CLUSTER_STATUS_INDEX);\r
+ }\r
+ public void setClusterStatus(int value) {\r
+ setExtra(CLUSTER_STATUS_INDEX, value);\r
+ }\r
+ void analyse() {\r
+\r
+ final int tsize = getTableSize();\r
+ final int esize = ResourceElement.getSizeOf();\r
+ long[] table = getTable();\r
+ for (int i = getTableBase(); i < getTableBase() + tsize; i += esize) {\r
+ if (ResourceElement.isUsed(getTable(), i)) {\r
+ System.out.println(" -" + Long.toHexString(table[i]) + " " + Long.toHexString(table[i+1]) + " " + Long.toHexString(table[i+2]) + " " + Long.toHexString(table[i+3]));\r
+ }\r
+ }\r
+\r
+ }\r
+ \r
+ public <Context> boolean foreachResource(ClusterI.ObjectProcedure<Context> procedure, Context context,\r
+ ClusterSupport support, Modifier modifier) throws DatabaseException {\r
+ final int tsize = getTableSize();\r
+// final int rsize = getResourceCount();\r
+ final int esize = ResourceElement.getSizeOf();\r
+ //int count = 0;\r
+ int key = ZERO_SHIFT;\r
+ for (int i = getTableBase(); i < getTableBase() + tsize; i += esize, ++key) {\r
+ if (ResourceElement.isUsed(getTable(), i)) {\r
+ int ref;\r
+ if (null == modifier)\r
+ ref = key;\r
+ else\r
+ ref = modifier.execute(key);\r
+ if (procedure.execute(context, ref))\r
+ return true; // loop was broken by procedure\r
+// if (rsize == ++count)\r
+// return false; // loop finished\r
+ }\r
+ }\r
+ //assert(rsize == count);\r
+ return false; // loop finished\r
+ }\r
+\r
+ public <Context> boolean foreachPredicate(int resourceIndex\r
+ , ClusterI.PredicateProcedure<Context> procedure, Context context\r
+ , ClusterSupport support, Modifier modifier, CompleteTable ct)\r
+ throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElement.foreachPredicate(getTable(), realIndex\r
+ , procedure, context, support, modifier, ct);\r
+ }\r
+\r
+ public int getSingleObject(int resourceIndex, ClusterSupport support, int pRef, ClusterI.CompleteTypeEnum pCompleteType, CompleteTable ct, Modifier modifier) throws DatabaseException {\r
+// return ResourceElement.getSingleObject(table, realIndex, support, pRef, pCompleteType, ct, modifier);\r
+ return ResourceElement.getSingleObject(table, 4 * resourceIndex - 3 + offset, support, pRef, pCompleteType, ct, modifier);\r
+ }\r
+\r
+ public void foreachObject(int resourceIndex, ReadGraphImpl graph,\r
+ AsyncMultiProcedure<Resource> procedure, ClusterSupport support, int pRef, ClusterI.CompleteTypeEnum pCompleteType, CompleteTable ct, Modifier modifier) throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ ResourceElement.foreachObject(table, realIndex, graph, procedure, support,\r
+ pRef, pCompleteType, ct, modifier);\r
+ }\r
+\r
+ public <C> void foreachObject(int resourceIndex, ReadGraphImpl graph, C context,\r
+ AsyncContextMultiProcedure<C, Resource> procedure, ClusterSupport support, int pRef, ClusterI.CompleteTypeEnum pCompleteType, CompleteTable ct, Modifier modifier) throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ ResourceElement.foreachObject(table, realIndex, graph, context, procedure, support,\r
+ pRef, pCompleteType, ct, modifier);\r
+ }\r
+ \r
+ public <Context> boolean foreachObject(int resourceIndex\r
+ , ClusterI.ObjectProcedure<Context> procedure, Context context\r
+ , ClusterSupport support, Modifier modifier,\r
+ int pRef, ClusterI.CompleteTypeEnum completeType, CompleteTable ct)\r
+ throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElement.foreachObject(table, realIndex\r
+ , procedure, context, support, modifier\r
+ , pRef, completeType, ct);\r
+ }\r
+ public int addStatement(int resourceIndex, int pRef, int oRef, PredicateTable pt, ObjectTable ot\r
+ , ClusterI.CompleteTypeEnum pCompleteType, CompleteTable ct)\r
+ throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElement.addStatement(getTable(), realIndex, pRef, oRef, pt, ot, pCompleteType, ct);\r
+ }\r
+\r
+ public boolean removeStatementFromCache(int resourceIndex, int pRef, int oRef,\r
+ ClusterI.CompleteTypeEnum pCompleteType, CompleteTable ct)\r
+ throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ boolean ret = ResourceElement.removeStatement(getTable(), realIndex, pRef, oRef, pCompleteType, ct);\r
+// if (ret && !ResourceElement.isUsed(getTable(), realIndex))\r
+// decResourceCount();\r
+ return ret;\r
+ }\r
+ \r
+ public void removeStatement(int resourceIndex, int pRef, int oRef, ClusterI.CompleteTypeEnum pCompleteType, CompleteTable ct,\r
+ PredicateTable pt, ObjectTable ot, ClusterBase cluster, ClusterSupport support)\r
+ throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ boolean removed = ResourceElement.removeStatement(getTable(), realIndex,\r
+ pRef, oRef, pCompleteType, ct);\r
+ if (!removed)\r
+ return;\r
+ int predicateIndex = ResourceElement.getPredicateIndex(getTable(), realIndex);\r
+ if (0 == predicateIndex) {\r
+// if (!ResourceElement.isUsed(getTable(), realIndex))\r
+// decResourceCount();\r
+ return;\r
+ }\r
+ GetStatements gs = new GetStatements(ot);\r
+ pt.foreachPredicate(predicateIndex, gs, null, null, null);\r
+ ArrayList<Statement> stms = gs.getStatements();\r
+\r
+ final int SIZE = stms.size();\r
+ if (SIZE < 3) {\r
+ for (int i = 0; i < SIZE; ++i) {\r
+ Statement stm = stms.get(i);\r
+ PredicateTable.Status ret = pt.removePredicate(predicateIndex,\r
+ stm.pRef, stm.oIndex, ot);\r
+ if (ret == Status.NothingRemoved)\r
+ throw new DatabaseException("Internal error during statement cache fix (2).");\r
+ int predicateKey = cluster.makeResourceKey(stm.pRef);\r
+ int completeTypeInt = ClusterTraitsBase.getCompleteTypeIntFromResourceKey(predicateKey);\r
+ ClusterI.CompleteTypeEnum completeType = CompleteTypeEnum.make(completeTypeInt);\r
+ int pi = ResourceElement.addStatement(getTable(), realIndex, stm.pRef, stm.oIndex,\r
+ pt, ot, completeType, ct);\r
+ assert(0 >= pi);\r
+ }\r
+ assert(0 == pt.getPredicateSetSize(predicateIndex));\r
+ ResourceElement.setPredicateIndex(getTable(), realIndex, 0);\r
+ } else {\r
+ for (int i = 0; i < SIZE; ++i) {\r
+ Statement stm = stms.get(i);\r
+ int predicateKey = cluster.makeResourceKey(stm.pRef);\r
+ int completeTypeInt = ClusterTraitsBase.getCompleteTypeIntFromResourceKey(predicateKey);\r
+ ClusterI.CompleteTypeEnum completeType = CompleteTypeEnum.make(completeTypeInt);\r
+ int pIndex = ResourceElement.addStatement(getTable(), realIndex,\r
+ stm.pRef, stm.oIndex, pt, ot, completeType, ct);\r
+ if (pIndex > 0)\r
+ return; // cache fixed and full, p and o sets in use\r
+ }\r
+ throw new DatabaseException("Internal error during statement cache fix (3).");\r
+ }\r
+// if (!ResourceElement.isUsed(getTable(), realIndex))\r
+// decResourceCount();\r
+ }\r
+\r
+ //(i-1)*4+1 + 4\r
+ private int checkIndexAndGetRealIndex(final int INDEX) {\r
+ assert(INDEX > 0);\r
+ assert(INDEX <= getTableCount());\r
+// final int TABLE_INDEX = (INDEX - ZERO_SHIFT) * ResourceElement.getSizeOf() + ZERO_SHIFT;\r
+// final int TABLE_INDEX = (INDEX - ZERO_SHIFT) * ResourceElement.getSizeOf() + ZERO_SHIFT;\r
+// return checkIndexAndGetRealIndex(TABLE_INDEX, ResourceElement.getSizeOf());\r
+ return 4 * INDEX - 3 + offset;\r
+ }\r
+ public void check(ClusterBase cluster)\r
+ throws DatabaseException {\r
+// int count = 0;\r
+ cluster.checkValueInit();\r
+ long[] table = getTable();\r
+ int ps = getHeader().getOffset() + ZERO_SHIFT;\r
+ final int TABLE_SIZE = getTableSize();\r
+ int pe = ps + TABLE_SIZE;\r
+ for (int p=ps; p<pe; p+=ResourceElement.getSizeOf()) {\r
+ if (!ResourceElement.isUsed(table, p))\r
+ continue;\r
+ int cr = ResourceElement.getCompleteObjectRef(table, p);\r
+ if (0 != cr) {\r
+ if (ClusterTraits.completeReferenceIsMultiple(cr))\r
+ cluster.checkCompleteSetReference(cr);\r
+ else {\r
+ int fi = ClusterTraits.completeReferenceGetForeignIndex(cr);\r
+ int ri = ClusterTraits.completeReferenceGetResourceIndex(cr);\r
+ if (0 != fi)\r
+ cluster.checkForeingIndex(fi);\r
+ else if (ri < 1 || ri > TABLE_SIZE)\r
+ throw new ValidationException("Illegal resource index=" + ri);\r
+ }\r
+ }\r
+ int pi = ResourceElement.getPredicateIndex(table, p);\r
+ if (0 != pi) {\r
+ cluster.checkPredicateIndex(pi);\r
+ }\r
+ ResourceElement.ValueData vd = new ResourceElement.ValueData();\r
+ ResourceElement.getValueCapacityAndIndex(vd, table, p);\r
+ cluster.checkValue(vd.capacity, vd.index);\r
+ }\r
+ cluster.checkValueFini();\r
+ }\r
+\r
+ @Override\r
+ public <Context> boolean foreach(int setIndex, Procedure procedure, Context context,\r
+ ClusterSupport support, Modifier modifier) throws DatabaseException {\r
+ throw new UnsupportedOperationException();\r
+ }\r
+}\r
+\r
+class Statement {\r
+ Statement(int pRef, int oIndex) {\r
+ this.pRef = pRef;\r
+ this.oIndex = oIndex;\r
+ }\r
+ final int pRef;\r
+ final int oIndex;\r
+}\r
+\r
+class CalculateStatements\r
+implements ClusterI.PredicateProcedure<CalculateStatements> {\r
+ private ObjectTable ot;\r
+ private final int sRef;\r
+\r
+ CalculateStatements(int sRef, ObjectTable ot) {\r
+ this.sRef = sRef;\r
+ this.ot = ot;\r
+ }\r
+\r
+ @Override\r
+ public boolean execute(final CalculateStatements context\r
+ , final int pKey, int oIndex) {\r
+ if (ClusterTraits.statementIndexIsDirect(oIndex))\r
+ return false; // osize = 1\r
+ try {\r
+ oIndex = ClusterTraits.statementIndexGet(oIndex);\r
+ } catch (DatabaseException e) {\r
+ Logger.getDefault().logError("Missing object set for s="\r
+ + sRef + " p=" + pKey, null);\r
+ return false; // continue looping\r
+ }\r
+ int osize = ot.getObjectSetSize(oIndex);\r
+ if (osize == 3 || osize > 9)\r
+ System.out.println("Resource " + sRef + " predicate " + pKey + " has "\r
+ + osize + " objects.");\r
+ return true; // break loop\r
+ }\r
+}\r
+\r
+class GetStatements implements PredicateProcedure<Object>, ObjectProcedure<Integer> {\r
+ private ObjectTable ot;\r
+ private final ArrayList<Statement> stms = new ArrayList<Statement>(); \r
+ GetStatements(ObjectTable ot) {\r
+ this.ot = ot;\r
+ }\r
+ ArrayList<Statement> getStatements() {\r
+ return stms;\r
+ }\r
+ @Override\r
+ public boolean execute(Object context, int pRef, int oIndex) {\r
+ try {\r
+ ot.foreachObject(oIndex, this, pRef, null, null);\r
+ } catch (DatabaseException e) {\r
+ e.printStackTrace();\r
+ return false; // continue looping\r
+ }\r
+ if (stms.size() > 2)\r
+ return true; // break loop\r
+ return false; // continue looping\r
+ }\r
+\r
+ @Override\r
+ public boolean execute(Integer pRef, int oRef) {\r
+ stms.add(new Statement(pRef, oRef));\r
+ if (stms.size() > 2)\r
+ return true; // break loop\r
+ return false; // continue looping\r
+ }\r
+ \r
+}\r
Code Review / simantics / platform.git / blobdiff