congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
Versioned.value
Code IndexAdd Tabnine to your IDE (free)

How to use
value
method
in
voldemort.versioning.Versioned

Best Java code snippets using voldemort.versioning.Versioned.value (Showing top 20 results out of 315)

origin: voldemort/voldemort

public Version put(K key, V value) {
  Version version = getVersionForPut(key);
  Versioned<V> versioned = Versioned.value(value, version);
  return put(key, versioned);
}
origin: voldemort/voldemort

public Version put(K key, V value, Object transforms) {
  Version version = getVersionForPut(key);
  Versioned<V> versioned = Versioned.value(value, version);
  return put(key, versioned, transforms);
}
origin: voldemort/voldemort

@Override
public void setUp() {
  target1.put("hello", Versioned.value("world"), null);
  Integer[] values1 = { 1, 2, 3, 4, 5, 6, 7, 8 };
  Integer[] values2 = { 100, 200, 300, 400, 500, 600, 700 };
  target2.put(1, Versioned.value(Arrays.asList(values1)), null);
  target2.put(100, Versioned.value(Arrays.asList(values2)), null);
}
origin: voldemort/voldemort

public Version putSysStore(K key, V value) {
  Version version = null;
  try {
    if(logger.isDebugEnabled()) {
      logger.debug("Invoking Put for key : " + key + " on store name : " + this.storeName);
    }
    Versioned<V> versioned = getSysStore(key);
    if(versioned == null)
      versioned = Versioned.value(value, new VectorClock());
    else
      versioned.setObject(value);
    this.sysStore.put(key, versioned, null);
    version = versioned.getVersion();
  } catch(Exception e) {
    if(logger.isDebugEnabled()) {
      logger.debug("Exception caught during putSysStore: " + e);
    }
  }
  return version;
}
origin: voldemort/voldemort

  public void run() {
    while(keepRunning.get()) {
      byte[] bytes = Integer.toString(count.getAndIncrement()).getBytes();
      store.put(new ByteArray(bytes), Versioned.value(bytes), null);
      count.incrementAndGet();
    }
  }
});
origin: voldemort/voldemort

public static List<Versioned<byte[]>> fromByteArray(byte[] bytes) {
  if(bytes.length < 1)
    throw new VoldemortException("Invalid value length: " + bytes.length);
  if(bytes[0] != VERSION)
    throw new VoldemortException("Unexpected version number in value: " + bytes[0]);
  int pos = 1;
  List<Versioned<byte[]>> vals = new ArrayList<Versioned<byte[]>>(2);
  while(pos < bytes.length) {
    VectorClock clock = new VectorClock(bytes, pos);
    pos += clock.sizeInBytes();
    int valueSize = ByteUtils.readInt(bytes, pos);
    pos += ByteUtils.SIZE_OF_INT;
    byte[] val = new byte[valueSize];
    System.arraycopy(bytes, pos, val, 0, valueSize);
    pos += valueSize;
    vals.add(Versioned.value(val, clock));
  }
  if(pos != bytes.length)
    throw new VoldemortException((bytes.length - pos)
                   + " straggling bytes found in value (this should not be possible)!");
  return vals;
}
origin: voldemort/voldemort

private Versioned<Slop> randomSlop(String name, int nodeId) {
  return Versioned.value(new Slop(name,
                  Operation.PUT,
                  TestUtils.randomBytes(10),
                  TestUtils.randomBytes(10),
                  nodeId,
                  new Date()));
}
origin: voldemort/voldemort

public void testGetAll() {
  target1.put("a", Versioned.value("a"), null);
  target1.put("b", Versioned.value("b"), null);
  Map<String, List<Versioned<String>>> found = valView.getAll(ImmutableList.of("a", "b"),
                                ImmutableMap.of("a",
                                        "concat",
                                        "b",
                                        "concat"));
  assertTrue(found.containsKey("a"));
  assertTrue(found.containsKey("b"));
  assertEquals("a42", found.get("a").get(0).getValue());
  assertEquals("b42", found.get("b").get(0).getValue());
}
origin: voldemort/voldemort

@Override
public void put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
    throws VoldemortException {
  if(valueCompressionStrategy != null)
    value = inflateValue(value);
  Versioned<byte[]> result = Versioned.value(valueFromViewSchema(key,
                                  value.getValue(),
                                  transforms),
                        value.getVersion());
  if(valueCompressionStrategy != null)
    result = deflateValue(result);
  target.put(key, result, null);
}
origin: voldemort/voldemort

