Java Code Examples for gnu.trove.map.hash.TLongObjectHashMap#put()

private static void writeBlocksLabelMultisetType(
		final RandomAccessibleInterval<UnsignedLongType> canvas,
		final long[] blocks,
		final DatasetSpec datasetSpec,
		final BlockSpec blockSpec,
		final TLongObjectHashMap<BlockDiff> blockDiff) throws IOException {
	final RandomAccessibleInterval<LabelMultisetType> highestResolutionData = N5LabelMultisets.openLabelMultiset(datasetSpec.container, datasetSpec.dataset);
	for (final long blockId : blocks) {
		blockSpec.fromLinearIndex(blockId);
		final IntervalView<Pair<LabelMultisetType, UnsignedLongType>> backgroundWithCanvas = Views.interval(Views.pair(highestResolutionData, canvas), blockSpec.asInterval());
		final int numElements = (int) Intervals.numElements(backgroundWithCanvas);
		final byte[] byteData = LabelUtils.serializeLabelMultisetTypes(new BackgroundCanvasIterable(Views.flatIterable(backgroundWithCanvas)), numElements);
		final ByteArrayDataBlock dataBlock = new ByteArrayDataBlock(Intervals.dimensionsAsIntArray(backgroundWithCanvas), blockSpec.pos, byteData);
		datasetSpec.container.writeBlock(datasetSpec.dataset, datasetSpec.attributes, dataBlock);
		blockDiff.put(blockId, createBlockDiffFromCanvas(backgroundWithCanvas));
	}
}
 

private static <I extends IntegerType<I> & NativeType<I>> void writeBlocksLabelIntegerType(
		final RandomAccessibleInterval<UnsignedLongType> canvas,
		final long[] blocks,
		final DatasetSpec datasetSpec,
		final BlockSpec blockSpec,
		final TLongObjectHashMap<BlockDiff> blockDiff) throws IOException {
	final RandomAccessibleInterval<I> highestResolutionData = N5Utils.open(datasetSpec.container, datasetSpec.dataset);
	final I i = Util.getTypeFromInterval(highestResolutionData).createVariable();
	for (final long blockId : blocks) {
		blockSpec.fromLinearIndex(blockId);
		final RandomAccessibleInterval<Pair<I, UnsignedLongType>> backgroundWithCanvas = Views.interval(Views.pair(highestResolutionData, canvas), blockSpec.asInterval());
		final RandomAccessibleInterval<I> mergedData = Converters.convert(backgroundWithCanvas, (s, t) -> pickFirstIfSecondIsInvalid(s.getA(), s.getB(), t), i.createVariable());
		N5Utils.saveBlock(mergedData, datasetSpec.container, datasetSpec.dataset, datasetSpec.attributes, blockSpec.pos);
		blockDiff.put(blockId, createBlockDiffFromCanvasIntegerType(Views.iterable(backgroundWithCanvas)));
	}
}
 

public static synchronized void initialize(EntityManager em) {
       TLongObjectHashMap<Currency> currencies = new TLongObjectHashMap<Currency>();
	Query<Currency> q = em.createQuery(Currency.class);
	Cursor c = q.execute();
	try {
		while (c.moveToNext()) {
			Currency currency = EntityManager.loadFromCursor(c, Currency.class);
			currencies.put(currency.id, currency);
		}
	} finally {
		c.close();
	}
	CURRENCIES.putAll(currencies);
}
 

private static <I extends IntegerType<I> & NativeType<I>> void downsampleAndWriteBlocksIntegerType(
		final long[] affectedBlocks,
		final N5Writer n5,
		final DatasetSpec previousDataset,
		final DatasetSpec targetDataset,
		final BlockSpec blockSpec,
		final Scale3D targetToPrevious,
		final int[] relativeFactors,
		final int level,
		final TLongObjectHashMap<BlockDiff> blockDiffsAt
) throws IOException {

	final RandomAccessibleInterval<I> previousData = N5Utils.open(n5, previousDataset.dataset);

	for (final long targetBlock : affectedBlocks)
	{
		blockSpec.fromLinearIndex(targetBlock);
		final double[] blockMinDouble = ArrayMath.asDoubleArray3(blockSpec.min);
		final double[] blockMaxDouble = ArrayMath.asDoubleArray3(ArrayMath.add3(blockSpec.max, 1));
		targetToPrevious.apply(blockMinDouble, blockMinDouble);
		targetToPrevious.apply(blockMaxDouble, blockMaxDouble);

		LOG.debug("level={}: blockMinDouble={} blockMaxDouble={}", level, blockMinDouble, blockMaxDouble);

		final long[] blockMin = ArrayMath.minOf3(ArrayMath.asLong3(ArrayMath.floor3(blockMinDouble, blockMinDouble)), previousDataset.dimensions);
		final long[] blockMax = ArrayMath.minOf3(ArrayMath.asLong3(ArrayMath.ceil3(blockMaxDouble, blockMaxDouble)), previousDataset.dimensions);
		final Interval targetInterval = new FinalInterval(blockSpec.min, blockSpec.max);
		final int[] size = Intervals.dimensionsAsIntArray(targetInterval);

		final long[] previousRelevantIntervalMin = blockMin.clone();
		final long[] previousRelevantIntervalMax = ArrayMath.add3(blockMax, -1);

		ArrayMath.divide3(blockMin, previousDataset.blockSize, blockMin);
		ArrayMath.divide3(blockMax, previousDataset.blockSize, blockMax);
		ArrayMath.add3(blockMax, -1, blockMax);
		ArrayMath.minOf3(blockMax, blockMin, blockMax);

		LOG.trace("Reading old access at position {} and size {}. ({} {})", blockSpec.pos, size, blockSpec.min, blockSpec.max);

		final BlockDiff blockDiff = downsampleIntegerTypeAndSerialize(
				n5,
				targetDataset.dataset,
				targetDataset.attributes,
				Views.interval(previousData, previousRelevantIntervalMin, previousRelevantIntervalMax),
				relativeFactors,
				size,
				targetInterval,
				blockSpec.pos);
		blockDiffsAt.put(targetBlock, blockDiff);
	}
}
 

public TsvChain(@NonNull DateTime initTs, @NonNull TimeSeriesValue initTsv) {
    final TLongObjectHashMap<TimeSeriesValue> tail = new TLongObjectHashMap<>();
    tail.put(initTs.getMillis(), initTsv);
    tailRefForAccess = new SoftReference<>(tail);
    tailRefForUpdate = new WeakReference<>(tail);
}