BundleService (pl.decerto:hyperon-persistence 1.12.2 API)

All Known Implementing Classes:

BundleServiceImpl
```
public interface BundleService
```
This interface acts as main facade service to work with Hyperon Persistence engine functionality. Before it can be used, it is really important to setup configuration with HyperonPersistenceFactory.

Author:

przemek hertel

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`Bundle`	`create()` Creates bundle for the first time, based on default profile.
`Bundle`	`create(String profile)` Creates bundle for the first time, based on given profile.
`BundleDiff`	`diff(Bundle next)` Compares given bundle with initial version of the same bundle(by id).
`BundleDiff`	`diff(Bundle prev, Bundle next)` Compares two different bundles and stores the result of comparison in `BundleDiff` object.
`GmoCacheManager`	`getCacheManager()` Returns cache manager, that is used within persistence engine as first level cache.
`BundleDef`	`getDefinition(String profile)` Based on given profile, bundle definition will be fetched from current Hyperon Studio environment, to which Hyperon Persistence is connected.
`Bundle`	`load(long id)` Retrieves a bundle based on given id for default profile.
`Bundle`	`load(long id, BundleDef def)` Retrieves a bundle based on given id and bundle definition.
`Bundle`	`load(long id, String profile)` Retrieves a bundle based on given id and profile.
`void`	`persist(Bundle bundle)` Saves bundle in tables using database connection defined with `HyperonPersistenceFactory`.

- Method Detail
  - persist
```
void persist(Bundle bundle)
```
    Saves bundle in tables using database connection defined with HyperonPersistenceFactory.
    There are few cases of persisting bundle and how it will be stored:
    1. if bundle is saved for the first time, it will store root bundle with revision set to 1 and update date to null.
    2. if bundle was already persisted in the past, then same bundle will be updated with incremented revision number and update date will be set to time of saving.
    All inserts, updates and deletes actions will be generated based on bundle and it's definition. Then used by engine, to invoke them on database.
    Parameters:
    
    bundle - to be persisted, can't be null
  - load
```
Bundle load(long id)
```
    Retrieves a bundle based on given id for default profile. Default profile might be setup using HyperonPersistenceFactory.setDefaultProfile(String). Bundle definition will be used from current Hyperon Studio environment, to which Hyperon Persistence is connected. Rest is the same as in load(long, BundleDef). Calling this method multiple times for the same id, will always return new Bundle instance.
    Example:
```
	BundleService service = ..;
	Bundle firstBundle = service.load(12);
	Bundle secondBundle = service.load(12);

	firstBundle != secondBundle;  // true
	Objects.equals(firstBundle, secondBundle); // true
 
```
    Parameters:
    
    id - bundle id to load
    
    Returns:
    
    loaded bundle instance
    
    Throws:
    
    HyperonPersistenceException - if there was no bundle definition for default profile
    
    See Also:
    
    load(long, BundleDef), load(long, String)
  - load
```
Bundle load(long id,
            BundleDef def)
```
    Retrieves a bundle based on given id and bundle definition. This definition is used to:
    - find root table name. If table name is not defined in bundle definition, then default table name is used: bundle.
    - fetching bundle from database, based on bundle definition.
    Calling this method multiple times for the same id, will always return new Bundle instance.
    Example:
```
	BundleService service = ..;
	Bundle firstBundle = service.load(12);
	Bundle secondBundle = service.load(12);

	firstBundle != secondBundle;  // true
	Objects.equals(firstBundle, secondBundle); // true
 
```
    Parameters:
    
    id - bundle id to load
    
    def - bundle definition, can't be null
    
    Returns:
    
    loaded bundle instance
    
    See Also:
    
    DaoConfig.setBundleTable(String), Bundle.deepcopy(), load(long), load(long, String)
  - load
```
Bundle load(long id,
            String profile)
```
    Retrieves a bundle based on given id and profile. Based on profile, bundle definition will be fetched from current Hyperon Studio environment, to which Hyperon Persistence is connected. Rest is the same as in load(long, BundleDef). Calling this method multiple times for the same id, will always return new Bundle instance.
    Example:
