Uses of Class
voldemort.versioning.Versioned

Packages that use Versioned
voldemort.client The user facing interface to Voldemort. 
voldemort.client.protocol Classes that abstract the serialization format for Voldemort client requests. 
voldemort.client.protocol.admin Classes that abstract admin based Voldemort requests. 
voldemort.client.protocol.admin.filter Classes that deal with filters that can be used by our streaming API 
voldemort.client.protocol.pb A protocol buffers based client-side request format. 
voldemort.client.protocol.vold Classes specific to our native Voldemort protocol. 
voldemort.coordinator   
voldemort.serialization Code for mapping objects to bytes and bytes to objects. 
voldemort.server.protocol.admin Server side implementation of admin based requests 
voldemort.server.rest   
voldemort.store The Store interface is the primary interface for Voldemort. 
voldemort.store.bdb A storage engine that persists data in BDB JE. 
voldemort.store.compress Classes associated with compression on the server ( storage ) side. 
voldemort.store.configuration A storage engine to persist metadata on a server. 
voldemort.store.gzip Storage engine which gzips the content before delegating it down. 
voldemort.store.http HTTP based storage engine 
voldemort.store.invalidmetadata Server side store which checks whether the tuples coming to this node are valid. 
voldemort.store.logging A wrapper store which deals with logging. 
voldemort.store.memory An in-memory storage engine that serves data out of a non-persistent map. 
voldemort.store.metadata Our in-memory metadata store on the server which is backed by the configuration files. 
voldemort.store.mysql A storage engine that persists data in a mysql instance. 
voldemort.store.nonblockingstore Non-blocking store which deals with async requests. 
voldemort.store.readonly A storage engine that provides very efficient read-only access to large sorted files of data. 
voldemort.store.readonly.chunk Read-only store classes for understanding various format changes. 
voldemort.store.rebalancing Server side wrapper stores used for redirection during rebalancing. 
voldemort.store.retention   
voldemort.store.routed A store implmentation that handles routing to nodes, and repairing obsolete values detected on those nodes. 
voldemort.store.routed.action Classes representing various states for the state based routing stores. 
voldemort.store.serialized A store implementation that handles serialization to bytes from rich objects. 
voldemort.store.slop A store implementation that falls back on storing values in additional nodes not in the preference list when nodes are unavailable. 
voldemort.store.socket A store implementation that works remotely over a tcp/ip socket interacting with a SocketServer on the the other side. 
voldemort.store.socket.clientrequest More classes related to how to parse client requests 
voldemort.store.stats Store wrappers which deal with statistics 
voldemort.store.versioned Store decorators that interact with versions. 
voldemort.store.views Classes related to Views and server side transforms 
voldemort.utils Basic helper functions. 
voldemort.versioning Classes for operating on vector clocks and dealing with distributed state. 
 

Uses of Versioned in voldemort.client
 

Fields in voldemort.client with type parameters of type Versioned
protected  InconsistencyResolver<Versioned<V>> DefaultStoreClient.resolver
           
 

Methods in voldemort.client that return Versioned
 Versioned<V> DefaultStoreClient.get(K key)
           
 Versioned<V> LazyStoreClient.get(K key)
           
 Versioned<V> StoreClient.get(K key)
          Get the versioned value associated with the given key or null if no value is associated with the key.
 Versioned<V> DefaultStoreClient.get(K key, java.lang.Object transforms)
           
 Versioned<V> LazyStoreClient.get(K key, java.lang.Object transforms)
           
 Versioned<V> StoreClient.get(K key, java.lang.Object transforms)
          Get the versioned value associated with the given key and apply the given transforms to it before returning the value.
 Versioned<V> DefaultStoreClient.get(K key, Versioned<V> defaultValue)
           
 Versioned<V> LazyStoreClient.get(K key, Versioned<V> defaultValue)
           
 Versioned<V> StoreClient.get(K key, Versioned<V> defaultValue)
          Get the versioned value associated with the given key or the defaultValue if no value is associated with the key.
 Versioned<V> DefaultStoreClient.get(K key, Versioned<V> defaultValue, java.lang.Object transform)
           
protected  Versioned<V> DefaultStoreClient.getItemOrThrow(K key, Versioned<V> defaultValue, java.util.List<Versioned<V>> items)
           
 Versioned<V> SystemStoreClient.getSysStore(K key)
           
 

Methods in voldemort.client that return types with arguments of type Versioned
 java.util.Map<K,Versioned<V>> DefaultStoreClient.getAll(java.lang.Iterable<K> keys)
           
 java.util.Map<K,Versioned<V>> LazyStoreClient.getAll(java.lang.Iterable<K> keys)
           
 java.util.Map<K,Versioned<V>> StoreClient.getAll(java.lang.Iterable<K> keys)
          Gets the versioned values associated with the given keys and returns them in a Map of keys to versioned values.
 java.util.Map<K,Versioned<V>> DefaultStoreClient.getAll(java.lang.Iterable<K> keys, java.util.Map<K,java.lang.Object> transforms)
           
 java.util.Map<K,Versioned<V>> LazyStoreClient.getAll(java.lang.Iterable<K> keys, java.util.Map<K,java.lang.Object> transforms)
           
 java.util.Map<K,Versioned<V>> StoreClient.getAll(java.lang.Iterable<K> keys, java.util.Map<K,java.lang.Object> transforms)
          Like getAll, except that the transforms are applied on the value associated with each key before returning the results
protected  java.util.List<Versioned<java.lang.String>> AbstractStoreClientFactory.getRemoteMetadata(java.lang.String key, java.net.URI url)
           
protected  java.util.List<Versioned<java.lang.String>> SocketStoreClientFactory.getRemoteMetadata(java.lang.String key, java.net.URI url)
           
 

