Javers (javers-core 1.3.20 API)

```
public interface Javers
```
Facade to JaVers instance.
Should be constructed by JaversBuilder provided with your domain model configuration.

For example, to deeply compare two objects or two arbitrary complex graphs of objects, call:
```
 Javers javers = JaversBuilder.javers().build();
 Diff diff = javers.compare(oldVersion, currentVersion);
 
```
See Also:

http://javers.org/documentation

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`Commit`	`commit(java.lang.String author, java.lang.Object currentVersion)` Persists a current state of a given domain object graph in JaVers repository.
`Commit`	`commitShallowDelete(java.lang.String author, java.lang.Object deleted)` Marks given object as deleted.
`Commit`	`commitShallowDeleteById(java.lang.String author, GlobalIdDTO globalId)` The same like `commitShallowDelete(String,Object)` but deleted object is selected using globalId
`Diff`	`compare(java.lang.Object oldVersion, java.lang.Object currentVersion)` Deep compare JaVers core function, deeply compares two arbitrary complex object graphs.
`<T> Diff`	`compareCollections(java.util.Collection<T> oldVersion, java.util.Collection<T> currentVersion, java.lang.Class<T> itemClass)` Deeply compares two collections.
`java.util.List<Change>`	`findChanges(JqlQuery query)` Queries JaversRepository for changes history (diff sequence) of given class, object or property.
`java.util.List<CdoSnapshot>`	`findSnapshots(JqlQuery query)` Queries JaversRepository for object Snapshots (historical versions).
`java.util.List<Change>`	`getChangeHistory(GlobalIdDTO globalId, int limit)` Deprecated.
`JsonConverter`	`getJsonConverter()` If you are serializing JaVers objects like `Commit`, `Change`, `Diff` or `CdoSnapshot` to JSON, use this JsonConverter.
`Optional<CdoSnapshot>`	`getLatestSnapshot(GlobalIdDTO globalId)` Deprecated.
`Optional<CdoSnapshot>`	`getLatestSnapshot(java.lang.Object localId, java.lang.Class entityClass)` Latest snapshot of given entity instance or Optional#EMPTY if instance is not versioned.
`java.util.List<CdoSnapshot>`	`getStateHistory(GlobalIdDTO globalId, int limit)` Deprecated.
`<T extends JaversType> T`	`getTypeMapping(java.lang.reflect.Type clientsType)` Use JaversTypes, if you want to: - describe your class in the context of JaVers domain model mapping, - use JaVers Reflection API to conveniently access your object properties (instead of awkward java.lang.reflect API).
`IdBuilder`	`idBuilder()`
`Diff`	`initial(java.lang.Object newDomainObject)` Initial diff is a kind of snapshot of given domain object graph.
`<T> T`	`processChangeList(java.util.List<Change> changes, ChangeProcessor<T> changeProcessor)` Generic purpose method for processing a changes list.
`java.lang.String`	`toJson(Diff diff)` Deprecated.

- Method Detail
  - commit
```
Commit commit(java.lang.String author,
              java.lang.Object currentVersion)
```
    Persists a current state of a given domain object graph in JaVers repository.
    
    JaVers applies commit() to given object and all objects navigable from it. You can capture a state of an arbitrary complex object graph with a single commit() call.
    
    Parameters:
    
    currentVersion - standalone object or handle to an object graph
    
    See Also:
    
    http://javers.org/documentation/repository-examples
  - commitShallowDelete
```
Commit commitShallowDelete(java.lang.String author,
                           java.lang.Object deleted)
```
    Marks given object as deleted.
    
    Unlike commit(String, Object), this method is shallow and affects only given object.
    
    This method doesn't delete anything from JaVers repository. It just persists 'terminal snapshot' of given object.
    
    Parameters:
    
    deleted - object to be marked as deleted
  - commitShallowDeleteById
```
Commit commitShallowDeleteById(java.lang.String author,
                               GlobalIdDTO globalId)
```
    The same like commitShallowDelete(String,Object) but deleted object is selected using globalId
  - compare
