Config4Impl

java.lang.Object
- com.db4o.internal.Config4Impl

All Implemented Interfaces:: ClientServerConfiguration, Configuration, FreespaceConfiguration, QueryConfiguration, DeepClone, MessageSender

public final class Config4Impl
extends java.lang.Object
implements Configuration, DeepClone, MessageSender, FreespaceConfiguration, QueryConfiguration, ClientServerConfiguration

Configuration template for creating new db4o files

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Config4Impl.ConfigDeepCloneContext

Nested Classes
Modifier and Type	Class and Description
`static class`	`Config4Impl.ConfigDeepCloneContext`

Field Summary

Fields
Modifier and Type Field and Description

static int PREFETCH_SLOT_CACHE_SIZE_FACTOR

Fields
Modifier and Type	Field and Description
`static int`	`PREFETCH_SLOT_CACHE_SIZE_FACTOR`

Constructor Summary

Constructors
Constructor and Description

Config4Impl()

Constructors
Constructor and Description
`Config4Impl()`

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`activationDepth()` gets the configured activation depth.
`void`	`activationDepth(int depth)` sets the activation depth to the specified value.
`ActivationDepthProvider`	`activationDepthProvider()`
`void`	`activationDepthProvider(ActivationDepthProvider provider)`
`void`	`add(ConfigurationItem item)` adds ConfigurationItems to be applied when an ObjectContainer or ObjectServer is opened.
`void`	`addAlias(Alias alias)` adds a new Alias for a class, namespace or package.
`boolean`	`allowVersionUpdates()`
`void`	`allowVersionUpdates(boolean flag)` turns automatic database file format version updates on.
`void`	`applyConfigurationItems(InternalObjectContainer container)`
`static void`	`assertIsNotTainted(Configuration config)`
`boolean`	`asynchronousSync()`
`void`	`asynchronousSync(boolean flag)`
`boolean`	`automaticShutDown()`
`void`	`automaticShutDown(boolean flag)` turns automatic shutdown of the engine on and off.
`boolean`	`batchMessages()`
`void`	`batchMessages(boolean flag)` Configures to batch messages between client and server.
`java.lang.String`	`blobPath()`
`byte`	`blockSize()`
`void`	`blockSize(int bytes)` sets the storage data blocksize for new ObjectContainers.
`void`	`bTreeCacheHeight(int height)` configures caching of BTree nodes.
`int`	`bTreeNodeSize()`
`void`	`bTreeNodeSize(int size)` configures the size of BTree nodes in indexes.
`CacheConfiguration`	`cache()` returns the Cache configuration interface.
`CallBackMode`	`callbackMode()`
`void`	`callbackMode(CallBackMode mode)`
`void`	`callbacks(boolean turnOn)` turns callback methods on and off.
`TernaryBool`	`callConstructors()`
`void`	`callConstructors(boolean flag)` advises db4o to try instantiating objects with/without calling constructors.
`void`	`classActivationDepthConfigurable(boolean turnOn)` turns `individual class activation depth configuration` on and off.
`ClientServerConfiguration`	`clientServer()` returns client/server configuration interface.
`LegacyClientServerFactory`	`clientServerFactory()`
`boolean`	`commitRecoveryDisabled()`
`Config4Class`	`configClass(java.lang.String className)`
`Iterator4`	`configurationItemsIterator()` Returns an iterator for all `ConfigurationItem` instances added.
`void`	`container(ObjectContainerBase container)`
`IdSystemFactory`	`customIdSystemFactory()`
`int`	`databaseGrowthSize()`
`void`	`databaseGrowthSize(int bytes)` configures the size database files should grow in bytes, when no free slot is found within.
`java.lang.Object`	`deepClone(java.lang.Object param)` The parameter allows passing one new object so parent references can be corrected on children.
`boolean`	`detectSchemaChanges()`
`void`	`detectSchemaChanges(boolean flag)` tuning feature: configures whether db4o checks all persistent classes upon system startup, for added or removed fields.
`DiagnosticConfiguration`	`diagnostic()` returns the configuration interface for diagnostics.
`DiagnosticProcessor`	`diagnosticProcessor()`
`void`	`disableCommitRecovery()` turns commit recovery off.
`int`	`discardFreeSpace()`
`void`	`discardSmallerThan(int byteCount)` tuning feature: configures the minimum size of free space slots in the database file that are to be reused.
`void`	`encrypt(boolean flag)` Deprecated.
`java.util.List`	`environmentContributions()`
`QueryEvaluationMode`	`evaluationMode()`
`void`	`evaluationMode(QueryEvaluationMode mode)` configures the query processor evaluation mode.
`Hashtable4`	`exceptionalClasses()`
`boolean`	`exceptionsOnNotStorable()`
`void`	`exceptionsOnNotStorable(boolean flag)` configures whether Exceptions are to be thrown, if objects can not be stored.
`void`	`factory(LegacyClientServerFactory factory)`
`boolean`	`fileBasedTransactionLog()`
`void`	`fileBasedTransactionLog(boolean flag)`
`FreespaceConfiguration`	`freespace()` returns the freespace configuration interface.
`FreespaceFiller`	`freespaceFiller()`
`void`	`freespaceFiller(FreespaceFiller freespaceFiller)` Configure a way to overwrite freed space in the database file with custom (for example: random) bytes.
`TernaryBool`	`generateCommitTimestamps()`
`void`	`generateCommitTimestamps(boolean flag)` Configures db4o to generate commit timestamps for all stored objects. All the objects commited within a transaction will share the same commit timestamp.
`ConfigScope`	`generateUUIDs()`
`void`	`generateUUIDs(ConfigScope scope)` configures db4o to generate UUIDs for stored objects.
`void`	`generateVersionNumbers(ConfigScope scope)` Deprecated.
`MessageSender`	`getMessageSender()` returns the MessageSender for this Configuration context.
`byte`	`idSystemType()`
`boolean`	`internStrings()` returns true if strings will be interned.
`void`	`internStrings(boolean doIntern)` configures db4o to call #intern() on strings upon retrieval.
`IoAdapter`	`io()` returns the configured `IoAdapter`.
`void`	`io(IoAdapter adapter)` allows to configure db4o to use a customized byte IO adapter.
`boolean`	`isReadOnly()`
`void`	`lockDatabaseFile(boolean flag)` can be used to turn the database file locking thread off.
`boolean`	`lockFile()`
`void`	`markTransient(java.lang.String marker)` allows to mark fields as transient with custom attributes.
`int`	`maxBatchQueueSize()`
`void`	`maxBatchQueueSize(int maxSize)` Configures the maximum memory buffer size for batched message.
`int`	`maxStackDepth()`
`void`	`maxStackDepth(int maxStackDepth)`
`int`	`messageLevel()`
`void`	`messageLevel(int level)` sets the detail level of db4o messages.
`MessageRecipient`	`messageRecipient()`
`NameProvider`	`nameProvider()`
`void`	`nameProvider(NameProvider provider)`
`ObjectClass`	`objectClass(java.lang.Object clazz)` returns an `ObjectClass` object to configure the specified class.
`boolean`	`optimizeNativeQueries()` indicates whether Native Queries will be optimized dynamically.
`void`	`optimizeNativeQueries(boolean optimizeNQ)` If set to true, db4o will try to optimize native queries dynamically at query execution time, otherwise it will run native queries in unoptimized mode as SODA evaluations.
`java.io.PrintStream`	`outStream()`
`void`	`password(java.lang.String pw)` Deprecated.
`int`	`prefetchDepth()`
`void`	`prefetchDepth(int prefetchDepth)` Sets the depth to which prefetched objects are activated.
`int`	`prefetchIDCount()`
`void`	`prefetchIDCount(int prefetchIDCount)` Sets the number of IDs to be pre-allocated in the database for new objects created on the client.
`int`	`prefetchObjectCount()`
`void`	`prefetchObjectCount(int prefetchObjectCount)` Sets the number of objects to be prefetched for an ObjectSet.
`Event4<EventArgs>`	`prefetchSettingsChanged()`
`int`	`prefetchSlotCacheSize()`
`void`	`prefetchSlotCacheSize(int slotCacheSize)` Sets the slot cache size to the given value.
`QueryConfiguration`	`queries()` returns the Query configuration interface.
`QueryResultIteratorFactory`	`queryResultIteratorFactory()`
`void`	`queryResultIteratorFactory(QueryResultIteratorFactory factory)`
`Hashtable4`	`readAs()`
`void`	`readOnly(boolean flag)` turns readOnly mode on and off.
`boolean`	`recoveryMode()`
`void`	`recoveryMode(boolean flag)` turns recovery mode on and off. Recovery mode can be used to try to retrieve as much as possible out of an already corrupted database.
`ReferenceSystemFactory`	`referenceSystemFactory()`
`void`	`referenceSystemFactory(ReferenceSystemFactory referenceSystemFactory)`
`GenericReflector`	`reflector()`
`void`	`reflectWith(Reflector reflect)` configures the use of a specially designed reflection implementation.
`void`	`refreshClasses()`
`void`	`registerTypeHandler(TypeHandlerPredicate predicate, TypeHandler4 typeHandler)` allows registering special TypeHandlers for customized marshalling and customized comparisons.
`void`	`removeAlias(Alias alias)` Removes an alias previously added with `Configuration.addAlias(Alias)`.
`int`	`reservedStorageSpace()`
`void`	`reserveStorageSpace(long byteCount)` tuning feature only: reserves a number of bytes in database files.
`java.lang.String`	`resolveAliasRuntimeName(java.lang.String runtimeType)`
`java.lang.String`	`resolveAliasStoredName(java.lang.String storedType)`
`void`	`send(java.lang.Object obj)` The ConfigImpl also is our messageSender
`void`	`setBlobPath(java.lang.String path)` configures the path to be used to store and read Blob data.
`void`	`setMessageRecipient(MessageRecipient messageRecipient)` sets the MessageRecipient to receive Client Server messages.
`void`	`setOut(java.io.PrintStream outStream)` Deprecated.
`boolean`	`singleThreadedClient()`
`void`	`singleThreadedClient(boolean flag)` configures the client messaging system to be single threaded or multithreaded.
`Storage`	`storage()` returns the configured `Storage`
`void`	`storage(Storage factory)` allows to configure db4o to use a customized byte IO storage mechanism.
`StringEncoding`	`stringEncoding()`
`void`	`stringEncoding(StringEncoding encoding)` configures the string encoding to be used.
`void`	`taint()`
`boolean`	`testConstructors()`
`void`	`testConstructors(boolean flag)` tuning feature: configures whether db4o should try to instantiate one instance of each persistent class on system startup.
`int`	`timeoutClientSocket()`
`void`	`timeoutClientSocket(int milliseconds)` configures the time a client waits for a message response from the server.
`int`	`timeoutServerSocket()`
`void`	`timeoutServerSocket(int milliseconds)` configures the timeout of the serverside socket.
`TypeHandler4`	`typeHandlerForClass(ReflectClass classReflector, byte handlerVersion)`
`int`	`updateDepth()`
`void`	`updateDepth(int depth)` specifies the global updateDepth.
`UpdateDepthProvider`	`updateDepthProvider()`
`void`	`updateDepthProvider(UpdateDepthProvider provider)`
`void`	`useBTreeSystem()` configures db4o to use a BTree-based freespace system.
`void`	`useCustomIdSystem(IdSystemFactory factory)`
`void`	`useIndexSystem()` Deprecated.
`void`	`useInMemoryIdSystem()`
`void`	`usePointerBasedIdSystem()`
`void`	`useRamSystem()` configures db4o to use a RAM-based freespace system.
`void`	`useSingleBTreeIdSystem()`
`void`	`useStackedBTreeIdSystem()`
`int`	`weakReferenceCollectionInterval()`
`void`	`weakReferenceCollectionInterval(int milliseconds)` configures the timer for WeakReference collection.
`boolean`	`weakReferences()`
`void`	`weakReferences(boolean flag)` turns weak reference management on or off.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - PREFETCH_SLOT_CACHE_SIZE_FACTOR
```
public static final int PREFETCH_SLOT_CACHE_SIZE_FACTOR
```
    See Also:
    Constant Field Values