Methods in voldemort.client with parameters of type Versioned
 Versioned<V> DefaultStoreClient.get(K key, Versioned<V> defaultValue)
           
 Versioned<V> LazyStoreClient.get(K key, Versioned<V> defaultValue)
           
 Versioned<V> StoreClient.get(K key, Versioned<V> defaultValue)
          Get the versioned value associated with the given key or the defaultValue if no value is associated with the key.
 Versioned<V> DefaultStoreClient.get(K key, Versioned<V> defaultValue, java.lang.Object transform)
           
protected  Versioned<V> DefaultStoreClient.getItemOrThrow(K key, Versioned<V> defaultValue, java.util.List<Versioned<V>> items)
           
 Version DefaultStoreClient.put(K key, Versioned<V> versioned)
           
 Version LazyStoreClient.put(K key, Versioned<V> versioned)
           
 Version StoreClient.put(K key, Versioned<V> versioned)
          Put the given Versioned value into the store for the given key if the version is greater to or concurrent with existing values.
 Version DefaultStoreClient.put(K key, Versioned<V> versioned, java.lang.Object transform)
           
 boolean DefaultStoreClient.putIfNotObsolete(K key, Versioned<V> versioned)
           
 boolean LazyStoreClient.putIfNotObsolete(K key, Versioned<V> versioned)
           
 boolean StoreClient.putIfNotObsolete(K key, Versioned<V> versioned)
          Put the versioned value to the key, ignoring any ObsoleteVersionException that may be thrown
 Version SystemStoreClient.putSysStore(K key, Versioned<V> value)
           
 

Method parameters in voldemort.client with type arguments of type Versioned
protected  Versioned<V> DefaultStoreClient.getItemOrThrow(K key, Versioned<V> defaultValue, java.util.List<Versioned<V>> items)
           
<K,V,T> Store<K,V,T>
AbstractStoreClientFactory.getRawStore(java.lang.String storeName, InconsistencyResolver<Versioned<V>> resolver)
           
<K,V,T> Store<K,V,T>
StoreClientFactory.getRawStore(java.lang.String storeName, InconsistencyResolver<Versioned<V>> resolver)
          Get the underlying store, not the public StoreClient interface
<K,V,T> Store<K,V,T>
CachingStoreClientFactory.getRawStore(java.lang.String storeName, InconsistencyResolver<Versioned<V>> resolver)
           
<K,V,T> Store<K,V,T>
AbstractStoreClientFactory.getRawStore(java.lang.String storeName, InconsistencyResolver<Versioned<V>> resolver, java.lang.String customStoresXml, java.lang.String clusterXmlString, FailureDetector fd)
           
<K1,V1,T1> Store<K1,V1,T1>
MockStoreClientFactory.getRawStore(java.lang.String storeName, InconsistencyResolver<Versioned<V1>> resolver)
           
<K,V> StoreClient<K,V>
AbstractStoreClientFactory.getStoreClient(java.lang.String storeName, InconsistencyResolver<Versioned<V>> resolver)
           
<K,V> StoreClient<K,V>
MockStoreClientFactory.getStoreClient(java.lang.String storeName, InconsistencyResolver<Versioned<V>> resolver)
           
<K,V> StoreClient<K,V>
StoreClientFactory.getStoreClient(java.lang.String storeName, InconsistencyResolver<Versioned<V>> inconsistencyResolver)
          Get a StoreClient for the given store.
<K,V> StoreClient<K,V>
SocketStoreClientFactory.getStoreClient(java.lang.String storeName, InconsistencyResolver<Versioned<V>> resolver)
           
<K,V> StoreClient<K,V>
CachingStoreClientFactory.getStoreClient(java.lang.String storeName, InconsistencyResolver<Versioned<V>> resolver)
           
 

Constructor parameters in voldemort.client with type arguments of type Versioned
DefaultStoreClient(java.lang.String storeName, InconsistencyResolver<Versioned<V>> resolver, StoreClientFactory storeFactory, int maxMetadataRefreshAttempts)
           
ZenStoreClient(java.lang.String storeName, InconsistencyResolver<Versioned<V>> resolver, AbstractStoreClientFactory storeFactory, int maxMetadataRefreshAttempts)
           
ZenStoreClient(java.lang.String storeName, InconsistencyResolver<Versioned<V>> resolver, AbstractStoreClientFactory storeFactory, int maxMetadataRefreshAttempts, java.lang.String clientContext, int clientSequence, ClientConfig config, SchedulerService scheduler)
           
 

Uses of Versioned in voldemort.client.protocol
 

Methods in voldemort.client.protocol that return types with arguments of type Versioned
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> RequestFormat.readGetAllResponse(java.io.DataInputStream stream)
           
 java.util.List<Versioned<byte[]>> RequestFormat.readGetResponse(java.io.DataInputStream stream)
           
 

Methods in voldemort.client.protocol with parameters of type Versioned
 boolean VoldemortFilter.accept(java.lang.Object key, Versioned<?> value)
          Extend this function to implement custom filter strategies.
 

Uses of Versioned in voldemort.client.protocol.admin
 

Methods in voldemort.client.protocol.admin that return Versioned
 Versioned<Cluster> AdminClient.RebalancingOperations.getLatestCluster(java.util.List<java.lang.Integer> requiredNodes)
          Get the latest cluster from all available nodes in the cluster
Throws exception if:
A) Any node in the required nodes list fails to respond.
B) Cluster is in inconsistent state with concurrent versions for cluster metadata on any two nodes.
 Versioned<Cluster> AdminClient.MetadataManagementOperations.getRemoteCluster(int nodeId)
          Get the cluster information from a remote node.
 Versioned<java.lang.String> AdminClient.MetadataManagementOperations.getRemoteMetadata(int remoteNodeId, java.lang.String key)
          Get the metadata on a remote node.
 Versioned<MetadataStore.VoldemortState> AdminClient.RebalancingOperations.getRemoteServerState(int nodeId)
          Retrieve the server MetadataStore.VoldemortState from a remote node.
 Versioned<java.util.List<StoreDefinition>> AdminClient.MetadataManagementOperations.getRemoteStoreDefList(int nodeId)
          Retrieve the store definitions from a remote node.
 