```
Diff compare(java.lang.Object oldVersion,
             java.lang.Object currentVersion)
```
    Deep compare
    JaVers core function, deeply compares two arbitrary complex object graphs.
    To calculate a diff, just provide two versions of the same Domain Object (Entity or ValueObject) or handles to two versions of the same object graph.
    The handle could be a root of an Aggregate, tree root or any node in an Domain Object graph from where all other nodes are navigable.
    
    Flat collection compare
    You can also pass object collections here (List, Sets or Maps), but in this case, JaVers calculates flat collection diff only. Because it's impossible to determine type of raw collection items, JaVers maps them as Values and compares using Object.equals(Object).
    So if you need to deep compare, wrap collections in some Value Objects.
    Misc
    compare() function is used for ad-hoc objects comparing. In order to use data auditing feature, call commit(String, Object).
    Diffs can be converted to JSON with toJson(Diff) or pretty-printed with Diff.prettyPrint()
    
    See Also:
    
    http://javers.org/documentation/diff-examples
  - compareCollections
```
<T> Diff compareCollections(java.util.Collection<T> oldVersion,
                            java.util.Collection<T> currentVersion,
                            java.lang.Class<T> itemClass)
```
    Deeply compares two collections.
    
    Introduced due to the lack of possibility to statically determine type of collection items when two collections are passed to compare(Object, Object).
    
    Usage example:
```
 List<Person> oldList = ...
 List<Person> newList = ...
 Diff diff = javers.compareCollections(oldList, newList, Person.class);
 
```
  - initial
```
Diff initial(java.lang.Object newDomainObject)
```
    Initial diff is a kind of snapshot of given domain object graph. Use it alongside with compare(Object, Object)
  - findChanges
```
java.util.List<Change> findChanges(JqlQuery query)
```
    Queries JaversRepository for changes history (diff sequence) of given class, object or property.
    There are various types of changes: ValueChange, ReferenceChange, ListChange, NewObject and so on.
    See Change class hierarchy.
    
    Resulting List is ordered in reverse chronological order.
    
    Querying for Entity changes by instance Id
    
    For example, to get change history of last 5 versions of "bob" Person, call:
```
 javers.findChanges( QueryBuilder.byInstanceId("bob", Person.class).limit(5).build() );
 
```
    Last "salary" changes of "bob" Person:
```
 javers.findChanges( QueryBuilder.byInstanceId("bob", Person.class).andProperty("salary").build() );
 
```
    Querying for ValueObject changes
    
    Last changes on Address ValueObject owned by "bob" Person:
```
 javers.findChanges( QueryBuilder.byValueObjectId("bob", Person.class, "address").build() );
 
```
    Last changes on Address ValueObject owned by any Person:
```
 javers.findChanges( QueryBuilder.byValueObject(Person.class, "address").build() );
 
```
    Querying for any object changes by its class
    
    Last changes on any object of MyClass.class:
```
 javers.findChanges( QueryBuilder.byClass(MyClass.class).build() );
 
```
    Last "myProperty" changes on any object of MyClass.class:
```
 javers.findChanges( QueryBuilder.byClass(Person.class).andProperty("myProperty").build() );
 
```
    Returns:
    
    empty List if nothing found
    
    See Also:
    
    http://javers.org/documentation/jql-examples
  - findSnapshots
```
java.util.List<CdoSnapshot> findSnapshots(JqlQuery query)
```
    Queries JaversRepository for object Snapshots (historical versions).
    Snapshot is a simple Map (property -> value) representation of your domain object.
    
    Resulting List is ordered in reverse chronological order.
    
    For example, to get last 5 snapshots versions of "bob" Person, call:
```
 javers.findSnapshots( QueryBuilder.byInstanceId("bob", Person.class).limit(5).build() );
 
```
    For more query examples, see findChanges(JqlQuery) method. Both methods use Javers Query Language (JQL). So you can use the same query object to get changes and snapshots views.
    Returns:
    
    empty List if nothing found
    
    See Also:
    
    http://javers.org/documentation/jql-examples
  - getLatestSnapshot
