CoderManager (org.openidentityplatform.commons.parent 2.2.3 Documentation)

All Known Implementing Classes:

DefaultCoderManager
```
public interface CoderManager
```
Manages the collections of KeyCoders and ValueCoders that encode and decode object values in Persistit™. An application should register all KeyCoder and ValueCoder implementations before storing or accessing objects of the associated classes in Persistit.

When Persistit is initialized, a instance of DefaultCoderManager is installed as the current CoderManager. Applications can refer to it through the method Persistit.getCoderManager(). Applications should register KeyCoder and ValueCoder instances as follows:
```
 ValueCoder vc1 = new MyClassValueCoder();
 KeyCoder kc1 = new MyClassKeyCoder();
 Persistit.getInstance().getCoderManager().registerValueCoder(MyClass.class, kc1);
 Persistit.getInstance().getCoderManager().registerKeyCoder(MyClass.class, kc1);
 
```
Subsequently, any time the application appends an instance of a MyClass to a Key, the MyClassKeyCoder will be used to convert the interior state of the MyClass into a representation within the Key. Likewise, whenever the application puts an object of class MyClass into a Value, the registered MyClassValueCoder will be used to encode it. Persistit uses the lookupKeyCoder(java.lang.Class<?>) and lookupValueCoder(java.lang.Class<?>) methods to acquire the appropriate coder.

An application may replace the default implementation provided by DefaultCoderManager. Such a custom implementation might, for example, handle the relationship between certain classes and their associated coders in a special way.

An application can create and install a customized CoderManager as follows:
```
 CoderManager myCoderManager = new MyCoderManager(Persistit.getInstance().getCoderManager());
 Persistit.getInstance().setCoderManager(myCoderManager);
 
```
Note that the MyCoderManager instance receives the previously installed CoderManager as an argument of its constructor. The new CoderManager should return the previously installed one as the value of its getParent() method, and the lookupKeyCoder(java.lang.Class<?>) and lookupValueCoder(java.lang.Class<?>) should delegate any lookups not handled by the customized CoderManager back to the parent.

Key Ordering

The encoding of key values determines the ordering of traversal for Exchange.traverse(com.persistit.Key.Direction, boolean) and associated methods. See Key for definition of the ordering among the types for which built-in encoding exists. The ordering of key values based on objects that are encoded by custom KeyCoders is determined by the implementation of each KeyCoder.
This leaves the question of how keys that may contain encoded objects of different classes are ordered. For example, consider the code fragment shown here:
```
  Exchange exchange = new Exchange(...);
  Object a = new MyClass1();  // where MyClass1 and MyClass2
  Object b = new MyClass2();  // have registered KeyCoders
  exchange.to(a).store();     // store something with a's value as key
  exchange.to(b).store();     // store something with b's value as key
  exchange.to(Key.BEFORE)
  while (exchange.next())
  {
      System.out.println(exchange.indexTo(-1).getTypeName());
  }
 
```
This code will insert two records incorporating the values a and b into Persistit, and will then traverse the resulting tree and print the names of the classes of the key values. The question is whether "MyClass2" will be printed before or after "MyClass2".

The answer depends on the order in which MyClass1 and MyClass2 were first registered within Persistit. At the time a new class is first registered, Persistit assigns a permanent int-valued class handle to the class. Whenever an instance of that class is encoded within either a Key or a Value, that handle value, rather than the class name, is used. This reduces disk, memory and CPU consumption whenever Persistit stores or retrieves objects. Handles are assigned in increasing numeric order as classes are registered. Thus if MyClass1 was registered before MyClass2, it will precede MyClass2 in traversal order. Otherwise it will follow MyClass2.
Version:

1.0

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`CoderManager`	`getParent()` Return the parent `CoderManager` implementation, or `null` if there is none.
`Map<Class<?>,? extends KeyCoder>`	`getRegisteredKeyCoders()` Create a `Map` of `Class`es to registered `KeyCoder` s.
`Map<Class<?>,? extends ValueCoder>`	`getRegisteredValueCoders()` Create a `Map` of `Class`es to registered `ValueCoder`s.
`ValueCoder`	`getValueCoder(Class<?> clazz)` Return a `ValueCoder` for the supplied `Class`.
`KeyCoder`	`lookupKeyCoder(Class<?> clazz)` Returns the `KeyCoder` registered for the supplied `Class`, or `null` if no `KeyCoder` is registered.
`ValueCoder`	`lookupValueCoder(Class<?> clazz)` Returns the `ValueCoder` registered for the supplied `Class`, or `null` if no `ValueCoder` is registered.
`KeyCoder`	`registerKeyCoder(Class<?> clazz, KeyCoder coder)` Register the provided `KeyCoder` to encode and decode instances of supplied class.
`ValueCoder`	`registerValueCoder(Class<?> clazz, ValueCoder coder)` Register the provided `ValueCoder` to encode and decode instances of supplied class.
`KeyCoder`	`unregisterKeyCoder(Class<?> clazz)` Remove the registered `KeyCoder` for the supplied class.
`int`	`unregisterKeyCoder(KeyCoder coder)` Remove the supplied `KeyCoder` from all classes to which it was previously registered.
`ValueCoder`	`unregisterValueCoder(Class<?> clazz)` Remove the registered `ValueCoder` for the supplied class.
`int`	`unregisterValueCoder(ValueCoder coder)` Remove the supplied `ValueCoder` from all classes to which it was previously registered.

