@Override
public void fromBinary(final byte[] bytes) {
final ByteBuffer buf = ByteBuffer.wrap(bytes);
final int numSfcs = buf.getInt();
final int numDimensions = buf.getInt();
final int mappingSize = buf.getInt();
maxEstimatedDuplicateIds = buf.getLong();
maxEstimatedDuplicateIdsBigInteger = BigInteger.valueOf(maxEstimatedDuplicateIds);
orderedSfcs = new SpaceFillingCurve[numSfcs];
baseDefinitions = new NumericDimensionDefinition[numDimensions];
for (int i = 0; i < numSfcs; i++) {
final byte[] sfc = new byte[buf.getInt()];
buf.get(sfc);
orderedSfcs[i] = PersistenceUtils.fromBinary(sfc, SpaceFillingCurve.class);
}
for (int i = 0; i < numDimensions; i++) {
final byte[] dim = new byte[buf.getInt()];
buf.get(dim);
baseDefinitions[i] = PersistenceUtils.fromBinary(dim, NumericDimensionDefinition.class);
}
final Builder<Integer, Byte> bimapBuilder = ImmutableBiMap.builder();
for (int i = 0; i < mappingSize; i++) {
bimapBuilder.put(Byte.valueOf(buf.get()).intValue(), buf.get());
}
orderedSfcIndexToTierId = bimapBuilder.build();
}
@Override
public byte[] toBinary() {
int byteBufferLength = 20 + (2 * orderedSfcIndexToTierId.size());
final List<byte[]> orderedSfcBinaries = new ArrayList<byte[]>(orderedSfcs.length);
final List<byte[]> dimensionBinaries = new ArrayList<byte[]>(baseDefinitions.length);
for (final SpaceFillingCurve sfc : orderedSfcs) {
final byte[] sfcBinary = PersistenceUtils.toBinary(sfc);
byteBufferLength += (4 + sfcBinary.length);
orderedSfcBinaries.add(sfcBinary);
}
for (final NumericDimensionDefinition dimension : baseDefinitions) {
final byte[] dimensionBinary = PersistenceUtils.toBinary(dimension);
byteBufferLength += (4 + dimensionBinary.length);
dimensionBinaries.add(dimensionBinary);
}
final ByteBuffer buf = ByteBuffer.allocate(byteBufferLength);
buf.putInt(orderedSfcs.length);
buf.putInt(baseDefinitions.length);
buf.putInt(orderedSfcIndexToTierId.size());
buf.putLong(maxEstimatedDuplicateIds);
for (final byte[] sfcBinary : orderedSfcBinaries) {
buf.putInt(sfcBinary.length);
buf.put(sfcBinary);
}
for (final byte[] dimensionBinary : dimensionBinaries) {
buf.putInt(dimensionBinary.length);
buf.put(dimensionBinary);
}
for (final Entry<Integer, Byte> entry : orderedSfcIndexToTierId.entrySet()) {
buf.put(entry.getKey().byteValue());
buf.put(entry.getValue());
}
return buf.array();
}
@SuppressWarnings("unchecked")
protected T entryToValue(final Entry<Key, Value> entry) {
final T result = (T) PersistenceUtils.fromBinary(entry.getValue().get(), Persistable.class);
if (result != null) {
addObjectToCache(getPrimaryId(result), getSecondaryId(result), result);
}
return result;
}
@Override
public byte[] toBinary() {
final byte[] indexStrategyBytes = PersistenceUtils.toBinary(indexStrategy);
final byte[] coordinateRangesBinary = new ArrayOfArrays(coordinateRanges).toBinary();
final ByteBuffer buf =
ByteBuffer.allocate(coordinateRangesBinary.length + indexStrategyBytes.length + 4);
buf.putInt(indexStrategyBytes.length);
buf.put(indexStrategyBytes);
buf.put(coordinateRangesBinary);
return buf.array();
}
@Override
protected void addObject(final ByteArrayId id, final ByteArrayId secondaryId, final T object) {
addObjectToCache(id, secondaryId, object);
try {
final Writer writer = accumuloOperations.createWriter(getTablename(), true);
synchronized (this) {
if (!iteratorsAttached) {
iteratorsAttached = true;
final IteratorConfig[] configs = getIteratorConfig();
if ((configs != null) && (configs.length > 0)) {
accumuloOperations.attachIterators(getTablename(), true, true, true, null, configs);
}
}
}
final Mutation mutation = new Mutation(new Text(id.getBytes()));
final Text cf = getSafeText(getColumnFamily());
final Text cq = getSafeText(getColumnQualifier(object));
final byte[] visibility = getVisibility(object);
if (visibility != null) {
mutation.put(
cf, cq, new ColumnVisibility(visibility), new Value(PersistenceUtils.toBinary(object)));
} else {
mutation.put(cf, cq, new Value(PersistenceUtils.toBinary(object)));
}
writer.write(mutation);
try {
writer.close();
} catch (final IOException e) {
LOGGER.warn("Unable to close metadata writer", e);
}
} catch (final TableNotFoundException e) {
LOGGER.error("Unable add object", e);
}
}
@Override
public void fromBinary(final byte[] bytes) {
final ByteBuffer buf = ByteBuffer.wrap(bytes);
try {
final int indexStrategyLength = buf.getInt();
final byte[] indexStrategyBytes = new byte[indexStrategyLength];
buf.get(indexStrategyBytes);
indexStrategy = PersistenceUtils.fromBinary(indexStrategyBytes, NumericIndexStrategy.class);
final byte[] coordRangeBytes = new byte[bytes.length - indexStrategyLength - 4];
buf.get(coordRangeBytes);
final ArrayOfArrays arrays = new ArrayOfArrays();
arrays.fromBinary(coordRangeBytes);
coordinateRanges = arrays.getCoordinateArrays();
rangeCache = RangeLookupFactory.createMultiRangeLookup(coordinateRanges);
} catch (final Exception e) {
LOGGER.warn("Unable to read parameters", e);
}
}
@Override
public void init(
final SortedKeyValueIterator<Key, Value> source,
final Map<String, String> options,
final IteratorEnvironment env)
throws IOException {
this.source = source;
if (options == null) {
throw new IllegalArgumentException(
"Arguments must be set for " + NumericIndexStrategyFilterIterator.class.getName());
}
try {
if (options.containsKey(INDEX_STRATEGY_KEY)) {
final String idxStrategyStr = options.get(INDEX_STRATEGY_KEY);
final byte[] idxStrategyBytes = ByteArrayUtils.byteArrayFromString(idxStrategyStr);
indexStrategy = PersistenceUtils.fromBinary(idxStrategyBytes, NumericIndexStrategy.class);
} else {
throw new IllegalArgumentException(
"'"
+ INDEX_STRATEGY_KEY
+ "' must be set for "
+ NumericIndexStrategyFilterIterator.class.getName());
}
if (options.containsKey(COORDINATE_RANGE_KEY)) {
final String coordRangeStr = options.get(COORDINATE_RANGE_KEY);
final byte[] coordRangeBytes = ByteArrayUtils.byteArrayFromString(coordRangeStr);
final ArrayOfArrays arrays = new ArrayOfArrays();
arrays.fromBinary(coordRangeBytes);
rangeCache = RangeLookupFactory.createMultiRangeLookup(arrays.getCoordinateArrays());
} else {
throw new IllegalArgumentException(
"'"
+ COORDINATE_RANGE_KEY
+ "' must be set for "
+ NumericIndexStrategyFilterIterator.class.getName());
}
} catch (final Exception e) {
throw new IllegalArgumentException(e);
}
}