de.ipcon.db.tools

Class UnlazyUpdateStrategy

java.lang.Object

de.ipcon.db.tools.UnlazyUpdateStrategy

All Implemented Interfaces:

CachingBOLoaderUpdateStrategyI

public class UnlazyUpdateStrategy
extends java.lang.Object
implements CachingBOLoaderUpdateStrategyI

Field Summary

Fields

Modifier and Type	Field and Description
static java.util.Set<java.lang.Class>	DEFAULT_IGNORE_CLASSES_FOR_UPDATING A list of internal classes that should be unmodifiable anyway and can be safely ignored when listening for changes

Fields inherited from interface de.ipcon.db.core.CachingBOLoaderUpdateStrategyI

$0

Constructor Summary

Constructors

Constructor and Description
UnlazyUpdateStrategy(SchemaI schema, java.util.Collection<java.lang.Class> rootClasses, java.util.Collection<java.lang.String> unlazyUpdateInformation, java.util.Set<java.lang.Class> ignoredClassesWhenUpdating)

Method Summary

Modifier and Type	Method and Description
java.util.Map<EntityI,java.util.Set<AttributeI>>	getFullUnlazyMap()
static java.util.Collection<java.lang.String>	getNetwork(BO bo, java.util.Set<java.lang.String> recursionGuard, boolean onlyManyRelations) This method iterates over the provided BO and returns all currently unlazy relations of the accessible network.
SchemaI	getSchema()
java.util.Set<AttributeI>	getUnlazyManyrelations(java.lang.Class clazz)
java.util.Set<AttributeI>	getUnlazyManyrelations(EntityI entity)
java.util.Set	getUpdateableEntities() A list of all entities to keep updated, in this case: All entities that are reachable from the provided roots in theory
boolean	hasUnlazyManyrelations(java.lang.Class clazz)
boolean	hasUnlazyManyrelations(EntityI entity)
boolean	isLoadAnyChangesIntoCache()
boolean	isRelevantRegardingKeepClasses(java.lang.Class aClass) Checks if the provided class is expected to be reachable from the provided roots
boolean	isUnlazy(EntityI entity, AttributeI attr)
void	setSchema(SchemaI schema)

Methods inherited from class java.lang.Object

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

Field Detail

DEFAULT_IGNORE_CLASSES_FOR_UPDATING

public static final java.util.Set<java.lang.Class> DEFAULT_IGNORE_CLASSES_FOR_UPDATING

A list of internal classes that should be unmodifiable anyway and can be safely ignored when listening for changes

Constructor Detail

UnlazyUpdateStrategy

public UnlazyUpdateStrategy(SchemaI schema,
                            java.util.Collection<java.lang.Class> rootClasses,
                            java.util.Collection<java.lang.String> unlazyUpdateInformation,
                            java.util.Set<java.lang.Class> ignoredClassesWhenUpdating)

Method Detail

getUpdateableEntities

public java.util.Set getUpdateableEntities()

A list of all entities to keep updated, in this case: All entities that are reachable from the provided roots in theory

Specified by:

getUpdateableEntities in interface CachingBOLoaderUpdateStrategyI

Returns:

a set of Entities to keep updated.

isRelevantRegardingKeepClasses

public boolean isRelevantRegardingKeepClasses(java.lang.Class aClass)

Checks if the provided class is expected to be reachable from the provided roots

Specified by:

isRelevantRegardingKeepClasses in interface CachingBOLoaderUpdateStrategyI

Returns:

true, if the passed Class is one of classes (or a subclass of one) that will be kept updated. Will only be called on classes defined by getUpdateableEntities

isLoadAnyChangesIntoCache

public boolean isLoadAnyChangesIntoCache()

Specified by:

isLoadAnyChangesIntoCache in interface CachingBOLoaderUpdateStrategyI

Returns:

true if any changed BOs that fit UpdateableEntities and isRelevantRegardingKeepClasses should be loaded into the cache, even if those weren't there before. Those BOs might implicitly update the GC Strategy (FIXME this behaviour could change). Insertion of those loaded BOs can be observed through the CacheListener Interface. false, if only BOs that are already inside the cache should be handled or if they were added to an already unlazied manyrelation of a BO in the cache.

getSchema

public SchemaI getSchema()

setSchema

public void setSchema(SchemaI schema)

getUnlazyManyrelations

public java.util.Set<AttributeI> getUnlazyManyrelations(java.lang.Class clazz)

getUnlazyManyrelations

public java.util.Set<AttributeI> getUnlazyManyrelations(EntityI entity)

isUnlazy

public boolean isUnlazy(EntityI entity,
                        AttributeI attr)

hasUnlazyManyrelations

public boolean hasUnlazyManyrelations(java.lang.Class clazz)

Returns:

true if clazz is not null and has at least one attribute that should get unlazied

hasUnlazyManyrelations

public boolean hasUnlazyManyrelations(EntityI entity)

Returns:

true if entity is not null and has at least one attribute that should get unlazied

getFullUnlazyMap

public java.util.Map<EntityI,java.util.Set<AttributeI>> getFullUnlazyMap()

getNetwork

public static java.util.Collection<java.lang.String> getNetwork(BO bo,
                                                                java.util.Set<java.lang.String> recursionGuard,
                                                                boolean onlyManyRelations)

This method iterates over the provided BO and returns all currently unlazy relations of the accessible network. If onlyManyRelations is set to true, then only unlazy manyrelations will be described, otherwise n-1 relations will be included too. Use this method if you calculate some values and want to check which manyrelations have been unlazied. Usage example:

 //make sure that there aren't unkown unlazies till now.
 final def before = UnlazyUpdateStrategy.getNetwork(bo, null, false)
 def debugClosure = {
    log.info("DebugClosure started, waiting 10 seconds....")
    Thread.sleep(15000)
    log.info("Getting network")
    def after = UnlazyUpdateStrategy.getNetwork(bo, null, false)
    //log.info("\nBEFORE (${before.size()})\n${ before.sort().join('\n') }")
    //log.info("\nAFTER (${after.size()})\n${ after.sort().join('\n') }")
    def delta = (after-before)
    log.info("\nDELTA (${delta.size()})\n${ delta.sort().join('\n') }")
 }
 Executors.newSingleThreadExecutor().execute(debugClosure as Runnable)