Methods in voldemort.client.protocol.admin that return types with arguments of type Versioned
 java.util.Iterator<Pair<ByteArray,Versioned<byte[]>>> AdminClient.BulkStreamingFetchOperations.fetchEntries(int nodeId, java.lang.String storeName, java.util.List<java.lang.Integer> partitionList, VoldemortFilter filter, boolean fetchMasterEntries)
          Legacy interface for fetching entries.
 java.util.Iterator<Pair<ByteArray,Versioned<byte[]>>> AdminClient.BulkStreamingFetchOperations.fetchEntries(int nodeId, java.lang.String storeName, java.util.List<java.lang.Integer> partitionIds, VoldemortFilter filter, boolean fetchMasterEntries, Cluster initialCluster, long recordsPerPartition)
          Fetch key/value tuples belonging to this list of partition ids
 java.util.Iterator<Pair<ByteArray,Versioned<byte[]>>> AdminClient.BulkStreamingFetchOperations.fetchEntries(int nodeId, java.lang.String storeName, java.util.List<java.lang.Integer> partitionIds, VoldemortFilter filter, boolean fetchMasterEntries, long recordsPerPartition)
          Legacy interface for fetching entries.
 java.util.Iterator<Pair<ByteArray,Versioned<byte[]>>> AdminClient.BulkStreamingFetchOperations.fetchOrphanedEntries(int nodeId, java.lang.String storeName)
          Fetches entries that don't belong to the node, based on current metadata and yet persisted on the node
 java.util.List<Versioned<byte[]>> AdminClient.StoreOperations.getNodeKey(java.lang.String storeName, int nodeId, ByteArray key)
          Fetch key/value tuple for given key for a specific store on specified node.
 java.util.List<Versioned<byte[]>> QueryKeyResult.getValues()
           
 

Methods in voldemort.client.protocol.admin with parameters of type Versioned
 void BaseStreamingClient.streamingPut(ByteArray key, Versioned<byte[]> value)
          A Streaming Put call
 void BaseStreamingClient.streamingPut(ByteArray key, Versioned<byte[]> value, java.lang.String storeName)
           
 void StreamingClient.streamingPut(ByteArray key, Versioned<byte[]> value, java.lang.String storeName)
           
protected  void StreamingClient.streamingSlopPut(ByteArray key, Versioned<byte[]> value, java.lang.String storeName, int failedNodeId)
          This is a method to stream slops to "slop" store when a node is detected faulty in a streaming session
 void AdminClient.MetadataManagementOperations.updateRemoteMetadata(int remoteNodeId, java.lang.String key, Versioned<java.lang.String> value)
          Update metadata at the given remoteNodeId.
 void AdminClient.MetadataManagementOperations.updateRemoteMetadata(java.util.List<java.lang.Integer> remoteNodeIds, java.lang.String key, Versioned<java.lang.String> value)
          Wrapper for updateRemoteMetadata function used against a single Node It basically loops over the entire list of Nodes that we need to execute the required operation against.
 

Method parameters in voldemort.client.protocol.admin with type arguments of type Versioned
 void AdminClient.StreamingOperations.updateEntries(int nodeId, java.lang.String storeName, java.util.Iterator<Pair<ByteArray,Versioned<byte[]>>> entryIterator, VoldemortFilter filter)
          Update a stream of key/value entries at the given node.
 void AdminClient.StreamingOperations.updateSlopEntries(int nodeId, java.util.Iterator<Versioned<Slop>> entryIterator)
          Update slops which may be meant for multiple stores
 

Constructor parameters in voldemort.client.protocol.admin with type arguments of type Versioned
QueryKeyResult(ByteArray key, java.util.List<Versioned<byte[]>> values)
           
 

Uses of Versioned in voldemort.client.protocol.admin.filter
 

Methods in voldemort.client.protocol.admin.filter with parameters of type Versioned
 boolean DefaultVoldemortFilter.accept(java.lang.Object key, Versioned<?> value)
           
 

Uses of Versioned in voldemort.client.protocol.pb
 

Methods in voldemort.client.protocol.pb that return Versioned
static Versioned<byte[]> ProtoUtils.decodeVersioned(VProto.Versioned versioned)
           
static Versioned<byte[]> ProtoUtils.decodeVersionedMetadataKeyValue(VProto.KeyedVersions keyValue)
          Given a list of value versions for the metadata keys we are just interested in the value at index 0 This is because even if we have to update the cluster.xml we marshall a single key into a versioned list Hence we just look at the value at index 0
 

Methods in voldemort.client.protocol.pb that return types with arguments of type Versioned
static java.util.List<Versioned<byte[]>> ProtoUtils.decodeVersions(java.util.List<VProto.Versioned> versioned)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> ProtoBuffClientRequestFormat.readGetAllResponse(java.io.DataInputStream input)
           
 java.util.List<Versioned<byte[]>> ProtoBuffClientRequestFormat.readGetResponse(java.io.DataInputStream input)
           
 

Methods in voldemort.client.protocol.pb with parameters of type Versioned
static VProto.Versioned.Builder ProtoUtils.encodeVersioned(Versioned<byte[]> versioned)
           
 

Uses of Versioned in voldemort.client.protocol.vold
 

Methods in voldemort.client.protocol.vold that return types with arguments of type Versioned
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> VoldemortNativeClientRequestFormat.readGetAllResponse(java.io.DataInputStream stream)
           
 java.util.List<Versioned<byte[]>> VoldemortNativeClientRequestFormat.readGetResponse(java.io.DataInputStream inputStream)
           
 