- Constructor Detail
  - Config4Impl
```
public Config4Impl()
```
- Method Detail
  - activationDepth
```
public int activationDepth()
```
    Description copied from interface: Configuration
    
    gets the configured activation depth.
    
    Specified by:
    
    activationDepth in interface Configuration
    
    Returns:
    the configured activation depth.
  - activationDepth
```
public void activationDepth(int depth)
```
    Description copied from interface: Configuration
    sets the activation depth to the specified value.
    
    Why activation?
    When objects are instantiated from the database, the instantiation of member objects needs to be limited to a certain depth. Otherwise a single object could lead to loading the complete database into memory, if all objects where reachable from a single root object.
    
    db4o uses the concept "depth", the number of field-to-field hops an object is away from another object. The preconfigured "activation depth" db4o uses in the default setting is 5.
    
    Whenever an application iterates through the ObjectSet of a query result, the result objects will be activated to the configured activation depth.
    
    A concrete example with the preconfigured activation depth of 5:
```
 // Object foo is the result of a query, it is delivered by the ObjectSet 
 Object foo = objectSet.next();
```
    foo.member1.member2.member3.member4.member5 will be a valid object
    foo, member1, member2, member3 and member4 will be activated
    member5 will be deactivated, all of it's members will be null
    member5 can be activated at any time by calling ObjectContainer.activate(Object, int).
    
    Note that raising the global activation depth will consume more memory and have negative effects on the performance of first-time retrievals. Lowering the global activation depth needs more individual activation work but can increase performance of queries.
    
    ObjectContainer.deactivate(Object, int) can be used to manually free memory by deactivating objects.
    
    In client/server environment the same setting should be used on both client and server
    
    .
    Specified by:
    
    activationDepth in interface Configuration
    
    Parameters:
    depth - the desired global activation depth.
    See Also:
    configuring classes individually
  - add
```
public void add(ConfigurationItem item)
```
    Description copied from interface: Configuration
    
    adds ConfigurationItems to be applied when an ObjectContainer or ObjectServer is opened.
    
    Specified by:
    
    add in interface Configuration
    
    Parameters:
    item - the ConfigurationItem
  - configurationItemsIterator
```
public Iterator4 configurationItemsIterator()
```
    Returns an iterator for all ConfigurationItem instances added.
    
    Returns:
    the iterator
    See Also:
    add(com.db4o.config.ConfigurationItem)
  - allowVersionUpdates
```
public void allowVersionUpdates(boolean flag)
```
    Description copied from interface: Configuration
    
    turns automatic database file format version updates on.
    
    Upon db4o database file format version changes, db4o can automatically update database files to the current version. db4objects does not provide functionality to reverse this process. It is not ensured that updated database files can be read with older db4o versions. In some cases (Example: using ObjectManager) it may not be desirable to update database files automatically therefore automatic updating is turned off by default for security reasons.
    
    Call this method to turn automatic database file version updating on.
    
    If automatic updating is turned off, db4o will refuse to open database files that use an older database file format.
    
    In client-server environment this setting should be used on both client and server.
    
    Specified by:
    
    allowVersionUpdates in interface Configuration
  - applyConfigurationItems
