How to use

NumericVersion

in

org.infinispan.container.versioning

@DataProvider(name = "sizeMatchData")
public Object[][] sizeMatchData() {
 return new Object[][] {
    { 10, 100, -1, -1, null },
    { 20, 313, -1, -1, null },
    { 10, 100, 4000, -1, null },
    { 20, 313, -1, 10000, null },
    { 10, 100, 4000, -1, new NumericVersion(1003)},
    { 20, 313, -1, 10000, new NumericVersion(81418) },
    { 10, 100, 4000, 738141, null},
    { 20, 313, 14141, 10000, new NumericVersion(8417) },
 };
}

public static long extractVersion(CacheEntry ce) {
 if (ce == null) return -1;
 EntryVersion entryVersion = ce.getMetadata().version();
 long version = 0;
 if (entryVersion != null) {
   if (entryVersion instanceof NumericVersion) {
    version = NumericVersion.class.cast(entryVersion).getVersion();
   }
   if (entryVersion instanceof SimpleClusteredVersion) {
    version = SimpleClusteredVersion.class.cast(entryVersion).getVersion();
   }
 }
 return version;
}

public void testConditionalReplaceWithVersion() {
 final Integer key = 2;
 NumericVersion version = new NumericVersion(1);
 advCache.put(key, "v1", withVersion(version));
 NumericVersion newVersion = new NumericVersion(2);
 advCache.replace(key, "v1", "v2", withVersion(newVersion));
 CacheEntry cacheEntry = advCache.getCacheEntry(key);
 assertEquals(EQUAL, newVersion.compareTo(cacheEntry.getMetadata().version()));
}

@Override
public Void apply(ReadWriteEntryView<K, String> rw) {
  rw.set("one", new MetaEntryVersion(new NumericVersion(100)));
  return null;
}

public void testReplaceWithVersion() {
 final Integer key = 7;
 NumericVersion version = new NumericVersion(1);
 advCache.put(key, "v1", withVersion(version));
 NumericVersion newVersion = new NumericVersion(2);
 advCache.replace(key, "v2", withVersion(newVersion));
 CacheEntry cacheEntry = advCache.getCacheEntry(key);
 assertEquals(EQUAL, newVersion.compareTo(cacheEntry.getMetadata().version()));
}

private ByteBuf buildSingleGetWithVersionResponse(byte[] k, CacheEntry<byte[], byte[]> entry) {
 byte[] v = entry.getValue();
 // TODO: Would be nice for EntryVersion to allow retrieving the version itself...
 byte[] version = String.valueOf(((NumericVersion) entry.getMetadata().version()).getVersion()).getBytes();
 ByteBuf buf = buildGetHeaderBegin(k, entry, version.length + 1 + END_SIZE);
 buf.writeByte(SP); // 1
 buf.writeBytes(version); // version.length
 writeGetHeaderData(v, buf);
 return writeGetHeaderEnd(buf);
}

@Test
public void testDuplicateParametersOnConstruction() {
 MetaEntryVersion versionParam1 = new MetaEntryVersion(new NumericVersion(100));
 MetaEntryVersion versionParam2 = new MetaEntryVersion(new NumericVersion(200));
 MetaParams metas = MetaParams.of(versionParam1, versionParam2);
 assertEquals(1, metas.size());
 assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(200))),
   metas.find(MetaEntryVersion.class));
}

public void testPutWithVersion() {
 final Integer key = 1;
 NumericVersion version = new NumericVersion(1);
 advCache.put(key, "v1", withVersion(version));
 CacheEntry cacheEntry = advCache.getCacheEntry(key);
 assertEquals(EQUAL, version.compareTo(cacheEntry.getMetadata().version()));
}

@Override
public byte[] convert(byte[] key, byte[] oldValue, Metadata oldMetadata, byte[] newValue, Metadata newMetadata, EventType eventType) {
 int capacity = UnsignedNumeric.sizeUnsignedInt(key.length) + key.length +
    (newValue != null ? UnsignedNumeric.sizeUnsignedInt(newValue.length) + newValue.length + 8 : 0);
 if (newValue == null && returnOldValue && oldValue != null) {
   capacity += UnsignedNumeric.sizeUnsignedInt(oldValue.length) + oldValue.length + 8;
 }
 byte[] out = new byte[capacity];
 int offset = UnsignedNumeric.writeUnsignedInt(out, 0, key.length);
 offset += putBytes(key, offset, out);
 if (newValue != null) {
   offset += UnsignedNumeric.writeUnsignedInt(out, offset, newValue.length);
   offset += putBytes(newValue, offset, out);
   putLong(((NumericVersion) newMetadata.version()).getVersion(), offset, out);
 }
 if (newValue == null && returnOldValue && oldValue != null) {
   offset += UnsignedNumeric.writeUnsignedInt(out, offset, oldValue.length);
   offset += putBytes(oldValue, offset, out);
   putLong(((NumericVersion) newMetadata.version()).getVersion(), offset, out);
 }
 return out;
}

@Override
public ReadWriteEntryView<K, String> apply(ReadWriteEntryView<K, String> rw) {
  Optional<MetaEntryVersion> metaParam = rw.findMetaParam(MetaEntryVersion.class);
  metaParam.ifPresent(metaVersion -> {
   if (metaVersion.get().compareTo(new NumericVersion(version)) == EQUAL)
     rw.set("uno", new MetaEntryVersion(new NumericVersion(200)));
  });
  return rw;
}