Uses of Versioned in voldemort.coordinator
 

Methods in voldemort.coordinator that return types with arguments of type Versioned
 java.util.Map<K,java.util.List<Versioned<V>>> DynamicTimeoutStoreClient.getAllWithCustomTimeout(CompositeVoldemortRequest<K,V> requestWrapper)
          Performs a get all operation with the specified composite request object
 java.util.List<Versioned<V>> DynamicTimeoutStoreClient.getWithCustomTimeout(CompositeVoldemortRequest<K,V> requestWrapper)
          Performs a get operation with the specified composite request object
 

Method parameters in voldemort.coordinator with type arguments of type Versioned
 void HttpGetRequestExecutor.writeResponse(java.util.List<Versioned<byte[]>> versionedValues)
           
 void HttpGetAllRequestExecutor.writeResponse(java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> versionedResponses)
           
 void HttpGetAllRequestExecutor.writeResponseOld(java.util.Map<ByteArray,Versioned<byte[]>> responseVersioned)
           
 

Uses of Versioned in voldemort.serialization
 

Methods in voldemort.serialization that return Versioned
 Versioned<T> VersionedSerializer.toObject(byte[] bytes)
           
 

Methods in voldemort.serialization with parameters of type Versioned
 VoldemortOperation VoldemortOperation.makePutOperation(java.lang.String key, Versioned<byte[]> versioned)
           
 byte[] VersionedSerializer.toBytes(Versioned<T> versioned)
           
 

Uses of Versioned in voldemort.server.protocol.admin
 

Fields in voldemort.server.protocol.admin with type parameters of type Versioned
protected  ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> PartitionScanFetchEntriesRequestHandler.entriesPartitionIterator
           
 

Uses of Versioned in voldemort.server.rest
 

Constructor parameters in voldemort.server.rest with type arguments of type Versioned
GetAllResponseSender(org.jboss.netty.channel.MessageEvent messageEvent, java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> versionedResponses, java.lang.String storeName)
           
GetResponseSender(org.jboss.netty.channel.MessageEvent messageEvent, ByteArray key, java.util.List<Versioned<byte[]>> versionedValues, java.lang.String storeName)
           
 

Uses of Versioned in voldemort.store
 

Methods in voldemort.store that return Versioned
 Versioned<V> CompositeVoldemortRequest.getValue()
           
 

Methods in voldemort.store that return types with arguments of type Versioned
 ClosableIterator<Pair<K,Versioned<V>>> AbstractStorageEngine.entries()
           
 ClosableIterator<Pair<K,Versioned<V>>> StorageEngine.entries()
          Get an iterator over pairs of entries in the store.
 ClosableIterator<Pair<K,Versioned<V>>> AbstractStorageEngine.entries(int partitionId)
           
 ClosableIterator<Pair<K,Versioned<V>>> StorageEngine.entries(int partition)
          Get an iterator over pairs of entries in a store's partition.
static java.util.List<Versioned<byte[]>> StoreBinaryFormat.fromByteArray(byte[] bytes)
           
 java.util.List<Versioned<V>> Store.get(CompositeVoldemortRequest<K,V> request)
          Get the value associated with the given key
 java.util.List<Versioned<V>> DelegatingStore.get(CompositeVoldemortRequest<K,V> request)
           
 java.util.List<Versioned<V>> AbstractStore.get(CompositeVoldemortRequest<K,V> request)
           
 java.util.List<Versioned<V>> Store.get(K key, T transforms)
          Get the value associated with the given key
 java.util.List<Versioned<V>> DelegatingStore.get(K key, T transform)
           
 java.util.List<Versioned<V>> AbstractStore.get(K key, T transforms)
           
static
<K,V,T> java.util.List<Versioned<V>>
StoreUtils.get(Store<K,V,T> storageEngine, K key, T transform)
          Implements get by delegating to getAll.
 java.util.Map<K,java.util.List<Versioned<V>>> Store.getAll(CompositeVoldemortRequest<K,V> request)
          Get the values associated with the given keys and returns them in a Map of keys to a list of versioned values.
 java.util.Map<K,java.util.List<Versioned<V>>> DelegatingStore.getAll(CompositeVoldemortRequest<K,V> request)
           
 java.util.Map<K,java.util.List<Versioned<V>>> AbstractStore.getAll(CompositeVoldemortRequest<K,V> request)
           
 java.util.Map<K,java.util.List<Versioned<V>>> Store.getAll(java.lang.Iterable<K> keys, java.util.Map<K,T> transforms)
          Get the values associated with the given keys and returns them in a Map of keys to a list of versioned values.
 java.util.Map<K,java.util.List<Versioned<V>>> DelegatingStore.getAll(java.lang.Iterable<K> keys, java.util.Map<K,T> transforms)
           
 java.util.Map<K,java.util.List<Versioned<V>>> AbstractStore.getAll(java.lang.Iterable<K> keys, java.util.Map<K,T> transforms)
           
static
<K,V,T> java.util.Map<K,java.util.List<Versioned<V>>>
StoreUtils.getAll(Store<K,V,T> storageEngine, java.lang.Iterable<K> keys, java.util.Map<K,T> transforms)
          Implements getAll by delegating to get.
 java.util.List<Versioned<V>> AbstractStorageEngine.multiVersionPut(K key, java.util.List<Versioned<V>> values)
           
 java.util.List<Versioned<V>> StorageEngine.multiVersionPut(K key, java.util.List<Versioned<V>> values)
          Atomically update storage with the list of versioned values for the given key, to improve storage efficiency.
 Pair<ByteArray,Versioned<byte[]>> PartitionListIterator.next()
           