```
public void applyConfigurationItems(InternalObjectContainer container)
```
  - automaticShutDown
```
public void automaticShutDown(boolean flag)
```
    Description copied from interface: Configuration
    
    turns automatic shutdown of the engine on and off. The default and recommended setting is true.
    
    In client-server environment this setting should be used on both client and server.
    
    Specified by:
    
    automaticShutDown in interface Configuration
    
    Parameters:
    flag - whether db4o should shut down automatically.
  - blockSize
```
public void blockSize(int bytes)
```
    Description copied from interface: Configuration
    
    sets the storage data blocksize for new ObjectContainers.
    
    The standard setting is 1 allowing for a maximum database file size of 2GB. This value can be increased to allow larger database files, although some space will be lost to padding because the size of some stored objects will not be an exact multiple of the block size. A recommended setting for large database files is 8, since internal pointers have this length.
    
    This setting is only effective when the database is first created, in client-server environment in most cases it means that the setting should be used on the server side.
    
    Specified by:
    
    blockSize in interface Configuration
    
    Parameters:
    bytes - the size in bytes from 1 to 127
  - bTreeNodeSize
```
public void bTreeNodeSize(int size)
```
    Description copied from interface: Configuration
    
    configures the size of BTree nodes in indexes.
    
    Default setting: 100
    Lower values will allow a lower memory footprint and more efficient reading and writing of small slots.
    Higher values will reduce the overall number of read and write operations and allow better performance at the cost of more RAM use.
    
    This setting should be used on both client and server in client-server environment.
    
    Specified by:
    
    bTreeNodeSize in interface Configuration
    
    Parameters:
    size - the number of elements held in one BTree node.
  - bTreeCacheHeight
```
public void bTreeCacheHeight(int height)
```
    Description copied from interface: Configuration
    
    configures caching of BTree nodes.
    
    Clean BTree nodes will be unloaded on #commit and #rollback unless they are configured as cached here.
    
    Default setting: 0
    Possible settings: 1, 2 or 3
    
    The potential number of cached BTree nodes can be calculated with the following formula:
    maxCachedNodes = bTreeNodeSize ^ bTreeCacheHeight
    
    This setting should be used on both client and server in client-server environment.
    
    Specified by:
    
    bTreeCacheHeight in interface Configuration
    
    Parameters:
    height - the height of the cache from the root
  - callbacks
```
public void callbacks(boolean turnOn)
```
    Description copied from interface: Configuration
    
    turns callback methods on and off.
    
    Callbacks are turned on by default.
    
    A tuning hint: If callbacks are not used, you can turn this feature off, to prevent db4o from looking for callback methods in persistent classes. This will increase the performance on system startup.
    
    In client/server environment this setting should be used on both client and server.
    
    Specified by:
    
    callbacks in interface Configuration
    
    Parameters:
    turnOn - false to turn callback methods off
    See Also:
    Using callbacks
  - callbackMode
```
public void callbackMode(CallBackMode mode)
```
  - callConstructors
```
public void callConstructors(boolean flag)
```
    Description copied from interface: Configuration
    
    advises db4o to try instantiating objects with/without calling constructors.
    
    Not all JDKs / .NET-environments support this feature. db4o will attempt, to follow the setting as good as the enviroment supports. In doing so, it may call implementation-specific features like sun.reflect.ReflectionFactory#newConstructorForSerialization on the Sun Java 1.4.x/5 VM (not available on other VMs) and FormatterServices.GetUninitializedObject() on the .NET framework (not available on CompactFramework). This setting may also be overridden for individual classes in ObjectClass.callConstructor(boolean).
    
    The default setting depends on the features supported by your current environment.
    
    In client/server environment this setting should be used on both client and server.
    
    Specified by:
    
    callConstructors in interface Configuration
    
    Parameters:
    flag - - specify true, to request calling constructors, specify false to request not calling constructors.
    See Also:
    ObjectClass.callConstructor(boolean)
  - classActivationDepthConfigurable
```
public void classActivationDepthConfigurable(boolean turnOn)
```
    Description copied from interface: Configuration
    
    turns individual class activation depth configuration on and off.
    
    This feature is turned on by default.
    
    In client/server environment this setting should be used on both client and server.
    
    Specified by:
    
    classActivationDepthConfigurable in interface Configuration
    
    Parameters:
    turnOn - false to turn the possibility to individually configure class activation depths off
    See Also:
    Why activation?
  - configClass
```
public Config4Class configClass(java.lang.String className)
```
  - deepClone
```
public java.lang.Object deepClone(java.lang.Object param)
```
    Description copied from interface: DeepClone
    
    The parameter allows passing one new object so parent references can be corrected on children.
    
    Specified by:
    
    deepClone in interface DeepClone
  - container
```
public void container(ObjectContainerBase container)
```
  - databaseGrowthSize
```
public void databaseGrowthSize(int bytes)
```
    Description copied from interface: Configuration
    
    configures the size database files should grow in bytes, when no free slot is found within.
    
    Tuning setting.
    
    Whenever no free slot of sufficient length can be found within the current database file, the database file's length is extended. This configuration setting configures by how much it should be extended, in bytes.
    
    This configuration setting is intended to reduce fragmentation. Higher values will produce bigger database files and less fragmentation.
    
    To extend the database file, a single byte array is created and written to the end of the file in one write operation. Be aware that a high setting will require allocating memory for this byte array.
    
    Specified by:
    
    databaseGrowthSize in interface Configuration
    
    Parameters:
    bytes - amount of bytes
  - databaseGrowthSize
```
public int databaseGrowthSize()
```
  - detectSchemaChanges
```
public void detectSchemaChanges(boolean flag)
```
    Description copied from interface: Configuration
    
    tuning feature: configures whether db4o checks all persistent classes upon system startup, for added or removed fields.
    
    If this configuration setting is set to false while a database is being created, members of classes will not be detected and stored.
    
    This setting can be set to false in a production environment after all persistent classes have been stored at least once and classes will not be modified any further in the future.
    
    In a client/server environment this setting should be configured both on the client and and on the server.
    
    Default value:
    true
    
    Specified by:
    
    detectSchemaChanges in interface Configuration
    
    Parameters:
    flag - the desired setting
  - disableCommitRecovery
```
public void disableCommitRecovery()
```
    Description copied from interface: Configuration
    
    turns commit recovery off.
    
    db4o uses a two-phase commit algorithm. In a first step all intended changes are written to a free place in the database file, the "transaction commit record". In a second step the actual changes are performed. If the system breaks down during commit, the commit process is restarted when the database file is opened the next time. On very rare occasions (possibilities: hardware failure or editing the database file with an external tool) the transaction commit record may be broken. In this case, this method can be used to try to open the database file without commit recovery. The method should only be used in emergency situations after consulting db4o support.
    
    Specified by:
    
    disableCommitRecovery in interface Configuration
  - discardSmallerThan