public void testPutIfAbsentWithVersion() {
 final Integer key = 3;
 NumericVersion version = new NumericVersion(1);
 assertEquals(null, advCache.putIfAbsent(key, "v1", withVersion(version)));
 CacheEntry cacheEntry = advCache.getCacheEntry(key);
 assertEquals(EQUAL, version.compareTo(cacheEntry.getMetadata().version()));
}

private long serverDataVersion(byte[] k, Cache cache) {
 CacheEntry cacheEntry = cache.getAdvancedCache().getCacheEntry(k);
 Metadata metadata = cacheEntry.getMetadata();
 EntryVersion version = metadata.version();
 return ((NumericVersion) version).getVersion();
}

@Test
public void testDuplicateParametersOnAdd() {
 MetaEntryVersion versionParam1 = new MetaEntryVersion(new NumericVersion(100));
 MetaParams metas = MetaParams.of(versionParam1);
 assertEquals(1, metas.size());
 assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(100))),
   metas.find(MetaEntryVersion.class));
 MetaEntryVersion versionParam2 = new MetaEntryVersion(new NumericVersion(200));
 metas.add(versionParam2);
 assertEquals(1, metas.size());
 assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(200))),
   metas.find(MetaEntryVersion.class));
 MetaEntryVersion versionParam3 = new MetaEntryVersion(new NumericVersion(300));
 MetaEntryVersion versionParam4 = new MetaEntryVersion(new NumericVersion(400));
 metas.addMany(versionParam3, versionParam4);
 assertEquals(1, metas.size());
 assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(400))),
   metas.find(MetaEntryVersion.class));
}

public void testPutAsyncWithVersion() throws Exception {
 final Integer key = 4;
 NumericVersion version = new NumericVersion(1);
 Future<String> f = advCache.putAsync(key, "v1", withVersion(version));
 assertNotNull(f);
 assertFalse(f.isCancelled());
 assertNull(f.get());
 assertTrue(f.isDone());
 CacheEntry entry = advCache.getCacheEntry(key);
 assertEquals("v1", entry.getValue());
 assertEquals(EQUAL, version.compareTo(entry.getMetadata().version()));
}

@CacheEntryCreated
@CacheEntryModified
@CacheEntryRemoved
@CacheEntryExpired
public void onCacheEvent(CacheEntryEvent<byte[], byte[]> event) {
  if (isSendEvent(event)) {
   long version;
   Metadata metadata;
   if ((metadata = event.getMetadata()) != null && metadata.version() != null) {
     version = ((NumericVersion) metadata.version()).getVersion();
   } else {
     version = 0;
   }
   Object k = event.getKey();
   Object v = event.getValue();
   sendEvent((byte[]) k, (byte[]) v, version, event);
  }
}

public void testPrimaryOwnerChangingDuringReplaceBasedOnMeta() throws Exception {
 // TODO: Move initial set and replace with meta logic to TestWriteOperation
 WriteOnlyMap<String, String> wo0 = wo(0);
 wo0.eval("testkey", wo -> wo.set("v0", new MetaEntryVersion(new NumericVersion(1))));
 doTest(TestWriteOperation.REPLACE_META_FUNCTIONAL);
}

long version;
if (numericVersion != null) {
 version = numericVersion.getVersion();
} else {
 version = 0;

@Test
public void testAddFindMultipleMetaParams() {
 MetaParams metas = MetaParams.empty();
 metas.addMany(new MetaLifespan(1000), new MetaMaxIdle(1000), new MetaEntryVersion(new NumericVersion(12345)));
 assertFalse(metas.isEmpty());
 assertEquals(3, metas.size());
 Optional<MetaMaxIdle> maxIdle = metas.find(MetaMaxIdle.class);
 Optional<MetaEntryVersion> entryVersion = metas.find(MetaEntryVersion.class);
 assertEquals(Optional.of(new MetaMaxIdle(1000)), maxIdle);
 assertFalse(900 == maxIdle.get().get().longValue());
 assertEquals(new MetaEntryVersion(new NumericVersion(12345)), entryVersion.get());
 assertFalse(new MetaEntryVersion(new NumericVersion(23456)).equals(entryVersion.get()));
}

@Override
protected Object perform(TestWriteOperation op, AdvancedCache<Object, Object> cache0, String key) {
 try {
   return super.perform(op, cache0, key);
 } catch (IllegalArgumentException e) {
   switch (op) {
    case REPLACE_META_FUNCTIONAL:
      return FunctionalTestUtils.await(rw(cache0).eval(key, "v1", (v, rw) -> {
         return rw.findMetaParam(MetaEntryVersion.class)
          .filter(ver -> ver.get().compareTo(new NumericVersion(1)) == EQUAL)
          .map(ver -> {
            rw.set(v, new MetaEntryVersion(new NumericVersion(2)));
            return true;
          }).orElse(false);
       }));
    default:
      throw new AssertionError("Unknown operation: " + op);
   }
 }
}

private void handleGetForRemoveIfUnmodified(HotRodHeader header, AdvancedCache<byte[], byte[]> cache, CacheEntry<byte[], byte[]> entry, byte[] key, long version, Throwable throwable) {
 if (throwable != null) {
   writeException(header, throwable);
 } else if (entry != null) {
   byte[] prev = entry.getValue();
   NumericVersion streamVersion = new NumericVersion(version);
   if (entry.getMetadata().version().equals(streamVersion)) {
    cache.removeAsync(key, prev).whenComplete((removed, throwable2) -> {
      if (throwable2 != null) {
       writeException(header, throwable2);
      } else if (removed) {
       writeSuccess(header, prev);
      } else {
       writeNotExecuted(header, prev);
      }
    });
   } else {
    writeNotExecuted(header, prev);
   }
 } else {
   writeNotExist(header);
 }
}