コード例 #1
0
 @Override
 public boolean compareAndSetBlock(
     int x, int y, int z, short expectId, short expectData, short newId, short newData) {
   int exp = BlockFullState.getPacked(expectId, expectData);
   int update = BlockFullState.getPacked(newId, newData);
   boolean success = store.compareAndSet(getIndex(x, y, z), exp, update);
   if (success && exp != update) {
     markDirty(x, y, z, exp, update);
   }
   return success;
 }
コード例 #2
0
  /**
   * Atomically gets the full set of data associated with the block.<br>
   * <br>
   *
   * @param x the x coordinate
   * @param y the y coordinate
   * @param z the z coordinate
   * @return the full state of the block
   */
  @Override
  public int getFullData(int x, int y, int z) {
    int index = getIndex(x, y, z);
    int spins = 0;
    boolean interrupted = false;
    try {
      while (true) {
        if (spins++ > SPINS) {
          interrupted |= atomicWait(index);
        }
        checkCompressing();

        int seq = getSequence(x, y, z);
        short blockId = blockIds.get(index);
        if (auxStore.isReserved(blockId)) {
          int state = auxStore.getInt(blockId);
          if (testSequence(x, y, z, seq)) {
            return state;
          }
        } else {
          int state = BlockFullState.getPacked(blockId, (short) 0);
          return state;
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }
コード例 #3
0
 @Override
 public short[] getDataArray(short[] array) {
   if (array.length != length) {
     array = new short[length];
   }
   for (int i = 0; i < length; i++) {
     array[i] = BlockFullState.getData(store.get(i));
   }
   return array;
 }
コード例 #4
0
 @Override
 public int getAndSetBlock(int x, int y, int z, short id, short data) {
   int oldState = BlockFullState.getPacked(id, data);
   int newState = 0;
   try {
     return newState = store.set(getIndex(x, y, z), oldState);
   } finally {
     markDirty(x, y, z, oldState, newState);
   }
 }
コード例 #5
0
 public AtomicPaletteBlockStore(
     int shift, boolean storeState, int dirtySize, short[] blocks, short[] data) {
   this(shift, storeState, dirtySize);
   if (blocks != null) {
     int[] initial = new int[Math.min(blocks.length, this.length)];
     for (int i = 0; i < blocks.length; i++) {
       short d = data != null ? data[i] : 0;
       initial[i] = BlockFullState.getPacked(blocks[i], d);
     }
     store.set(initial);
   }
 }
コード例 #6
0
  private int getAndSetBlockRaw(int x, int y, int z, short id, short data) {
    int index = getIndex(x, y, z);
    int spins = 0;
    boolean interrupted = false;
    try {
      while (true) {
        if (spins++ > SPINS) {
          interrupted |= atomicWait(index);
        }
        checkCompressing();

        short oldBlockId = blockIds.get(index);
        boolean oldReserved = auxStore.isReserved(oldBlockId);
        if (data == 0 && !auxStore.isReserved(id)) {
          if (!blockIds.compareAndSet(index, oldBlockId, id)) {
            continue;
          }
        } else {
          int newIndex = auxStore.add(id, data);
          if (!blockIds.compareAndSet(index, oldBlockId, (short) newIndex)) {
            auxStore.remove(newIndex);
            continue;
          }
        }

        if (oldReserved) {
          return auxStore.remove(oldBlockId);
        }

        return BlockFullState.getPacked(oldBlockId, (short) 0);
      }
    } finally {
      markDirty(x, y, z);
      atomicNotify(index);
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }
コード例 #7
0
 @Override
 public int getData(int x, int y, int z) {
   return BlockFullState.getData(getFullData(x, y, z));
 }