```
public void discardSmallerThan(int byteCount)
```
    Description copied from interface: FreespaceConfiguration
    
    tuning feature: configures the minimum size of free space slots in the database file that are to be reused.
    
    When objects are updated or deleted, the space previously occupied in the database file is marked as "free", so it can be reused. db4o maintains two lists in RAM, sorted by address and by size. Adjacent entries are merged. After a large number of updates or deletes have been executed, the lists can become large, causing RAM consumption and performance loss for maintenance. With this method you can specify an upper bound for the byte slot size to discard.
    
    Pass Integer.MAX_VALUE to this method to discard all free slots for the best possible startup time.
    
    The downside of setting this value: Database files will necessarily grow faster.
    
    Default value:
    0 all space is reused
    
    Specified by:
    
    discardSmallerThan in interface FreespaceConfiguration
    
    Parameters:
    byteCount - Slots with this size or smaller will be lost.
  - encrypt
```
public void encrypt(boolean flag)
```
    Deprecated.
    
    Description copied from interface: Configuration
    
    configures the use of encryption.
    
    This method needs to be called before a database file is created with the first Db4o.openFile(java.lang.String).
    
    If encryption is set to true, you need to supply a password to seed the encryption mechanism.
    
    db4o database files keep their encryption format after creation.
    
    Specified by:
    
    encrypt in interface Configuration
    
    Parameters:
    flag - true for turning encryption on, false for turning encryption off.
    See Also:
    Configuration.password(java.lang.String)
  - exceptionsOnNotStorable
```
public void exceptionsOnNotStorable(boolean flag)
```
    Description copied from interface: Configuration
    
    configures whether Exceptions are to be thrown, if objects can not be stored.
    
    db4o requires the presence of a constructor that can be used to instantiate objects. If no default public constructor is present, all available constructors are tested, whether an instance of the class can be instantiated. Null is passed to all constructor parameters. The first constructor that is successfully tested will be used throughout the running db4o session. If an instance of the class can not be instantiated, the object will not be stored. By default, execution will continue without any message or error. This method can be used to configure db4o to throw an ObjectNotStorableException if an object can not be stored.
    
    The default for this setting is true.
    
    In client/server environment this setting should be used on both client and server.
    
    Specified by:
    
    exceptionsOnNotStorable in interface Configuration
    
    Parameters:
    flag - false to not throw Exceptions if objects can not be stored (fail silently).
  - freespace
```
public FreespaceConfiguration freespace()
```
    Description copied from interface: Configuration
    
    returns the freespace configuration interface.
    
    Specified by:
    
    freespace in interface Configuration
  - freespaceFiller
```
public void freespaceFiller(FreespaceFiller freespaceFiller)
```
    Description copied from interface: FreespaceConfiguration
    
    Configure a way to overwrite freed space in the database file with custom (for example: random) bytes. Will slow down I/O operation. The value of this setting may be cached internally and can thus not be reliably set after an object container has been opened.
    
    Specified by:
    
    freespaceFiller in interface FreespaceConfiguration
    
    Parameters:
    freespaceFiller - The freespace overwriting callback to use
  - freespaceFiller
```
public FreespaceFiller freespaceFiller()
```
  - generateUUIDs
```
public void generateUUIDs(ConfigScope scope)
```
    Description copied from interface: Configuration
    
    configures db4o to generate UUIDs for stored objects. This setting should be used when the database is first created.
    
    Specified by:
    
    generateUUIDs in interface Configuration
    
    Parameters:
    scope - the scope for UUID generation: disabled, generate for all classes, or configure individually
  - generateVersionNumbers
```
@Deprecated
public void generateVersionNumbers(ConfigScope scope)
```
    Deprecated.
    
    Description copied from interface: Configuration
    
    configures db4o to generate version numbers for stored objects. This setting should be used when the database is first created.
    
    Specified by:
    
    generateVersionNumbers in interface Configuration
    
    Parameters:
    scope - the scope for version number generation: disabled, generate for all classes, or configure individually
  - generateCommitTimestamps
```
public void generateCommitTimestamps(boolean flag)
```
    Description copied from interface: Configuration
    Configures db4o to generate commit timestamps for all stored objects.
    
    All the objects commited within a transaction will share the same commit timestamp.
    This setting should be used when the database is first created.
    
    Afterwards you can access the object's commit timestamp like this:
```
 ObjectContainer container = ...;
 ObjectInfo objectInfo = container.ext().getObjectInfo(obj);
 long commitTimestamp = objectInfo.getVersion();
 
```
    Specified by:
    
    generateCommitTimestamps in interface Configuration
    
    Parameters:
    flag - if true, commit timetamps will be generated for all stored objects. If you already have commit timestamps for stored objects and later set this flag to false, although you wont be able to access them, the commit timestamps will still be taking space in your file container. The only way to free that space is defragmenting the container.
  - getMessageSender
```
public MessageSender getMessageSender()
```
    Description copied from interface: ClientServerConfiguration
    
    returns the MessageSender for this Configuration context. This setting should be used on the client side.
    
    Specified by:
    
    getMessageSender in interface ClientServerConfiguration
    
    Returns:
    MessageSender
  - internStrings
```
public void internStrings(boolean doIntern)
```
    Description copied from interface: Configuration
    
    configures db4o to call #intern() on strings upon retrieval. In client/server environment the setting should be used on both client and server.
    
    Specified by:
    
    internStrings in interface Configuration
    
    Parameters:
    doIntern - true to intern strings
  - io
```
public void io(IoAdapter adapter)
```
    Description copied from interface: Configuration
    
    allows to configure db4o to use a customized byte IO adapter.
    
    Derive from the abstract class IoAdapter to write your own. Possible usecases could be improved performance with a native library, mirrored write to two files, encryption or read-on-write fail-safety control.
    
    An example of a custom io adapter can be found in xtea_db4o community project:
    http://developer.db4o.com/ProjectSpaces/view.aspx/XTEA
    
    In client-server environment this setting should be used on the server (adapter class must be available)
    
    Specified by:
    
    io in interface Configuration
    
    Parameters:
    adapter - - the IoAdapter
  - lockDatabaseFile
```
public void lockDatabaseFile(boolean flag)
```
    Description copied from interface: Configuration
    
    can be used to turn the database file locking thread off.
    
    Since Java does not support file locking up to JDK 1.4, db4o uses an additional thread per open database file to prohibit concurrent access to the same database file by different db4o sessions in different VMs.
    
    To improve performance and to lower ressource consumption, this method provides the possibility to prevent the locking thread from being started.
    
    Caution!
    If database file locking is turned off, concurrent write access to the same database file from different JVM sessions will corrupt the database file immediately.
    
    This method has no effect on open ObjectContainers. It will only affect how ObjectContainers are opened.
    
    The default setting is true.
    
    In client-server environment this setting should be used on both client and server.
    
    Specified by:
    
    lockDatabaseFile in interface Configuration
    
    Parameters:
    flag - false to turn database file locking off.
  - markTransient
```
public void markTransient(java.lang.String marker)
```
    Description copied from interface: Configuration
    
    allows to mark fields as transient with custom attributes.
    
    .NET only: Call this method with the attribute name that you wish to use to mark fields as transient. Multiple transient attributes are possible by calling this method multiple times with different attribute names.
    
    In client/server environment the setting should be used on both client and server.
    
    Specified by:
    
    markTransient in interface Configuration
    
    Parameters:
    marker - - the fully qualified name of the attribute, including it's namespace
  - messageLevel