public void testPutWithTransforms() {
  Integer[] values1 = { 9, 90, 10, 15, 25, 106 };
  Integer[] filter1 = { 1, 10 };
  Versioned<List<Integer>> values = Versioned.value(Arrays.asList(values1));
  VectorClock clock = (VectorClock) values.getVersion();
  clock.incrementVersion(0, System.currentTimeMillis());
  view.put(1, Versioned.value(values.getValue(), clock), Arrays.asList(filter1));
  assertEquals(10, view.get(1, Arrays.asList(filter1)).get(0).getValue().size());
  Integer[] filter2 = { 5, 10 };
  assertEquals(6, view.get(1, Arrays.asList(filter2)).get(0).getValue().size());
  Version updatedVersion = view.get(1, Arrays.asList(filter2)).get(0).getVersion();
  Integer[] filter3 = { 1, 50 };
  Integer[] values2 = { 90, 15, 25, 106 };
  clock = (VectorClock) updatedVersion;
  VectorClock clock1 = clock.incremented(0, System.currentTimeMillis());
  view.put(1, Versioned.value(Arrays.asList(values2), clock1), Arrays.asList(filter3));
  assertEquals(12, view.get(1, Arrays.asList(filter3)).get(0).getValue().size());
}
origin: voldemort/voldemort

  @Override
  public void doOperation(int index) {
    try {
      String key = Integer.toString(index);
      List<Versioned<byte[]>> vs = store.get(key, null);
      VectorClock version;
      if(vs.size() == 0)
        version = new VectorClock();
      else
        version = (VectorClock) vs.get(0).getVersion();
      version.incrementVersion(0, 847584375);
      store.put(key, Versioned.value(value, version), null);
    } catch(ObsoleteVersionException e) {
      // do nothing
    } catch(RuntimeException e) {
      e.printStackTrace();
      throw e;
    }
  }
}, recents, numValues, cacheHitRatio);
origin: voldemort/voldemort

public void testPut() {
  valView.put("abc", Versioned.value("cde"), null);
  assertEquals("c", target1.get("abc", null).get(0).getValue());
}
origin: voldemort/voldemort

/**
 * Util function to test getAll with one node down
 * 
 * @param store The Routed store object used to perform the put and getall
 * @throws Exception
 */
private void getAllWithNodeDown(Store<ByteArray, byte[], byte[]> store) throws Exception {
  Map<ByteArray, byte[]> expectedValues = Maps.newHashMap();
  for(byte i = 1; i < 11; ++i) {
    ByteArray key = new ByteArray(new byte[] { i });
    byte[] value = new byte[] { (byte) (i + 50) };
    store.put(key, Versioned.value(value), null);
    expectedValues.put(key, value);
  }
  recordException(failureDetector, cluster.getNodes().iterator().next());
  Map<ByteArray, List<Versioned<byte[]>>> all = store.getAll(expectedValues.keySet(), null);
  assertEquals(expectedValues.size(), all.size());
  for(Map.Entry<ByteArray, List<Versioned<byte[]>>> mapEntry: all.entrySet()) {
    byte[] value = expectedValues.get(mapEntry.getKey());
    assertEquals(new ByteArray(value), new ByteArray(mapEntry.getValue().get(0).getValue()));
  }
}
origin: voldemort/voldemort

  @Override
  protected Pair<ByteArray, Versioned<byte[]>> computeNext() {
    Pair<ByteArray, Versioned<byte[]>> p = inner.next();
    Versioned<byte[]> newVal = Versioned.value(valueToViewSchema(p.getFirst(),
                                   p.getSecond().getValue(),
                                   null),
                          p.getSecond().getVersion());
    return Pair.create(p.getFirst(), newVal);
  }
}
origin: voldemort/voldemort

@Test
public void testGetVersions() throws Exception {
  List<K> keys = getKeys(2);
  K key = keys.get(0);
  V value = getValue();
  Store<K, V, T> store = getStore();
  store.put(key, Versioned.value(value), null);
  List<Versioned<V>> versioneds = store.get(key, null);
  List<Version> versions = store.getVersions(key);
  assertEquals(1, versioneds.size());
  assertTrue(versions.size() > 0);
  for(int i = 0; i < versions.size(); i++)
    assertEquals(versioneds.get(0).getVersion(), versions.get(i));
  assertEquals(0, store.getVersions(keys.get(1)).size());
}
origin: voldemort/voldemort

@Test
public void testGetVersions2() throws Exception {
  List<ByteArray> keys = getKeys(2);
  ByteArray key = keys.get(0);
  byte[] value = getValue();
  Store<ByteArray, byte[], byte[]> store = getStore();
  store.put(key, Versioned.value(value), null);
  List<Versioned<byte[]>> versioneds = store.get(key, null);
  List<Version> versions = store.getVersions(key);
  assertEquals(1, versioneds.size());
  assertEquals(9, versions.size());
  for(int i = 0; i < versions.size(); i++)
    assertEquals(versioneds.get(0).getVersion(), versions.get(i));
  assertEquals(0, store.getVersions(keys.get(1)).size());
}
origin: voldemort/voldemort