protected  java.util.List<Versioned<V>> AbstractStorageEngine.resolveAndConstructVersionsToPersist(java.util.List<Versioned<V>> valuesInStorage, java.util.List<Versioned<V>> multiPutValues)
          Computes the final list of versions to be stored, on top of what is currently being stored.
 

Methods in voldemort.store with parameters of type Versioned
 void Store.put(K key, Versioned<V> value, T transforms)
          Associate the value with the key and version in this store
 void DelegatingStore.put(K key, Versioned<V> value, T transform)
           
 void AbstractStore.put(K key, Versioned<V> value, T transforms)
           
 

Method parameters in voldemort.store with type arguments of type Versioned
static
<V> java.util.List<Version>
StoreUtils.getVersions(java.util.List<Versioned<V>> versioneds)
           
 java.util.List<Versioned<V>> AbstractStorageEngine.multiVersionPut(K key, java.util.List<Versioned<V>> values)
           
 java.util.List<Versioned<V>> StorageEngine.multiVersionPut(K key, java.util.List<Versioned<V>> values)
          Atomically update storage with the list of versioned values for the given key, to improve storage efficiency.
protected  java.util.List<Versioned<V>> AbstractStorageEngine.resolveAndConstructVersionsToPersist(java.util.List<Versioned<V>> valuesInStorage, java.util.List<Versioned<V>> multiPutValues)
          Computes the final list of versions to be stored, on top of what is currently being stored.
protected  java.util.List<Versioned<V>> AbstractStorageEngine.resolveAndConstructVersionsToPersist(java.util.List<Versioned<V>> valuesInStorage, java.util.List<Versioned<V>> multiPutValues)
          Computes the final list of versions to be stored, on top of what is currently being stored.
static byte[] StoreBinaryFormat.toByteArray(java.util.List<Versioned<byte[]>> values)
           
 

Constructors in voldemort.store with parameters of type Versioned
CompositeVersionedPutVoldemortRequest(K key, Versioned<V> value, long timeoutInMs)
           
CompositeVersionedPutVoldemortRequest(K key, Versioned<V> value, long timeoutInMs, long originTimeInMs, RequestRoutingType routingType)
           
CompositeVoldemortRequest(K key, V rawValue, java.lang.Iterable<K> keys, Versioned<V> value, Version version, long timeoutInMs, boolean resolveConflicts, byte operationType)
           
CompositeVoldemortRequest(K key, V rawValue, java.lang.Iterable<K> keys, Versioned<V> value, Version version, long timeoutInMs, boolean resolveConflicts, byte operationType, long requestOriginTimeInMs, RequestRoutingType routingType)
           
 

Uses of Versioned in voldemort.store.bdb
 