```
public void messageLevel(int level)
```
    Description copied from interface: Configuration
    
    sets the detail level of db4o messages. Messages will be output to the configured output PrintStream.
    
    Level 0 - no messages
    Level 1 - open and close messages
    Level 2 - messages for new, update and delete
    Level 3 - messages for activate and deactivate
    
    When using client-server and the level is set to 0, the server will override this and set it to 1. To get around this you can set the level to -1. This has the effect of not returning any messages.
    
    In client-server environment this setting can be used on client or on server depending on which information do you want to track (server side provides more detailed information).
    
    Specified by:
    
    messageLevel in interface Configuration
    
    Parameters:
    level - integer from 0 to 3
    See Also:
    Configuration.setOut(java.io.PrintStream)
  - optimizeNativeQueries
```
public void optimizeNativeQueries(boolean optimizeNQ)
```
    Description copied from interface: Configuration
    
    If set to true, db4o will try to optimize native queries dynamically at query execution time, otherwise it will run native queries in unoptimized mode as SODA evaluations. On the Java platform the jars needed for native query optimization (db4o-X.x-nqopt.jar, bloat-X.x.jar) have to be on the classpath at runtime for this switch to have effect.
    
    The default setting is true.
    
    In client-server environment this setting should be used on both client and server.
    
    Specified by:
    
    optimizeNativeQueries in interface Configuration
    
    Parameters:
    optimizeNQ - true, if db4o should try to optimize native queries at query execution time, false otherwise
  - optimizeNativeQueries
```
public boolean optimizeNativeQueries()
```
    Description copied from interface: Configuration
    
    indicates whether Native Queries will be optimized dynamically.
    
    Specified by:
    
    optimizeNativeQueries in interface Configuration
    
    Returns:
    boolean true if Native Queries will be optimized dynamically.
    See Also:
    Configuration.optimizeNativeQueries(boolean)
  - objectClass
```
public ObjectClass objectClass(java.lang.Object clazz)
```
    Description copied from interface: Configuration
    
    returns an ObjectClass object to configure the specified class.
    
    The clazz parameter can be any of the following:
    - a fully qualified classname as a String.
    - a Class object.
    - any other object to be used as a template.
    
    Specified by:
    
    objectClass in interface Configuration
    
    Parameters:
    clazz - class name, Class object, or example object.
    
    Returns:
    an instance of an ObjectClass object for configuration.
  - outStream
```
public java.io.PrintStream outStream()
```
  - password
```
public void password(java.lang.String pw)
```
    Deprecated.
    
    Description copied from interface: Configuration
    
    protects the database file with a password.
    
    To set a password for a database file, this method needs to be called before a database file is created with the first Db4o.openFile(java.lang.String).
    
    All further attempts to open the file, are required to set the same password.
    
    The password is used to seed the encryption mechanism, which makes it impossible to read the database file without knowing the password.
    
    Specified by:
    
    password in interface Configuration
    
    Parameters:
    pw - the password to be used.
  - readOnly
```
public void readOnly(boolean flag)
```
    Description copied from interface: Configuration
    
    turns readOnly mode on and off.
    
    This method configures the mode in which subsequent calls to Db4o.openFile() will open files.
    
    Readonly mode allows to open an unlimited number of reading processes on one database file. It is also convenient for deploying db4o database files on CD-ROM.
    
    In client-server environment this setting should be used on the server side in embedded mode and ONLY on client side in networked mode.
    
    Specified by:
    
    readOnly in interface Configuration
    
    Parameters:
    flag - true for configuring readOnly mode for subsequent calls to Db4o.openFile().
  - reflector
```
public GenericReflector reflector()
```
  - reflectWith
```
public void reflectWith(Reflector reflect)
```
    Description copied from interface: Configuration
    
    configures the use of a specially designed reflection implementation.
    
    db4o internally uses java.lang.reflect.* by default. On platforms that do not support this package, customized implementations may be written to supply all the functionality of the interfaces in the com.db4o.reflect package. This method can be used to install a custom reflection implementation.
    
    In client-server environment this setting should be used on the server side (reflector class must be available)
    
    Specified by:
    
    reflectWith in interface Configuration
  - refreshClasses
```
public void refreshClasses()
```
  - reserveStorageSpace
```
public void reserveStorageSpace(long byteCount)
                         throws DatabaseReadOnlyException
```
    Description copied from interface: Configuration
    
    tuning feature only: reserves a number of bytes in database files.
    
    The global setting is used for the creation of new database files. Continous calls on an ObjectContainer Configuration context (see ExtObjectContainer.configure()) will continually allocate space.
    
    The allocation of a fixed number of bytes at one time makes it more likely that the database will be stored in one chunk on the mass storage. Less read/write head movement can result in improved performance.
    
    Note:
    Allocated space will be lost on abnormal termination of the database engine (hardware crash, VM crash). A Defragment run will recover the lost space. For the best possible performance, this method should be called before the Defragment run to configure the allocation of storage space to be slightly greater than the anticipated database file size.
    
    In client-server environment this setting should be used on the server side.
    
    Default configuration: 0
    
    Specified by:
    
    reserveStorageSpace in interface Configuration
    
    Parameters:
    byteCount - the number of bytes to reserve
    
    Throws:
    
    DatabaseReadOnlyException
  - send
```
public void send(java.lang.Object obj)
```
    The ConfigImpl also is our messageSender
    
    Specified by:
    
    send in interface MessageSender
    
    Parameters:
    obj - the message parameter, any object may be used.
  - setBlobPath
```
public void setBlobPath(java.lang.String path)
                 throws java.io.IOException
```
    Description copied from interface: Configuration
    
    configures the path to be used to store and read Blob data.
    
    In client-server environment this setting should be used on the server side.
    
    Specified by:
    
    setBlobPath in interface Configuration
    
    Parameters:
    path - the path to be used
    
    Throws:
    
    java.io.IOException
  - setMessageRecipient
```
public void setMessageRecipient(MessageRecipient messageRecipient)
```
    Description copied from interface: ClientServerConfiguration
    
    sets the MessageRecipient to receive Client Server messages.
    
    This setting should be used on the server side.
    
    Specified by:
    
    setMessageRecipient in interface ClientServerConfiguration
    
    Parameters:
    messageRecipient - the MessageRecipient to be used
  - setOut
```
public void setOut(java.io.PrintStream outStream)
```
    Deprecated.
    
    Description copied from interface: Configuration
    
    Assigns a PrintStream where db4o is to print its event messages.
    
    Messages are useful for debugging purposes and for learning to understand, how db4o works. The message level can be raised with Configuration.messageLevel(int) to produce more detailed messages.
    
    Use setOut(System.out) to print messages to the console.
    
    In client-server environment this setting should be used on the same side where Configuration.messageLevel(int) is used.
    
    Specified by:
    
    setOut in interface Configuration
    
    Parameters:
    outStream - the new PrintStream for messages.
    See Also:
    Configuration.messageLevel(int)
  - singleThreadedClient
```
public void singleThreadedClient(boolean flag)
```
    Description copied from interface: ClientServerConfiguration
    
    configures the client messaging system to be single threaded or multithreaded.
    
    Recommended settings:
    - true for low resource systems.
    - false for best asynchronous performance and fast GUI response.
    
    Default value:
    - .NET Compactframework: true
    - all other platforms: false
    
    This setting can be used on both client and server.
    
    Specified by:
    
    singleThreadedClient in interface ClientServerConfiguration
    
    Parameters:
    flag - the desired setting
  - stringEncoding
```
public StringEncoding stringEncoding()
```
  - stringEncoding