- Method Detail
  - getRegisteredValueCoders
```
Map<Class<?>,? extends ValueCoder> getRegisteredValueCoders()
```
    Create a Map of Classes to registered ValueCoders. The map is an unmodifiable, is sorted by class name, and does not change with subsequent registrations or unregistrations of ValueCoders.
    
    Returns:
    
    Map of Classes to ValueCoders.
  - getRegisteredKeyCoders
```
Map<Class<?>,? extends KeyCoder> getRegisteredKeyCoders()
```
    Create a Map of Classes to registered KeyCoder s. The map is an unmodifiable, and is sorted by class name, and does not change with subsequent registrations or unregistrations of KeyCoders.
    
    Returns:
    
    Map of Classes to KeyCoder s.
  - registerKeyCoder
```
KeyCoder registerKeyCoder(Class<?> clazz,
                          KeyCoder coder)
```
    Register the provided KeyCoder to encode and decode instances of supplied class.
    
    Parameters:
    
    clazz - The Class for which this KeyCoder will provide encoding and decoding services
    
    coder - The KeyCoder to register
    
    Returns:
    
    The KeyCoder formerly registered for this Class , or null if there was none.
  - unregisterKeyCoder
```
KeyCoder unregisterKeyCoder(Class<?> clazz)
```
    Remove the registered KeyCoder for the supplied class.
    
    Parameters:
    
    clazz - The Class from which to remove a KeyCoder, if present
    
    Returns:
    
    The KeyCoder that was removed, or null if there was none.
  - unregisterKeyCoder
```
int unregisterKeyCoder(KeyCoder coder)
```
    Remove the supplied KeyCoder from all classes to which it was previously registered.
    
    Parameters:
    
    coder - The KeyCoder to remove.
    
    Returns:
    
    The count of classes this KeyCoder was registered for.
  - lookupKeyCoder
```
KeyCoder lookupKeyCoder(Class<?> clazz)
```
    Returns the KeyCoder registered for the supplied Class, or null if no KeyCoder is registered.
    
    Parameters:
    
    clazz - The Class
    
    Returns:
    
    The KeyCoder or null if there is none.
  - registerValueCoder
```
ValueCoder registerValueCoder(Class<?> clazz,
                              ValueCoder coder)
```
    Register the provided ValueCoder to encode and decode instances of supplied class.
    
    Parameters:
    
    clazz - The Class for which this ValueCoder will provide encoding and decoding services
    
    coder - The ValueCoder to register
    
    Returns:
    
    The ValueCoder that was removed, or null if there was none.
  - unregisterValueCoder
```
ValueCoder unregisterValueCoder(Class<?> clazz)
```
    Remove the registered ValueCoder for the supplied class.
    
    Parameters:
    
    clazz - The Class from which to remove a ValueCoder, if present
    
    Returns:
    
    The ValueCoder that was removed, or null if there was none.
  - unregisterValueCoder
```
int unregisterValueCoder(ValueCoder coder)
```
    Remove the supplied ValueCoder from all classes to which it was previously registered.
    
    Parameters:
    
    coder - The ValueCoder to remove.
    
    Returns:
    
    The count of classes this ValueCoder was registered for.
  - lookupValueCoder
```
ValueCoder lookupValueCoder(Class<?> clazz)
```
    Returns the ValueCoder registered for the supplied Class, or null if no ValueCoder is registered.
    
    Parameters:
    
    clazz - The Class
    
    Returns:
    
    The ValueCoder or null if there is none.
  - getValueCoder
```
ValueCoder getValueCoder(Class<?> clazz)
```
    Return a ValueCoder for the supplied Class. If there is none registered, implicitly create one and register it.
    
    Parameters:
    
    clazz -
    
    Returns:
    
    The ValueCoder
  - getParent
```
CoderManager getParent()
```
    Return the parent CoderManager implementation, or null if there is none.
    
    Returns:
    
    The parent CoderManager

Interface CoderManager

Key Ordering

Method Summary

Method Detail

getRegisteredValueCoders

getRegisteredKeyCoders

registerKeyCoder

unregisterKeyCoder

unregisterKeyCoder

lookupKeyCoder

registerValueCoder

unregisterValueCoder

unregisterValueCoder

lookupValueCoder

getValueCoder

getParent