```
Optional<CdoSnapshot> getLatestSnapshot(java.lang.Object localId,
                                        java.lang.Class entityClass)
```
    Latest snapshot of given entity instance or Optional#EMPTY if instance is not versioned.
    
    For example, to get last snapshot of "bob" Person, call:
```
 javers.getLatestSnapshot("bob", Person.class));
 
```
  - getJsonConverter
```
JsonConverter getJsonConverter()
```
    If you are serializing JaVers objects like Commit, Change, Diff or CdoSnapshot to JSON, use this JsonConverter.
    
    For example:
```
 javers.getJsonConverter().toJson(changes);
 
```
  - processChangeList
```
<T> T processChangeList(java.util.List<Change> changes,
                        ChangeProcessor<T> changeProcessor)
```
    Generic purpose method for processing a changes list. After iterating over given list, returns data computed by ChangeProcessor.result().
    It's more convenient than iterating over changes on your own. ChangeProcessor frees you from if + inctanceof boilerplate.
    
    Additional features:
    - when several changes in a row refers to the same Commit, ChangeProcessor.onCommit(CommitMetadata) is called only for first occurrence
    - similarly, when several changes in a row affects the same object, ChangeProcessor.onAffectedObject(GlobalId) is called only for first occurrence
    
    For example, to get pretty change log, call:
```
 List<Change> changes = javers.calculateDiffs(...);
 String changeLog = javers.processChangeList(changes, new SimpleTextChangeLog());
 System.out.println( changeLog );
 
```
    See Also:
    
    SimpleTextChangeLog
  - toJson
```
@Deprecated
java.lang.String toJson(Diff diff)
```
    Deprecated.
    use:
```
 javers.getJsonConverter().toJson(diff);
 
```
  - getStateHistory
```
@Deprecated
java.util.List<CdoSnapshot> getStateHistory(GlobalIdDTO globalId,
                                                         int limit)
```
    Deprecated.
    
    use findSnapshots(JqlQuery)
  - getChangeHistory
```
@Deprecated
java.util.List<Change> getChangeHistory(GlobalIdDTO globalId,
                                                     int limit)
```
    Deprecated.
    
    use findChanges(JqlQuery)
  - getLatestSnapshot
```
@Deprecated
Optional<CdoSnapshot> getLatestSnapshot(GlobalIdDTO globalId)
```
    Deprecated.
    
    use getLatestSnapshot(Object, Class)
  - getTypeMapping
```
<T extends JaversType> T getTypeMapping(java.lang.reflect.Type clientsType)
```
    Use JaversTypes, if you want to:
    - describe your class in the context of JaVers domain model mapping,
    - use JaVers Reflection API to conveniently access your object properties (instead of awkward java.lang.reflect API).
    
    Class describe example. You can pretty-print JaversType of your class and check if mapping is correct.
```
 class Person {
     @Id int id;
     @Transient String notImportantField;
     String name;
 }
 
```
    Calling
```
 System.out.println( javers.getTypeMapping(Person.class).prettyPrint() );
 
```
    prints:
```
 EntityType{
   baseType: org.javers.core.examples.Person
   managedProperties:
      Field int id; //declared in: Person
      Field String name; //declared in: Person
   idProperty: login
 }
 
```
    Property access example. You can list object property values using Property abstraction.
```
 Javers javers = JaversBuilder.javers().build();
 ManagedType jType = javers.getTypeMapping(Person.class);
 Person person = new Person("bob", "Uncle Bob");

 System.out.println("Bob's properties:");
 for (Property p : jType.getProperties()){
     Object value = p.get(person);
     System.out.println( "property:" + p.getName() + ", value:" + value );
 }
 
```
    prints:
```
 Bob's properties:
 property:login, value:bob
 property:name, value:Uncle Bob
 
```
  - idBuilder
```
IdBuilder idBuilder()
```

Interface Javers

Method Summary

Method Detail

commit

commitShallowDelete

commitShallowDeleteById

compare

Deep compare

Flat collection compare

Misc

compareCollections

initial

findChanges

findSnapshots

getLatestSnapshot

getJsonConverter

processChangeList

toJson

getStateHistory

getChangeHistory

getLatestSnapshot

getTypeMapping

idBuilder