Examples of com.persistit.encoding.ValueCoder

com.persistit.encoding.ValueCoder
Interface for specialized encoding and decoding of Objects of arbitrary type in a {@link Value}. Persistit contains built-in logic to encode objects of certain classes. For other classes, if there is no registered ValueCoder, Persistit uses standard object serialization to generate a byte array that represents the state of that object in the database.

By implementing and registering a ValueCoder with the current {@link CoderManager} you can override this default encoding. Typically thecustomized encoding of an object will be much shorter than that produced by serialization because the customized encoding classes by their Persistit class handles (see {@link com.persistit.ClassIndex}) rather than their names. In addition, standard serialization serializes the entire graph of other objects that may be directly or indirectly referred to by the object being made persistent. This behavior may result in storing much more data than is required, and more importantly, may result in incorrect semantics. A customized ValueEncoder can handle persistence of fields that refer to other objects in a manner that is semantically appropriate for the specific object. Note that if a class has a ValueCoder, it can be stored in Persistit even if it does not implement java.io.Serializable.

A ValueCoder implements methods to convert an object of some class to an array of bytes and back again. Typically the implementation of a ValueCoder will simply invoke the Value's put methods to write the fields into the Value. For example, the following code defines a class, and a ValueCoder to store and retrieve it.
```
 class MyClass { int id; int anotherInt; String someString; MyClass anotherMyClass; } class MyClassValueCoder implements ValueCoder { public void put(Value value, Object object, CoderContext context) { MyClass mc = (MyClass) object; value.put(mc.id); value.put(mc.anotherInt); value.put(mc.someString); value.put(mc.anotherMyClass == null ? -1 : mc.anotherMyClass.id); } public Object get(Value value, Class clazz, CoderContext context) { MyClass mc = new MyClass(); mc.id = value.getInt(); mc.anotherInt = value.getInt(); mc.someString = value.getString(); mc.anotherMyClass = lookupMyClass(value.getInt()); return mc; } } 
```
The application should register this ValueCoder before attempting to invoke {@link Value#put(Object)} on an object of classMyClass or to retrieve an object value using {@link Value#get()}that will resolve to a MyClass. Generally this means that applications should register all ValueCoders and KeyCoders during application startup, immediately after invoking {@link com.persistit.Persistit#initialize}. For example:
```
 ... try { Persistit.initialize(); CoderManager cm = Persistit.getInstance().getCoderManager(); cm.registerValueCoder(new MyClassValueCoder()); cm.registerValueCoder(new MyClassValueCoder2()); ... cm.registerKeyCoder(new MyClassKeyCoder()); ... } catch (PersistitException e) { ... } 
```
@version 1.0

        default: {
            final int saveDepth = _depth;
            try {
                _depth++;
                final Class<?> cl = classForHandle(classHandle);
                final ValueCoder coder = getValueCoder(cl);


                if (coder != null) {
                    if (target == null) {
                        object = coder.get(this, cl, context);
                    }


                    else if (coder instanceof ValueRenderer) {
                        ((ValueRenderer) coder).render(this, target, cl, context);
                        object = target;

View Full Code Here

            try {
                if (_shared && _depth == 0) {
                    getValueCache().put(currentItemCount, object);
                }
                _depth++;
                ValueCoder coder = getValueCoder(cl);


                while (coder instanceof DefaultObjectCoder) {
                    final Object replacement = ((DefaultObjectCoder) coder).writeReplace(this, object);


                    if (replacement == object)
                        break;


                    replaced = true;


                    if (replacement != null) {
                        object = replacement;
                        cl = replacement.getClass();
                        coder = getValueCoder(cl);
                    } else {
                        break;
                    }
                }


                if (replaced) {
                    put(object, context);
                    end = _size;
                } else {
                    int handle;
                    if (cl == Object.class) {
                        handle = CLASS_OBJECT;
                    } else
                        handle = handleForClass(cl);


                    if (coder != null) {
                        _size += encodeVariableLengthInt(CLASS1, _size, handle - CLASS1);
                        coder.put(this, object, context);
                        end = _size;
                    } else {
                        _bytes[_size++] = CLASS_SERIALIZED;
                        final ObjectOutputStream oos = new OldValueOutputStream(this);
                        oos.writeObject(object);

View Full Code Here

     *            The class for which a <code>ValueCoder</code> is needed
     * @return The <code>ValueCoder</code>
     */
    @Override
    public ValueCoder getValueCoder(final Class<?> clazz) {
        ValueCoder coder = lookupValueCoder(clazz);
        if (coder == null) {
            final boolean serialOverride = isSerialOverride(clazz);
            if (serialOverride) {
                coder = new SerialValueCoder(clazz);
            } else if (ENUM_CLASS != null && ENUM_VALUE_CODER != null && ENUM_CLASS.isAssignableFrom(clazz)) {

View Full Code Here

     * collections classes in the Java API. These are somewhat faster and more
     * space-efficient than default java serialization of the same classes. This
     * method is called by Persistit during initialization.
     */
    private void registerDefaultCoveredClasses() {
        final ValueCoder coder = new CollectionValueCoder();
        for (int index = 0; index < COLLECTION_CLASSES.length; index++) {
            final Class<?> clazz = COLLECTION_CLASSES[index];
            if (!isSerialOverride(clazz)) {
                registerValueCoder(COLLECTION_CLASSES[index], coder);
            }

View Full Code Here

            throw new ConversionException("Not Serializable: " + clientClass.getName());
        }


        final Class superClass = clientClass.getSuperclass();
        if (superClass != null && Serializable.class.isAssignableFrom(superClass)) {
            ValueCoder coder = null;
            final CoderManager cm = _persistit.getCoderManager();
            if (cm != null) {
                coder = cm.lookupValueCoder(superClass);
            }
            if (!(coder instanceof DefaultValueCoder)) {

View Full Code Here

0 1 2

TOP

Related Classes of com.persistit.encoding.ValueCoder

com.persistit.DefaultCoderManager

com.persistit.DefaultValueCoder

com.persistit.Value

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.