```
 	BundleService service = ..;
 	Bundle firstBundle = service.load(12);
	Bundle secondBundle = service.load(12);

	firstBundle != secondBundle;  // true
	Objects.equals(firstBundle, secondBundle); // true
 
```
    Parameters:
    
    id - id bundle id to load
    
    profile - allows to get current domain definition
    
    Returns:
    
    loaded bundle instance
    
    Throws:
    
    HyperonPersistenceException - if there was no bundle definition for default profile
    
    See Also:
    
    load(long), load(long, BundleDef)
  - getDefinition
```
BundleDef getDefinition(String profile)
```
    Based on given profile, bundle definition will be fetched from current Hyperon Studio environment, to which Hyperon Persistence is connected.
    
    Parameters:
    
    profile - allows to get current domain definition
    
    Returns:
    
    loaded bundle definition
    
    Throws:
    
    HyperonPersistenceException - if there was no bundle definition for default profile
    
    See Also:
    
    BundleDef
  - create
```
Bundle create()
```
    Creates bundle for the first time, based on default profile. There must be bundle definition on Hyperon Studio environment, to which persistence engine is connected. Calling this multiple times, each time this will create new bundle instance.
    
    Returns:
    
    new bundle instance
    
    Throws:
    
    HyperonPersistenceException - if there was no bundle definition for default profile
    
    See Also:
    
    DaoConfig.setBundleTable(String)
  - create
```
Bundle create(String profile)
```
    Creates bundle for the first time, based on given profile. There must be profile and bundle definition on Hyperon Studio environment, to which persistence engine is connected. Calling this multiple times, each time this will create new bundle instance.
    
    Parameters:
    
    profile - allows to get current domain definition
    
    Returns:
    
    new bundle instance
    
    Throws:
    
    HyperonPersistenceException - if there was no bundle definition for default profile
    
    See Also:
    
    - for default table name
  - getCacheManager
```
GmoCacheManager getCacheManager()
```
    Returns cache manager, that is used within persistence engine as first level cache. It stores information about bundles and bundles definitions. This manager is exposed for custom management control of caches - for more advanced and complicated cases. It allows also to invalidate exposed caches.
    For most cases, there shouldn't be need to use this directly at all.
    
    Returns:
    
    instance of cache manager
  - diff
```
BundleDiff diff(Bundle prev,
                Bundle next)
```
    Compares two different bundles and stores the result of comparison in BundleDiff object. The result will be in form of separated collections of: elements to insert, to update, to delete.
    Example:
```
  BundleService service = ..;

  Bundle firstBundle = service.load(11);
  Bundle secondBundle = service.load(22);

  BundleDiff result = service.diff(firstBundle, secondBundle); // difference between these two bundles

  --------------
  Bundle firstBundle = service.load(33);
  Bundle secondBundle = service.load(33);

  BundleDiff result = service.diff(firstBundle, secondBundle); // same bundles, then no differences should be there
 
```
    Parameters:
    
    prev - first bundle, not null
    
    next - second bundle, not null
    
    Returns:
    
    difference between prev and next bundle
    
    See Also:
    
    BundleDiff
  - diff
```
BundleDiff diff(Bundle next)
```
    Compares given bundle with initial version of the same bundle(by id). Initial version means that it looks for bundle (with the same id) in:
    - cache - if found, then it is used for comparision
    - database - gets object, stores it in cache for later usage and uses it for comparision
    Result of comparison is stored in BundleDiff object. It will be in form of separated collections of: elements to insert, to update, to delete. Example:
```
  BundleService service = ..;

  Bundle bundle = service.load(12);
  bundle.get("policy").remove("product");

  BundleDiff result = service.diff(bundle); // there will be information about deleted product from policy
 
```
    This method doesn't look for previous versions of provided bundle!
    Parameters:
    
    next - bundle, not null
    
    Returns:
    
    difference between given bundle and previous version of this bundle
    
    See Also:
    
    BundleDiff

Interface BundleService

Method Summary

Method Detail

persist

load

load

load

getDefinition

create

create

getCacheManager

diff

diff