Methods in voldemort.store.bdb that return types with arguments of type Versioned
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> BdbStorageEngine.entries()
           
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> PartitionPrefixedBdbStorageEngine.entries(int partition)
           
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> BdbStorageEngine.entries(int partition)
           
 java.util.List<Versioned<byte[]>> PartitionPrefixedBdbStorageEngine.get(ByteArray key, byte[] transforms)
           
 java.util.List<Versioned<byte[]>> BdbStorageEngine.get(ByteArray key, byte[] transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> BdbStorageEngine.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 java.util.List<Versioned<byte[]>> PartitionPrefixedBdbStorageEngine.multiVersionPut(ByteArray key, java.util.List<Versioned<byte[]>> values)
           
 java.util.List<Versioned<byte[]>> BdbStorageEngine.multiVersionPut(ByteArray key, java.util.List<Versioned<byte[]>> values)
           
 

Methods in voldemort.store.bdb with parameters of type Versioned
 void PartitionPrefixedBdbStorageEngine.put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
           
 void BdbStorageEngine.put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
           
 

Method parameters in voldemort.store.bdb with type arguments of type Versioned
 java.util.List<Versioned<byte[]>> PartitionPrefixedBdbStorageEngine.multiVersionPut(ByteArray key, java.util.List<Versioned<byte[]>> values)
           
 java.util.List<Versioned<byte[]>> BdbStorageEngine.multiVersionPut(ByteArray key, java.util.List<Versioned<byte[]>> values)
           
 

Uses of Versioned in voldemort.store.compress
 

Methods in voldemort.store.compress that return types with arguments of type Versioned
 java.util.List<Versioned<byte[]>> CompressingStore.get(ByteArray key, byte[] transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> CompressingStore.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 

Methods in voldemort.store.compress with parameters of type Versioned
 void CompressingStore.put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
           
 

Uses of Versioned in voldemort.store.configuration
 

Methods in voldemort.store.configuration that return types with arguments of type Versioned
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> FileBackedCachingStorageEngine.entries()
           
 ClosableIterator<Pair<java.lang.String,Versioned<java.lang.String>>> ConfigurationStorageEngine.entries()
           
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> FileBackedCachingStorageEngine.entries(int partition)
           
 ClosableIterator<Pair<java.lang.String,Versioned<java.lang.String>>> ConfigurationStorageEngine.entries(int partition)
           
 java.util.List<Versioned<byte[]>> FileBackedCachingStorageEngine.get(ByteArray key, byte[] transforms)
           
 java.util.List<Versioned<java.lang.String>> ConfigurationStorageEngine.get(java.lang.String key, java.lang.String transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> FileBackedCachingStorageEngine.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 java.util.Map<java.lang.String,java.util.List<Versioned<java.lang.String>>> ConfigurationStorageEngine.getAll(java.lang.Iterable<java.lang.String> keys, java.util.Map<java.lang.String,java.lang.String> transforms)
           
 

Methods in voldemort.store.configuration with parameters of type Versioned
 void FileBackedCachingStorageEngine.put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
           
 void ConfigurationStorageEngine.put(java.lang.String key, Versioned<java.lang.String> value, java.lang.String transforms)
           
 

Uses of Versioned in voldemort.store.gzip
 

Methods in voldemort.store.gzip that return types with arguments of type Versioned
 java.util.List<Versioned<byte[]>> GzipStore.get(K key, byte[] transforms)
           
 

Methods in voldemort.store.gzip with parameters of type Versioned
 void GzipStore.put(K key, Versioned<byte[]> value, byte[] transforms)
           
 

Uses of Versioned in voldemort.store.http
 

Methods in voldemort.store.http that return types with arguments of type Versioned
 java.util.List<Versioned<byte[]>> HttpStore.get(ByteArray key, byte[] transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> HttpStore.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 

Methods in voldemort.store.http with parameters of type Versioned
 void HttpStore.put(ByteArray key, Versioned<byte[]> versioned, byte[] transforms)
           
 

Uses of Versioned in voldemort.store.invalidmetadata
 

Methods in voldemort.store.invalidmetadata that return types with arguments of type Versioned
 java.util.List<Versioned<byte[]>> InvalidMetadataCheckingStore.get(ByteArray key, byte[] transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> InvalidMetadataCheckingStore.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 

Methods in voldemort.store.invalidmetadata with parameters of type Versioned
 void InvalidMetadataCheckingStore.put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
           
 

Uses of Versioned in voldemort.store.logging
 

Methods in voldemort.store.logging that return types with arguments of type Versioned
 java.util.List<Versioned<V>> LoggingStore.get(CompositeVoldemortRequest<K,V> request)
           
 java.util.List<Versioned<V>> LoggingStore.get(K key, T transform)
           
 

Methods in voldemort.store.logging with parameters of type Versioned
 void LoggingStore.put(K key, Versioned<V> value, T transform)
           
 

Uses of Versioned in voldemort.store.memory
 

Fields in voldemort.store.memory with type parameters of type Versioned
protected  java.util.concurrent.ConcurrentMap<K,java.util.List<Versioned<V>>> InMemoryStorageEngine.map
           
 

Methods in voldemort.store.memory that return types with arguments of type Versioned
 ClosableIterator<Pair<K,Versioned<V>>> InMemoryStorageEngine.entries()
           
 ClosableIterator<Pair<K,Versioned<V>>> InMemoryStorageEngine.entries(int partition)
           
 java.util.List<Versioned<V>> InMemoryStorageEngine.get(K key, T transform)
           
 java.util.Map<K,java.util.List<Versioned<V>>> InMemoryStorageEngine.getAll(java.lang.Iterable<K> keys, java.util.Map<K,T> transforms)
           
 java.util.List<Versioned<V>> InMemoryStorageEngine.multiVersionPut(K key, java.util.List<Versioned<V>> values)
           
 

Methods in voldemort.store.memory with parameters of type Versioned
 void InMemoryStorageEngine.put(K key, Versioned<V> value, T transforms)
           
 

Method parameters in voldemort.store.memory with type arguments of type Versioned
 java.util.List<Versioned<V>> InMemoryStorageEngine.multiVersionPut(K key, java.util.List<Versioned<V>> values)
           
 

Constructor parameters in voldemort.store.memory with type arguments of type Versioned
InMemoryStorageEngine(java.lang.String name, java.util.concurrent.ConcurrentMap<K,java.util.List<Versioned<V>>> map)
           
 

Uses of Versioned in voldemort.store.metadata
 

Methods in voldemort.store.metadata that return types with arguments of type Versioned
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> MetadataStore.entries()
           
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> MetadataStore.entries(int partition)
           
 java.util.List<Versioned<byte[]>> MetadataStore.get(ByteArray keyBytes, byte[] transforms)
           
 java.util.List<Versioned<byte[]>> MetadataStore.get(java.lang.String key, java.lang.String transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> MetadataStore.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 

Methods in voldemort.store.metadata with parameters of type Versioned
 void MetadataStore.put(ByteArray keyBytes, Versioned<byte[]> valueBytes, byte[] transforms)
          A write through put to inner-store.
 void MetadataStore.put(java.lang.String key, Versioned<java.lang.Object> value)
          helper function to convert strings to bytes as needed.
 

Uses of Versioned in voldemort.store.mysql
 

Methods in voldemort.store.mysql that return types with arguments of type Versioned
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> MysqlStorageEngine.entries()
           
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> MysqlStorageEngine.entries(int partition)
           
 java.util.List<Versioned<byte[]>> MysqlStorageEngine.get(ByteArray key, byte[] transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> MysqlStorageEngine.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 

Methods in voldemort.store.mysql with parameters of type Versioned
 void MysqlStorageEngine.put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
           
 

Uses of Versioned in voldemort.store.nonblockingstore
 

Methods in voldemort.store.nonblockingstore with parameters of type Versioned
 void ThreadPoolBasedNonblockingStoreImpl.submitPutRequest(ByteArray key, Versioned<byte[]> value, byte[] transforms, NonblockingStoreCallback callback, long timeoutMs)
           
 void NonblockingStore.submitPutRequest(ByteArray key, Versioned<byte[]> value, byte[] transforms, NonblockingStoreCallback callback, long timeoutMs)
           
 

Uses of Versioned in voldemort.store.readonly
 

Methods in voldemort.store.readonly that return types with arguments of type Versioned
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> ReadOnlyStorageEngine.entries()
           
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> ReadOnlyStorageEngine.entries(int partition)
           
 java.util.List<Versioned<byte[]>> ReadOnlyStorageEngine.get(ByteArray key, byte[] transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> ReadOnlyStorageEngine.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 

Methods in voldemort.store.readonly with parameters of type Versioned
 void ReadOnlyStorageEngine.put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
          Not supported, throws UnsupportedOperationException if called
 

Uses of Versioned in voldemort.store.readonly.chunk
 

Methods in voldemort.store.readonly.chunk that return types with arguments of type Versioned
 Pair<ByteArray,Versioned<byte[]>> ChunkedFileSet.ROEntriesIterator.next()
           
 

Uses of Versioned in voldemort.store.rebalancing
 

Methods in voldemort.store.rebalancing that return types with arguments of type Versioned
 java.util.List<Versioned<byte[]>> RebootstrappingStore.get(ByteArray key, byte[] transforms)
           
 java.util.List<Versioned<byte[]>> RedirectingStore.get(ByteArray key, byte[] transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> RebootstrappingStore.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> RedirectingStore.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 

Methods in voldemort.store.rebalancing with parameters of type Versioned
 void RebootstrappingStore.put(ByteArray key, Versioned<byte[]> versioned, byte[] transforms)
           
 void RedirectingStore.put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
           
 

Uses of Versioned in voldemort.store.retention
 

Methods in voldemort.store.retention that return types with arguments of type Versioned
 java.util.List<Versioned<byte[]>> RetentionEnforcingStore.get(ByteArray key, byte[] transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> RetentionEnforcingStore.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 

Uses of Versioned in voldemort.store.routed
 

Methods in voldemort.store.routed that return Versioned
 Versioned<V> NodeValue.getVersioned()
           
 Versioned<byte[]> PutPipelineData.getVersionedCopy()
          Returns the copy of the Versioned as determined by PerformSerialPutRequests.
 

Methods in voldemort.store.routed that return types with arguments of type Versioned
 java.util.List<Versioned<byte[]>> PipelineRoutedStore.get(ByteArray key, byte[] transforms)
           
 java.util.List<Versioned<byte[]>> ThreadPoolRoutedStore.get(ByteArray key, byte[] transforms)
          Deprecated.  
 java.util.List<Versioned<byte[]>> PipelineRoutedStore.get(ByteArray key, byte[] transforms, long getOpTimeout)
           
 java.util.List<Versioned<byte[]>> PipelineRoutedStore.get(CompositeVoldemortRequest<ByteArray,byte[]> request)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> PipelineRoutedStore.getAll(CompositeVoldemortRequest<ByteArray,byte[]> request)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> PipelineRoutedStore.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> ThreadPoolRoutedStore.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
          Deprecated.  
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> PipelineRoutedStore.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms, long getAllOpTimeoutInMs)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> GetAllPipelineData.getResult()
           
 

Methods in voldemort.store.routed with parameters of type Versioned
 void PipelineRoutedStore.put(ByteArray key, Versioned<byte[]> versioned, byte[] transforms)
           
 void ThreadPoolRoutedStore.put(ByteArray key, Versioned<byte[]> versioned, byte[] transforms)
          Deprecated.  
 void PipelineRoutedStore.put(ByteArray key, Versioned<byte[]> versioned, byte[] transforms, long putOpTimeoutInMs)
           
 void PutPipelineData.setVersionedCopy(Versioned<byte[]> versionedCopy)
          The copy of the Versioned instance that was incremented before attempting to put on the remote Voldemort node.
 

Constructors in voldemort.store.routed with parameters of type Versioned
NodeValue(int nodeId, K key, Versioned<V> value)
           
 

Uses of Versioned in voldemort.store.routed.action
 

Classes in voldemort.store.routed.action with type parameters of type Versioned
 class ReadRepair<PD extends BasicPipelineData<java.util.List<Versioned<byte[]>>>>
           
 

Method parameters in voldemort.store.routed.action with type arguments of type Versioned
protected  void AbstractReadRepair.insertNodeValue(Node node, ByteArray key, java.util.List<Versioned<byte[]>> value)
           
 

Constructors in voldemort.store.routed.action with parameters of type Versioned
IncrementClock(PutPipelineData pipelineData, Pipeline.Event completeEvent, Versioned<byte[]> versioned, Time time)
           
PerformPutHintedHandoff(PutPipelineData pipelineData, Pipeline.Event completeEvent, ByteArray key, Versioned<byte[]> versioned, byte[] transforms, HintedHandoff hintedHandoff, Time time)
           
PerformSerialPutRequests(PutPipelineData pipelineData, Pipeline.Event completeEvent, ByteArray key, byte[] transforms, FailureDetector failureDetector, java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores, int required, Versioned<byte[]> versioned, Time time, Pipeline.Event masterDeterminedEvent)
           
 

Uses of Versioned in voldemort.store.serialized
 

Methods in voldemort.store.serialized that return types with arguments of type Versioned
 ClosableIterator<Pair<K,Versioned<V>>> SerializingStorageEngine.entries()
           
 ClosableIterator<Pair<K,Versioned<V>>> SerializingStorageEngine.entries(int partition)
           
 java.util.List<Versioned<V>> SerializingStore.get(K key, T transforms)
           
 java.util.Map<K,java.util.List<Versioned<V>>> SerializingStore.getAll(java.lang.Iterable<K> keys, java.util.Map<K,T> transforms)
           
 java.util.List<Versioned<V>> SerializingStorageEngine.multiVersionPut(K key, java.util.List<Versioned<V>> values)
           
 

Methods in voldemort.store.serialized with parameters of type Versioned
 void SerializingStore.put(K key, Versioned<V> value, T transforms)
           
 

Method parameters in voldemort.store.serialized with type arguments of type Versioned
 java.util.List<Versioned<V>> SerializingStorageEngine.multiVersionPut(K key, java.util.List<Versioned<V>> values)
           
 

Uses of Versioned in voldemort.store.slop
 

Methods in voldemort.store.slop that return types with arguments of type Versioned
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> SlopStorageEngine.entries()
           
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> SlopStorageEngine.entries(int partition)
           
 java.util.List<Versioned<byte[]>> SlopStorageEngine.get(ByteArray key, byte[] transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> SlopStorageEngine.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 

Methods in voldemort.store.slop with parameters of type Versioned
 void SlopStorageEngine.put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
           
 

Uses of Versioned in voldemort.store.socket
 

Methods in voldemort.store.socket that return types with arguments of type Versioned
 java.util.List<Versioned<byte[]>> SocketStore.get(ByteArray key, byte[] transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> SocketStore.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 

Methods in voldemort.store.socket with parameters of type Versioned
 void SocketStore.put(ByteArray key, Versioned<byte[]> versioned, byte[] transforms)
           
 void SocketStore.submitPutRequest(ByteArray key, Versioned<byte[]> value, byte[] transforms, NonblockingStoreCallback callback, long timeoutMs)
           
 

Uses of Versioned in voldemort.store.socket.clientrequest
 

Methods in voldemort.store.socket.clientrequest that return types with arguments of type Versioned
protected  java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> GetAllClientRequest.parseResponseInternal(java.io.DataInputStream inputStream)
           
protected  java.util.List<Versioned<byte[]>> GetClientRequest.parseResponseInternal(java.io.DataInputStream inputStream)
           
 

Constructors in voldemort.store.socket.clientrequest with parameters of type Versioned
PutClientRequest(java.lang.String storeName, RequestFormat requestFormat, RequestRoutingType requestRoutingType, ByteArray key, Versioned<byte[]> versioned, byte[] transforms)
           
 

Uses of Versioned in voldemort.store.stats
 

Methods in voldemort.store.stats that return types with arguments of type Versioned
 java.util.List<Versioned<byte[]>> StatTrackingStore.get(ByteArray key, byte[] transforms)
           
 java.util.List<Versioned<byte[]>> StatTrackingStore.get(CompositeVoldemortRequest<ByteArray,byte[]> request)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> StatTrackingStore.getAll(CompositeVoldemortRequest<ByteArray,byte[]> request)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> StatTrackingStore.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 

Methods in voldemort.store.stats with parameters of type Versioned
 void StatTrackingStore.put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
           
 

Uses of Versioned in voldemort.store.versioned
 

Methods in voldemort.store.versioned that return types with arguments of type Versioned
 java.util.List<Versioned<V>> InconsistencyResolvingStore.get(CompositeVoldemortRequest<K,V> request)
           
 java.util.List<Versioned<V>> InconsistencyResolvingStore.get(K key, T transforms)
           
 java.util.Map<K,java.util.List<Versioned<V>>> InconsistencyResolvingStore.getAll(CompositeVoldemortRequest<K,V> request)
           
 java.util.Map<K,java.util.List<Versioned<V>>> InconsistencyResolvingStore.getAll(java.lang.Iterable<K> keys, java.util.Map<K,T> transforms)
           
 

Methods in voldemort.store.versioned with parameters of type Versioned
 void VersionIncrementingStore.put(K key, Versioned<V> value, T transforms)
           
 

Constructor parameters in voldemort.store.versioned with type arguments of type Versioned
InconsistencyResolvingStore(Store<K,V,T> innerStore, InconsistencyResolver<Versioned<V>> resolver)
           
 

Uses of Versioned in voldemort.store.views
 

Methods in voldemort.store.views that return types with arguments of type Versioned
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> ViewStorageEngine.entries()
           
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> ViewStorageEngine.entries(int partition)
           
 java.util.List<Versioned<byte[]>> ViewStorageEngine.get(ByteArray key, byte[] transforms)
           
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> ViewStorageEngine.getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
           
 

Methods in voldemort.store.views with parameters of type Versioned
 void ViewStorageEngine.put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
           
 

Uses of Versioned in voldemort.utils
 

Methods in voldemort.utils with parameters of type Versioned
 void ConsistencyCheck.recordFetch(ConsistencyCheck.ClusterNode clusterNode, ByteArray key, Versioned<byte[]> versioned)
           
 

Constructors in voldemort.utils with parameters of type Versioned
ConsistencyCheck.HashedValue(Versioned<byte[]> versioned)
           
 

Uses of Versioned in voldemort.versioning
 

Methods in voldemort.versioning that return Versioned
 Versioned<T> Versioned.cloneVersioned()
          Create a clone of this Versioned object such that the object pointed to is the same, but the VectorClock and Versioned wrapper is a shallow copy.
static
<S> Versioned<S>
Versioned.value(S s)
           
static
<S> Versioned<S>
Versioned.value(S s, Version v)
           
 

Methods in voldemort.versioning that return types with arguments of type Versioned
 java.util.List<Versioned<T>> VectorClockInconsistencyResolver.resolveConflicts(java.util.List<Versioned<T>> items)
           
 java.util.List<Versioned<T>> TimeBasedInconsistencyResolver.resolveConflicts(java.util.List<Versioned<T>> items)
           
 java.util.List<Versioned<T>> MergingInconsistencyResolver.resolveConflicts(java.util.List<Versioned<T>> items)
           
 

Methods in voldemort.versioning with parameters of type Versioned
 int Versioned.HappenedBeforeComparator.compare(Versioned<S> v1, Versioned<S> v2)
           
 int Versioned.HappenedBeforeComparator.compare(Versioned<S> v1, Versioned<S> v2)
           
 

Method parameters in voldemort.versioning with type arguments of type Versioned
 java.util.List<Versioned<T>> VectorClockInconsistencyResolver.resolveConflicts(java.util.List<Versioned<T>> items)
           
 java.util.List<Versioned<T>> TimeBasedInconsistencyResolver.resolveConflicts(java.util.List<Versioned<T>> items)
           
 java.util.List<Versioned<T>> MergingInconsistencyResolver.resolveConflicts(java.util.List<Versioned<T>> items)
           
 



Jay Kreps, Roshan Sumbaly, Alex Feinberg, Bhupesh Bansal, Lei Gao, Chinmay Soman, Vinoth Chandar, Zhongjie Wu