Package org.projectnessie.versioned.persist.store

Class PersistVersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

java.lang.Object

org.projectnessie.versioned.persist.store.PersistVersionStore<CONTENTS,METADATA,CONTENTS_TYPE>

All Implemented Interfaces:

VersionStore<CONTENTS,METADATA,CONTENTS_TYPE>

public class PersistVersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>
extends Object
implements VersionStore<CONTENTS,METADATA,CONTENTS_TYPE>

Field Summary

Fields

Modifier and Type	Field	Description
protected StoreWorker<CONTENTS,METADATA,CONTENTS_TYPE>	storeWorker

Constructor Summary

Constructors

Constructor	Description
PersistVersionStore(DatabaseAdapter databaseAdapter, StoreWorker<CONTENTS,METADATA,CONTENTS_TYPE> storeWorker)

Method Summary

Modifier and Type	Method	Description
void	assign(NamedRef ref, Optional<Hash> expectedHash, Hash targetHash)
Hash	commit(BranchName branch, Optional<Hash> expectedHead, METADATA metadata, List<Operation<CONTENTS>> operations)
Hash	create(NamedRef ref, Optional<Hash> targetHash)
void	delete(NamedRef ref, Optional<Hash> hash)
Stream<WithHash<METADATA>>	getCommits(Ref ref)
Stream<Diff<CONTENTS>>	getDiffs(Ref from, Ref to)
Stream<WithType<Key,CONTENTS_TYPE>>	getKeys(Ref ref)
Stream<WithHash<NamedRef>>	getNamedRefs()
CONTENTS	getValue(Ref ref, Key key)
List<Optional<CONTENTS>>	getValues(Ref ref, List<Key> keys)
Hash	hashOnReference(NamedRef namedReference, Optional<Hash> hashOnReference)
void	merge(Hash fromHash, BranchName toBranch, Optional<Hash> expectedHash)
Hash	noAncestorHash()
Hash	toHash(NamedRef ref)
WithHash<Ref>	toRef(String refOfUnknownType)
void	transplant(BranchName targetBranch, Optional<Hash> referenceHash, List<Hash> sequenceToTransplant)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

storeWorker

protected final StoreWorker<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>> storeWorker

Constructor Detail

PersistVersionStore

public PersistVersionStore(DatabaseAdapter databaseAdapter,
                           StoreWorker<CONTENTS,METADATA,CONTENTS_TYPE> storeWorker)

Method Detail

hashOnReference

public Hash hashOnReference(NamedRef namedReference,
                            Optional<Hash> hashOnReference)
                     throws ReferenceNotFoundException

Specified by:

hashOnReference in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

noAncestorHash

@Nonnull
public Hash noAncestorHash()

Specified by:

noAncestorHash in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

toHash

@Nonnull
public Hash toHash(@Nonnull
                   NamedRef ref)
            throws ReferenceNotFoundException

Specified by:

toHash in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

toRef

public WithHash<Ref> toRef(@Nonnull
                           String refOfUnknownType)
                    throws ReferenceNotFoundException

Specified by:

toRef in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

commit

public Hash commit(@Nonnull
                   BranchName branch,
                   @Nonnull
                   Optional<Hash> expectedHead,
                   @Nonnull
                   METADATA metadata,
                   @Nonnull
                   List<Operation<CONTENTS>> operations)
            throws ReferenceNotFoundException,
                   ReferenceConflictException

Specified by:

commit in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

ReferenceConflictException

transplant

public void transplant(BranchName targetBranch,
                       Optional<Hash> referenceHash,
                       List<Hash> sequenceToTransplant)
                throws ReferenceNotFoundException,
                       ReferenceConflictException

Specified by:

transplant in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

ReferenceConflictException

merge

public void merge(Hash fromHash,
                  BranchName toBranch,
                  Optional<Hash> expectedHash)
           throws ReferenceNotFoundException,
                  ReferenceConflictException

Specified by:

merge in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

ReferenceConflictException

assign

public void assign(NamedRef ref,
                   Optional<Hash> expectedHash,
                   Hash targetHash)
            throws ReferenceNotFoundException,
                   ReferenceConflictException

Specified by:

assign in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

ReferenceConflictException

create

public Hash create(NamedRef ref,
                   Optional<Hash> targetHash)
            throws ReferenceNotFoundException,
                   ReferenceAlreadyExistsException

Specified by:

create in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

ReferenceAlreadyExistsException

delete

public void delete(NamedRef ref,
                   Optional<Hash> hash)
            throws ReferenceNotFoundException,
                   ReferenceConflictException

Specified by:

delete in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

ReferenceConflictException

getNamedRefs

public Stream<WithHash<NamedRef>> getNamedRefs()

Specified by:

getNamedRefs in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

getCommits

public Stream<WithHash<METADATA>> getCommits(Ref ref)
                                      throws ReferenceNotFoundException

Specified by:

getCommits in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

getKeys

public Stream<WithType<Key,CONTENTS_TYPE>> getKeys(Ref ref)
                                                  throws ReferenceNotFoundException

Specified by:

getKeys in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

getValue

public CONTENTS getValue(Ref ref,
                         Key key)
                  throws ReferenceNotFoundException

Specified by:

getValue in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

getValues

public List<Optional<CONTENTS>> getValues(Ref ref,
                                          List<Key> keys)
                                   throws ReferenceNotFoundException

Specified by:

getValues in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException

getDiffs

public Stream<Diff<CONTENTS>> getDiffs(Ref from,
                                       Ref to)
                                throws ReferenceNotFoundException

Specified by:

getDiffs in interface VersionStore<CONTENTS,METADATA,CONTENTS_TYPE extends Enum<CONTENTS_TYPE>>

Throws:

ReferenceNotFoundException