```
public void stringEncoding(StringEncoding encoding)
```
    Description copied from interface: Configuration
    
    configures the string encoding to be used.
    
    The string encoding can not be changed in the lifetime of a database file. To set up the database with the correct string encoding, this configuration needs to be set correctly before a database file is created with the first call to Db4o.openFile(java.lang.String) or Db4o.openServer(java.lang.String, int).
    
    For subsequent open calls, db4o remembers built-in string encodings. If a custom encoding is used (an encoding that is not supplied from within the db4o library), the correct encoding needs to be configured correctly again for all subsequent calls that open database files.
    
    Example:
    config.stringEncoding(StringEncodings.utf8()));
    
    Specified by:
    
    stringEncoding in interface Configuration
    
    See Also:
    StringEncodings
  - testConstructors
```
public void testConstructors(boolean flag)
```
    Description copied from interface: Configuration
    
    tuning feature: configures whether db4o should try to instantiate one instance of each persistent class on system startup.
    
    In a production environment this setting can be set to false, if all persistent classes have public default constructors.
    
    In client-server environment this setting should be used on both client and server side.
    
    Default value:
    true
    
    Specified by:
    
    testConstructors in interface Configuration
    
    Parameters:
    flag - the desired setting
  - timeoutClientSocket
```
public void timeoutClientSocket(int milliseconds)
```
    Description copied from interface: ClientServerConfiguration
    
    configures the time a client waits for a message response from the server.
    
    Default value: 600000ms (10 minutes)
    
    It is recommended to use the same values for ClientServerConfiguration.timeoutClientSocket(int) and ClientServerConfiguration.timeoutServerSocket(int).
    This setting can be used on both client and server.
    
    Specified by:
    
    timeoutClientSocket in interface ClientServerConfiguration
    
    Parameters:
    milliseconds - time in milliseconds
  - timeoutServerSocket
```
public void timeoutServerSocket(int milliseconds)
```
    Description copied from interface: ClientServerConfiguration
    
    configures the timeout of the serverside socket.
    
    The serverside handler waits for messages to arrive from the client. If no more messages arrive for the duration configured in this setting, the client will be disconnected.
    Clients send PING messages to the server at an interval of Math.min(timeoutClientSocket(), timeoutServerSocket()) / 2 and the server will respond to keep connections alive.
    Decrease this setting if you want clients to disconnect faster.
    Increase this setting if you have a large number of clients and long running queries and you are getting disconnected clients that you would like to wait even longer for a response from the server.
    Default value: 600000ms (10 minutes)
    
    It is recommended to use the same values for ClientServerConfiguration.timeoutClientSocket(int) and ClientServerConfiguration.timeoutServerSocket(int).
    This setting can be used on both client and server.
    
    Specified by:
    
    timeoutServerSocket in interface ClientServerConfiguration
    
    Parameters:
    milliseconds - time in milliseconds
  - updateDepth
```
public void updateDepth(int depth)
```
    Description copied from interface: Configuration
    
    specifies the global updateDepth.
    
    see the documentation of com.db4o.ObjectContainer#set for further details.
    
    The value be may be overridden for individual classes.
    
    The default setting is 1: Only the object passed to com.db4o.ObjectContainer#set will be updated.
    
    In client-server environment this setting should be used on both client and server sides.
    
    Specified by:
    
    updateDepth in interface Configuration
    
    Parameters:
    depth - the depth of the desired update.
    See Also:
    ObjectClass.updateDepth(int), ObjectClass.cascadeOnUpdate(boolean), Using callbacks
  - useBTreeSystem
```
public void useBTreeSystem()
```
    Description copied from interface: FreespaceConfiguration
    
    configures db4o to use a BTree-based freespace system.
    
    Advantages
    - ACID, no freespace is lost on abnormal system termination
    - low memory consumption
    
    Disadvantages
    - slower than the RAM-based system, since freespace information is written during every commit
    
    Specified by:
    
    useBTreeSystem in interface FreespaceConfiguration
  - useRamSystem
```
public void useRamSystem()
```
    Description copied from interface: FreespaceConfiguration
    
    configures db4o to use a RAM-based freespace system.
    
    Advantages
    - best performance
    
    Disadvantages
    - upon abnormal system termination all freespace is lost
    - memory consumption
    
    Specified by:
    
    useRamSystem in interface FreespaceConfiguration
  - useIndexSystem
```
public void useIndexSystem()
```
    Deprecated.
    
    Description copied from interface: FreespaceConfiguration
    
    discontinued freespace system, only available before db4o 7.0.
    
    Specified by:
    
    useIndexSystem in interface FreespaceConfiguration
  - weakReferenceCollectionInterval
```
public void weakReferenceCollectionInterval(int milliseconds)
```
    Description copied from interface: Configuration
    
    configures the timer for WeakReference collection.
    
    The default setting is 1000 milliseconds.
    
    Configure this setting to zero to turn WeakReference collection off.
    
    Specified by:
    
    weakReferenceCollectionInterval in interface Configuration
    
    Parameters:
    milliseconds - the time in milliseconds
  - weakReferences
```
public void weakReferences(boolean flag)
```
    Description copied from interface: Configuration
    
    turns weak reference management on or off.
    
    This method must be called before opening a database.
    
    Performance may be improved by running db4o without using weak references durring memory management at the cost of higher memory consumption or by alternatively implementing a manual memory management scheme using ExtObjectContainer.purge(java.lang.Object)
    
    Setting the value to false causes db4o to use hard references to objects, preventing the garbage collection process from disposing of unused objects.
    
    The default setting is true.
    
    Specified by:
    
    weakReferences in interface Configuration
  - addAlias
```
public void addAlias(Alias alias)
```
    Description copied from interface: Configuration
    
    adds a new Alias for a class, namespace or package.
    
    Aliases can be used to persist classes in the running application to different persistent classes in a database file or on a db4o server.
    
    Two simple Alias implementations are supplied along with db4o:
    - TypeAlias provides an #equals() resolver to match names directly.
    - WildcardAlias allows simple pattern matching with one single '*' wildcard character.
    
    It is possible to create own complex Alias constructs by creating own resolvers that implement the Alias interface.
    
    Examples of concrete usecases:
    
    EmbeddedConfiguration config = Db4oEmbedded.newConfiguration(); // Creating an Alias for a single class config.common().addAlias( new TypeAlias("com.f1.Pilot", "com.f1.Driver")); // Mapping a Java package onto another config.common().addAlias( new WildcardAlias( "com.f1.*", "com.f1.client*"));
    
    Aliases that translate the persistent name of a class to a name that already exists as a persistent name in the database (or on the server) are not permitted and will throw an exception when the database file is opened.
    
    Aliases should be configured before opening a database file or connecting to a server.
    
    In client/server environment this setting should be used on the server side.
    
    Specified by:
    
    addAlias in interface Configuration
  - removeAlias
```
public void removeAlias(Alias alias)
```
    Description copied from interface: Configuration
    
    Removes an alias previously added with Configuration.addAlias(Alias).
    
    Specified by:
    
    removeAlias in interface Configuration
    
    Parameters:
    alias - the alias to remove
  - resolveAliasRuntimeName
```
public java.lang.String resolveAliasRuntimeName(java.lang.String runtimeType)
```
  - resolveAliasStoredName
```
public java.lang.String resolveAliasStoredName(java.lang.String storedType)
```
  - allowVersionUpdates
```
public boolean allowVersionUpdates()
```
  - automaticShutDown
```
public boolean automaticShutDown()
```
  - blockSize
```
public byte blockSize()
```
  - bTreeNodeSize
```
public int bTreeNodeSize()
```
  - blobPath
```
public java.lang.String blobPath()
```
  - callbackMode
```
public CallBackMode callbackMode()
```
  - callConstructors
```
public TernaryBool callConstructors()
```
  - detectSchemaChanges
