bundles/org.simantics.db.procore/src/org/simantics/db/procore/cluster/TableIntArraySet2.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
   3  * in Industry THTH ry.\r
   4  * All rights reserved. This program and the accompanying materials\r
   5  * are made available under the terms of the Eclipse Public License v1.0\r
   6  * which accompanies this distribution, and is available at\r
   7  * http://www.eclipse.org/legal/epl-v10.html\r
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.db.procore.cluster;\r
  13 \r
  14 import org.simantics.db.exception.DatabaseException;\r
  15 import org.simantics.db.impl.ClusterI;\r
  16 import org.simantics.db.impl.IntAllocatorI;\r
  17 import org.simantics.db.impl.Modifier;\r
  18 \r
  19 final class TableIntArraySet2 {\r
  20     public static final int HeaderSize = 1; \r
  21     private static final int SIZE_OFFSET = -1;\r
  22     static int create(final int[] keys, final int[] vals, IntAllocatorI allocator)\r
  23     throws DatabaseException {\r
  24         final int LENGTH = keys.length;\r
  25         if (LENGTH < 1 || LENGTH != vals.length)\r
  26             throw new DatabaseException("Illegal argument to create TableIntArraySet2.");\r
  27         int newBase = allocator.allocate(LENGTH*2 + HeaderSize) + HeaderSize;\r
  28         int[] table = allocator.getTable();\r
  29         table[newBase + SIZE_OFFSET] = -LENGTH;\r
  30         for (int i=0; i<LENGTH; ++i) {\r
  31             if (0 == keys[i])\r
  32                 throw new DatabaseException("Illegal value to create TableIntArraySet2.");\r
  33             table[newBase + i*2] = keys[i];\r
  34             table[newBase + i*2 + 1] = vals[i];\r
  35         }\r
  36         return newBase;\r
  37     }\r
  38     static boolean isArraySet(int[] table, int base) {\r
  39         return table[base + SIZE_OFFSET] < 0;\r
  40     }\r
  41     static class Tables {\r
  42         int[] keys;\r
  43         int[] vals;\r
  44         public Tables() {\r
  45             this.keys = null;\r
  46             this.vals = null;\r
  47         }\r
  48     }\r
  49     static Tables getInts(int[] table, int base) {\r
  50         final int REAL_SIZE = -table[base + SIZE_OFFSET];\r
  51         assert(REAL_SIZE > 0);\r
  52         Tables t = new Tables();\r
  53         int i;\r
  54         for (i=0; i<REAL_SIZE; ++i) {\r
  55             int k = table[base + i*2];\r
  56             if (0 == k)\r
  57                 break;\r
  58         }\r
  59         final int size = i;\r
  60         assert(size > 0);\r
  61         t.keys = new int[size];\r
  62         t.vals = new int[size];\r
  63         for (i=0; i<size; ++i){\r
  64             t.keys[i] = table[base + i*2];\r
  65             t.vals[i] = table[base + i*2 + 1];\r
  66         }\r
  67         return t;\r
  68     }\r
  69     static int get(int[] table, int base, int aKey) {\r
  70         final int REAL_SIZE = -table[base + SIZE_OFFSET];\r
  71         assert(REAL_SIZE > 0);\r
  72         for (int i=0; i<REAL_SIZE; ++i, base += 2) {\r
  73             if (0 == table[base])\r
  74                 return 0;\r
  75             else if (aKey == table[base]) {\r
  76                 return table[base + 1];\r
  77             }\r
  78         }\r
  79         return 0;\r
  80     }\r
  81     /**\r
  82      * @param table\r
  83      * @param base\r
  84      * @param key\r
  85      * @param allocator\r
  86      * @return new base if object was actually added.\r
  87      */\r
  88     static int addInt(int[] table, int base, final int key, int val, IntAllocatorI allocator) {\r
  89         final int size = -table[base + SIZE_OFFSET];\r
  90         assert(size > 0);\r
  91         int i;\r
  92         for (i=0; i<size; ++i) {\r
  93             if (key == table[base + i*2]) {\r
  94                 if (val == table[base + i*2 + 1])\r
  95                     return 0;\r
  96                 else {\r
  97                     table[base + i*2 + 1] = val;\r
  98                     return base;\r
  99                 }\r
 100             } else if (0 == table[base + i*2])\r
 101                 break;\r
 102         }\r
 103         if (i < size) {\r
 104             assert(0 == table[base + i*2]);\r
 105             table[base + i*2] = key;\r
 106             table[base + i*2 + 1] = val;\r
 107             return base;\r
 108         }\r
 109         final int newSize = size + 1;\r
 110         int newBase = allocator.allocate(newSize*2 + HeaderSize) + HeaderSize;\r
 111         int[] newTable = allocator.getTable();\r
 112         newTable[newBase + SIZE_OFFSET] = -newSize;\r
 113         System.arraycopy(table, base, newTable, newBase, size*2);\r
 114         newTable[newBase + size*2] = key;\r
 115         newTable[newBase + size*2 + 1] = val;\r
 116         return newBase;\r
 117     }       \r
 118     \r
 119     static boolean removeInt(int[] table, int base, int key) {\r
 120         final int size = -table[base + SIZE_OFFSET];\r
 121         assert(size > 0);\r
 122         int i;\r
 123         for (i=0; i<size; ++i)\r
 124             if (key == table[base + i*2])\r
 125                 break;\r
 126             else if (0 == table[base + i*2])\r
 127                 return false; // not found\r
 128         if (i == size)\r
 129             return false; // not found\r
 130         int end = size - 1;\r
 131         for (;end>i; --end)\r
 132                 if (0 != table[base + end*2])\r
 133                         break;\r
 134         table[base + i*2] = table[base + end*2];\r
 135         table[base + i*2 + 1] = table[base + end*2 + 1];\r
 136         table[base + end*2] = 0;\r
 137         table[base + end*2 + 1] = 0;\r
 138         return true;\r
 139     }\r
 140 \r
 141     static int getSize(int[] table, int base) {\r
 142         final int size = -table[base + SIZE_OFFSET];\r
 143         assert(size > 0);\r
 144         int i;\r
 145         for (i=0; i<size; ++i)\r
 146             if (0 == table[base + i*2])\r
 147                 break;\r
 148         return i;\r
 149     }\r
 150     \r
 151     static int getAllocatedSize(int[] table, int base) {\r
 152         final int size = -table[base + SIZE_OFFSET];\r
 153         assert(size>0);\r
 154         return size + HeaderSize;\r
 155     }\r
 156     \r
 157     static <Context> boolean foreachInt(final int[] table, final int base\r
 158                 , final ClusterI.PredicateProcedure<Context> procedure, final Context context, final Modifier modifier) throws DatabaseException {\r
 159         final int size = -table[base + SIZE_OFFSET];\r
 160         assert(size>0);\r
 161         for (int i=0; i<size; ++i) {\r
 162             int pRef = table[base + i*2];\r
 163             if (0 == pRef)\r
 164                 break;\r
 165             int key;\r
 166             if (null == modifier)\r
 167                 key = pRef;\r
 168             else\r
 169                 key = modifier.execute(pRef);\r
 170             if (procedure.execute(context, key, table[base + i*2 + 1]))\r
 171                 return true; // loop broken by procedure\r
 172         }\r
 173         return false; // loop finished\r
 174     }\r
 175 }\r
 176 \r