@Test
public void testGetVersions2ZZZ() throws Exception {
  List<ByteArray> keys = getKeys(2);
  ByteArray key = keys.get(0);
  byte[] value = getValue();
  Store<ByteArray, byte[], byte[]> store = getZonedStore();
  store.put(key, Versioned.value(value), null);
  List<Versioned<byte[]>> versioneds = store.get(key, null);
  List<Version> versions = store.getVersions(key);
  assertEquals(1, versioneds.size());
  assertEquals(9, versions.size());
  for(int i = 0; i < versions.size(); i++)
    assertEquals(versioneds.get(0).getVersion(), versions.get(i));
  assertEquals(0, store.getVersions(keys.get(1)).size());
}
origin: voldemort/voldemort

@Override
@Test
public void testGetVersions() throws Exception {
  List<ByteArray> keys = getKeys(2);
  ByteArray key = keys.get(0);
  byte[] value = getValue();
  VectorClock vc = getClock(0, 0);
  Store<ByteArray, byte[], byte[]> store = getStore();
  store.put(key, Versioned.value(value, vc), null);
  List<Versioned<byte[]>> versioneds = store.get(key, null);
  List<Version> versions = store.getVersions(key);
  assertEquals(1, versioneds.size());
  assertTrue(versions.size() > 0);
  for(int i = 0; i < versions.size(); i++)
    assertEquals(versioneds.get(0).getVersion(), versions.get(i));
  assertEquals(0, store.getVersions(keys.get(1)).size());
}
origin: voldemort/voldemort

/**
 * Test the new put that returns the new version
 */
@Test
public void testPutReturnVersion() {
  Version baseVersion = new VectorClock();
  Version oldVersion = null;
  Version newVersion = null;
  Versioned<String> getVersioned = null;
  String oldValue = null;
  String newValue = null;
  for(int i = 0; i < 5; i++) {
    oldValue = "value" + i;
    newValue = "value" + (i + 1);
    oldVersion = storeClient.put("key1", Versioned.value(oldValue, baseVersion));
    newVersion = storeClient.put("key1",
                   Versioned.value(newValue,
                           ((VectorClock) oldVersion).clone()));
    getVersioned = storeClient.get("key1");
    baseVersion = newVersion;
    verifyResults(oldVersion, newVersion, getVersioned, newValue);
  }
}
origin: voldemort/voldemort

@Test
public void testPutVersioned() {
  client.put("k", Versioned.value("v"));
  Versioned<String> v = client.get("k");
  assertEquals("GET should return the version set by PUT.", "v", v.getValue());
  VectorClock expected = new VectorClock();
  expected.incrementVersion(nodeId, time.getMilliseconds());
  assertEquals("The version should be incremented after a put.", expected, v.getVersion());
  try {
    client.put("k", Versioned.value("v"));
    fail("Put of obsolete version should throw exception.");
  } catch(ObsoleteVersionException e) {
    // this is good
  }
  // PUT of a concurrent version should succeed
  client.put("k",
        new Versioned<String>("v2",
                   new VectorClock().incremented(nodeId + 1,
                                  time.getMilliseconds())));
  assertEquals("GET should return the new value set by PUT.", "v2", client.getValue("k"));
  assertEquals("GET should return the new version set by PUT.",
         expected.incremented(nodeId + 1, time.getMilliseconds()),
         client.get("k").getVersion());
}
voldemort.versioningVersionedvalue

Popular methods of Versioned

  • getValue
  • <init>
  • getVersion
  • setObject
  • cloneVersioned
    Create a clone of this Versioned object such that the object pointed to is the same, but the VectorC
  • equals
  • hashCode
  • toString

Popular in Java

  • Creating JSON documents from java classes using gson
  • getResourceAsStream (ClassLoader)
  • scheduleAtFixedRate (ScheduledExecutorService)
  • findViewById (Activity)
  • Container (java.awt)
    A generic Abstract Window Toolkit(AWT) container object is a component that can contain other AWT co
  • URLEncoder (java.net)
    This class is used to encode a string using the format required by application/x-www-form-urlencoded
  • ArrayList (java.util)
    ArrayList is an implementation of List, backed by an array. All optional operations including adding
  • Comparator (java.util)
    A Comparator is used to compare two objects to determine their ordering with respect to each other.
  • PriorityQueue (java.util)
    A PriorityQueue holds elements on a priority heap, which orders the elements according to their natu
  • JButton (javax.swing)
  • Best IntelliJ plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now