```
public boolean detectSchemaChanges()
```
  - commitRecoveryDisabled
```
public boolean commitRecoveryDisabled()
```
  - diagnostic
```
public DiagnosticConfiguration diagnostic()
```
    Description copied from interface: Configuration
    
    returns the configuration interface for diagnostics.
    
    Specified by:
    
    diagnostic in interface Configuration
    
    Returns:
    the configuration interface for diagnostics.
  - diagnosticProcessor
```
public DiagnosticProcessor diagnosticProcessor()
```
  - discardFreeSpace
```
public int discardFreeSpace()
```
  - exceptionalClasses
```
public Hashtable4 exceptionalClasses()
```
  - exceptionsOnNotStorable
```
public boolean exceptionsOnNotStorable()
```
  - generateUUIDs
```
public ConfigScope generateUUIDs()
```
  - generateCommitTimestamps
```
public TernaryBool generateCommitTimestamps()
```
  - internStrings
```
public boolean internStrings()
```
    Description copied from interface: Configuration
    
    returns true if strings will be interned.
    
    Specified by:
    
    internStrings in interface Configuration
  - lockFile
```
public boolean lockFile()
```
  - messageLevel
```
public int messageLevel()
```
  - messageRecipient
```
public MessageRecipient messageRecipient()
```
  - prefetchIDCount
```
public void prefetchIDCount(int prefetchIDCount)
```
    Description copied from interface: ClientServerConfiguration
    
    Sets the number of IDs to be pre-allocated in the database for new objects created on the client. This setting should be used on the client side. In embedded mode this setting has no effect.
    
    Specified by:
    
    prefetchIDCount in interface ClientServerConfiguration
    
    Parameters:
    prefetchIDCount - The number of IDs to be prefetched
  - prefetchIDCount
```
public int prefetchIDCount()
```
  - prefetchObjectCount
```
public void prefetchObjectCount(int prefetchObjectCount)
```
    Description copied from interface: ClientServerConfiguration
    
    Sets the number of objects to be prefetched for an ObjectSet. This setting should be used on the server side.
    
    Specified by:
    
    prefetchObjectCount in interface ClientServerConfiguration
    
    Parameters:
    prefetchObjectCount - The number of objects to be prefetched
  - prefetchObjectCount
```
public int prefetchObjectCount()
```
  - readAs
```
public Hashtable4 readAs()
```
  - isReadOnly
```
public boolean isReadOnly()
```
  - recoveryMode
```
public void recoveryMode(boolean flag)
```
    Description copied from interface: Configuration
    
    turns recovery mode on and off.
    
    Recovery mode can be used to try to retrieve as much as possible out of an already corrupted database. In recovery mode internal checks are more relaxed. Null or invalid objects may be returned instead of throwing exceptions.
    
    Use this method with care as a last resort to get data out of a corrupted database.
    
    Specified by:
    
    recoveryMode in interface Configuration
    
    Parameters:
    flag - true to turn recover mode on.
  - recoveryMode
```
public boolean recoveryMode()
```
  - reservedStorageSpace
```
public int reservedStorageSpace()
```
  - singleThreadedClient
```
public boolean singleThreadedClient()
```
  - testConstructors
```
public boolean testConstructors()
```
  - timeoutClientSocket
```
public int timeoutClientSocket()
```
  - timeoutServerSocket
```
public int timeoutServerSocket()
```
  - updateDepth
```
public int updateDepth()
```
  - weakReferenceCollectionInterval
```
public int weakReferenceCollectionInterval()
```
  - weakReferences
```
public boolean weakReferences()
```
  - io
```
public IoAdapter io()
```
    Description copied from interface: Configuration
    
    returns the configured IoAdapter.
    
    Specified by:
    
    io in interface Configuration
    
    Returns:
  - storage
```
public Storage storage()
```
    Description copied from interface: Configuration
    
    returns the configured Storage
    
    Specified by:
    
    storage in interface Configuration
  - storage
```
public void storage(Storage factory)
```
    Description copied from interface: Configuration
    
    allows to configure db4o to use a customized byte IO storage mechanism.
    
    Implement the interface Storage to write your own. Possible usecases could be improved performance with a native library, mirrored write to two files, encryption or read-on-write fail-safety control.
    
    Specified by:
    
    storage in interface Configuration
    
    Parameters:
    factory - - the factory
    See Also:
    CachingStorage, MemoryStorage, FileStorage, StorageDecorator
  - queries
```
public QueryConfiguration queries()
```
    Description copied from interface: Configuration
    
    returns the Query configuration interface.
    
    Specified by:
    
    queries in interface Configuration
  - evaluationMode
```
public void evaluationMode(QueryEvaluationMode mode)
```
    Description copied from interface: QueryConfiguration
    
    configures the query processor evaluation mode.
    
    The db4o query processor can run in three modes:
    - Immediate mode
    - Snapshot mode
    - Lazy mode
    
    In Immediate mode, a query will be fully evaluated when Query.execute() is called. The complete ObjectSet of all matching IDs is generated immediately.
    
    In Snapshot mode, the Query.execute() call will trigger all index processing immediately. A snapshot of the current state of all relevant indexes is taken for further processing by the SODA query processor. All non-indexed constraints and all evaluations will be run when the user application iterates through the resulting ObjectSet.
    
    In Lazy mode, the Query.execute() call will only create an Iterator against the best index found. Further query processing (including all index processing) will happen when the user application iterates through the resulting ObjectSet.
    
    Advantages and disadvantages of the individual modes:
    
    Immediate mode
    + If the query is intended to iterate through the entire resulting ObjectSet, this mode will be slightly faster than the others.
    + The query will process without intermediate side effects from changed objects (by the caller or by other transactions).
    - Query processing can block the server for a long time.
    - In comparison to the other modes it will take longest until the first results are returned.
    - The ObjectSet will require a considerate amount of memory to hold the IDs of all found objects.
    
    Snapshot mode
    + Index processing will happen without possible side effects from changes made by the caller or by other transaction.
    + Since index processing is fast, a server will not be blocked for a long time.
    - The entire candidate index will be loaded into memory. It will stay there until the query ObjectSet is garbage collected. In a C/S setup, the memory will be used on the server side.
    
    Lazy mode
    + The call to Query.execute() will return very fast. First results can be made available to the application before the query is fully processed.
    + A query will consume hardly any memory at all because no intermediate ID representation is ever created.
    - Lazy queries check candidates when iterating through the resulting ObjectSet. In doing so the query processor takes changes into account that may have happened since the Query#execute()call: committed changes from other transactions, and uncommitted changes from the calling transaction. There is a wide range of possible side effects. The underlying index may have changed. Objects themselves may have changed in the meanwhile. There even is the chance of creating an endless loop, if the caller of the iterates through the ObjectSet and changes each object in a way that it is placed at the end of the index: The same objects can be revisited over and over. In lazy mode it can make sense to work in a way one would work with collections to avoid concurrent modification exceptions. For instance one could iterate through the ObjectSet first and store all objects to a temporary other collection representation before changing objects and storing them back to db4o.
    
    Note: Some method calls against a lazy ObjectSet will require the query processor to create a snapshot or to evaluate the query fully. An example of such a call is ObjectSet.size().
    
    The default query evaluation mode is Immediate mode.
    
    Recommendations:
    - Lazy mode can be an excellent choice for single transaction read use, to keep memory consumption as low as possible.
    - Client/Server applications with the risk of concurrent modifications should prefer Snapshot mode to avoid side effects from other transactions.
    
    To change the evaluationMode, pass any of the three static QueryEvaluationMode constants from the QueryEvaluationMode class to this method:
    - QueryEvaluationMode.IMMEDIATE
    - QueryEvaluationMode.SNAPSHOT
    - QueryEvaluationMode.LAZY
    
    This setting must be issued from the client side.
    
    Specified by:
    
    evaluationMode in interface QueryConfiguration
  - evaluationMode
```
public QueryEvaluationMode evaluationMode()
```
    Specified by:
    
    evaluationMode in interface QueryConfiguration
    
    Returns:
    the currently configured query evaluation mode
    See Also:
    QueryConfiguration.evaluationMode(QueryEvaluationMode)
  - queryResultIteratorFactory
```
public void queryResultIteratorFactory(QueryResultIteratorFactory factory)
```
  - queryResultIteratorFactory
```
public QueryResultIteratorFactory queryResultIteratorFactory()
```
  - clientServer
```
public ClientServerConfiguration clientServer()
```
    Description copied from interface: Configuration
    
    returns client/server configuration interface.
    
    Specified by:
    
    clientServer in interface Configuration
  - batchMessages
```
public void batchMessages(boolean flag)
```
    Description copied from interface: ClientServerConfiguration
    
    Configures to batch messages between client and server. By default, batch mode is enabled.
    
    This setting can be used on both client and server.
    
    Specified by:
    
    batchMessages in interface ClientServerConfiguration
    
    Parameters:
    flag - false, to turn message batching off.
  - batchMessages
```
public boolean batchMessages()
```
  - maxBatchQueueSize
```
public void maxBatchQueueSize(int maxSize)
```
    Description copied from interface: ClientServerConfiguration
    
    Configures the maximum memory buffer size for batched message. If the size of batched messages is greater than maxSize, batched messages will be sent to server.
    
    This setting can be used on both client and server.
    
    Specified by:
    
    maxBatchQueueSize in interface ClientServerConfiguration
  - maxBatchQueueSize
```
public int maxBatchQueueSize()
```
  - activationDepthProvider
```
public void activationDepthProvider(ActivationDepthProvider provider)
```
  - updateDepthProvider
```
public void updateDepthProvider(UpdateDepthProvider provider)
```
  - activationDepthProvider
```
public ActivationDepthProvider activationDepthProvider()
```
  - updateDepthProvider
```
public UpdateDepthProvider updateDepthProvider()
```
  - registerTypeHandler
```
public void registerTypeHandler(TypeHandlerPredicate predicate,
                       TypeHandler4 typeHandler)
```
    Description copied from interface: Configuration
    
    allows registering special TypeHandlers for customized marshalling and customized comparisons.
    
    Specified by:
    
    registerTypeHandler in interface Configuration
    
    Parameters:
    predicate - to specify for which classes and versions the TypeHandler is to be used.
    typeHandler - to be used for the classes that match the predicate.
  - typeHandlerForClass
```
public TypeHandler4 typeHandlerForClass(ReflectClass classReflector,
                               byte handlerVersion)
```
  - factory
```
public void factory(LegacyClientServerFactory factory)
```
  - clientServerFactory
```
public LegacyClientServerFactory clientServerFactory()
```
  - cache
```
public CacheConfiguration cache()
```
    Description copied from interface: Configuration
    
    returns the Cache configuration interface.
    
    Specified by:
    
    cache in interface Configuration
  - fileBasedTransactionLog
```
public boolean fileBasedTransactionLog()
```
  - fileBasedTransactionLog
```
public void fileBasedTransactionLog(boolean flag)
```
  - taint
```
public void taint()
```
  - assertIsNotTainted
```
public static void assertIsNotTainted(Configuration config)
```
  - prefetchDepth
```
public void prefetchDepth(int prefetchDepth)
```
    Description copied from interface: ClientServerConfiguration
    
    Sets the depth to which prefetched objects are activated. This setting should be used on the client side.
    
    Specified by:
    
    prefetchDepth in interface ClientServerConfiguration
  - prefetchDepth
```
public int prefetchDepth()
```
  - environmentContributions
```
public java.util.List environmentContributions()
```
  - prefetchSlotCacheSize
```
public void prefetchSlotCacheSize(int slotCacheSize)
```
    Description copied from interface: ClientServerConfiguration
    
    Sets the slot cache size to the given value.
    
    Specified by:
    
    prefetchSlotCacheSize in interface ClientServerConfiguration
  - prefetchSlotCacheSize
```
public int prefetchSlotCacheSize()
```
  - prefetchSettingsChanged
```
public Event4<EventArgs> prefetchSettingsChanged()
```
  - referenceSystemFactory
```
public void referenceSystemFactory(ReferenceSystemFactory referenceSystemFactory)
```
  - referenceSystemFactory
```
public ReferenceSystemFactory referenceSystemFactory()
```
  - nameProvider
```
public void nameProvider(NameProvider provider)
```
  - nameProvider
```
public NameProvider nameProvider()
```
  - usePointerBasedIdSystem
```
public void usePointerBasedIdSystem()
```
  - useStackedBTreeIdSystem
```
public void useStackedBTreeIdSystem()
```
  - useSingleBTreeIdSystem
```
public void useSingleBTreeIdSystem()
```
  - idSystemType
```
public byte idSystemType()
```
  - useInMemoryIdSystem
```
public void useInMemoryIdSystem()
```
  - useCustomIdSystem
```
public void useCustomIdSystem(IdSystemFactory factory)
```
  - customIdSystemFactory
```
public IdSystemFactory customIdSystemFactory()
```
  - asynchronousSync
```
public void asynchronousSync(boolean flag)
```
  - asynchronousSync
```
public boolean asynchronousSync()
```
  - maxStackDepth
```
public int maxStackDepth()
```
    Specified by:
    
    maxStackDepth in interface Configuration
    
    See Also:
    CommonConfiguration.maxStackDepth()
  - maxStackDepth
```
public void maxStackDepth(int maxStackDepth)
```
    Specified by:
    
    maxStackDepth in interface Configuration
    
    See Also:
    CommonConfiguration.maxStackDepth(int)

Class Config4Impl

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PREFETCH_SLOT_CACHE_SIZE_FACTOR

Constructor Detail

Config4Impl

Method Detail

activationDepth

activationDepth

add

configurationItemsIterator

allowVersionUpdates

applyConfigurationItems

automaticShutDown

blockSize

bTreeNodeSize

bTreeCacheHeight

callbacks

callbackMode

callConstructors

classActivationDepthConfigurable

configClass

deepClone

container

databaseGrowthSize

databaseGrowthSize

detectSchemaChanges

disableCommitRecovery

discardSmallerThan

encrypt

exceptionsOnNotStorable

freespace

freespaceFiller

freespaceFiller

generateUUIDs

generateVersionNumbers

generateCommitTimestamps

getMessageSender

internStrings

io

lockDatabaseFile

markTransient

messageLevel

optimizeNativeQueries

optimizeNativeQueries

objectClass

outStream

password

readOnly

reflector

reflectWith

refreshClasses

reserveStorageSpace

send

setBlobPath

setMessageRecipient

setOut

singleThreadedClient

stringEncoding

stringEncoding

testConstructors

timeoutClientSocket

timeoutServerSocket

updateDepth

useBTreeSystem

useRamSystem

useIndexSystem

weakReferenceCollectionInterval

weakReferences

addAlias

removeAlias

resolveAliasRuntimeName

resolveAliasStoredName

allowVersionUpdates

automaticShutDown

blockSize