openjpa-xmlstore/src/main/java/org/apache/openjpa/xmlstore/ObjectData.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.    
 */
package org.apache.openjpa.xmlstore;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.openjpa.event.OrphanedKeyAction;
import org.apache.openjpa.kernel.FetchConfiguration;
import org.apache.openjpa.kernel.OpenJPAStateManager;
import org.apache.openjpa.kernel.StoreContext;
import org.apache.openjpa.meta.ClassMetaData;
import org.apache.openjpa.meta.FieldMetaData;
import org.apache.openjpa.meta.JavaTypes;
import org.apache.openjpa.meta.ValueMetaData;
import org.apache.openjpa.util.Proxy;
import org.apache.openjpa.util.UnsupportedException;
import serp.util.Numbers;

/**
 * In-memory form of data in datastore backing a single persistent object.
 */
public final class ObjectData
    implements Cloneable {

    private Object _oid;
    private Object[] _data;
    private Long _version;
    private ClassMetaData _meta;

    /**
     * Create the object without underlying data. Just pass in type specific
     * metadata and the oid.
     */
    public ObjectData(Object oid, ClassMetaData meta) {
        _oid = oid;
        _meta = meta;
        _data = new Object[meta.getFields().length];
    }

    /**
     * Getter for oid.
     */
    public Object getId() {
        return _oid;
    }

    /**
     * Get the data for the field with the given index.
     */
    public Object getField(int num) {
        return _data[num];
    }

    /**
     * Set the data for the field with the given index.
     */
    public void setField(int num, Object val) {
        _data[num] = val;
    }

    /**
     * Set the version number of the object.
     */
    public void setVersion(Long version) {
        _version = version;
    }

    /**
     * Get the version number of the object.
     */
    public Long getVersion() {
        return _version;
    }

    /**
     * Get the metadata associated with the type of persistent object for
     * which this data applies.
     */
    public ClassMetaData getMetaData() {
        return _meta;
    }

    /**
     * Load the data and version information for this object into the
     * given state manager. Only fields in the given fetch configuration are
     * loaded.
     */
    public void load(OpenJPAStateManager sm, FetchConfiguration fetch) {
        if (sm.getVersion() == null)
            sm.setVersion(_version);

        FieldMetaData[] fmds = _meta.getFields();
        for (int i = 0; i < fmds.length; i++)
            if (!sm.getLoaded().get(i) && fetch.requiresFetch(fmds[i]) 
                != FetchConfiguration.FETCH_NONE)
                sm.store(i, toLoadable(sm, fmds[i], _data[i], fetch));
    }

    /**
     * Load the data and version information for this object into the
     * given state manager. Only fields in the given bit set will be loaded.
     */
    public void load(OpenJPAStateManager sm, BitSet fields,
        FetchConfiguration fetch) {
        if (sm.getVersion() == null)
            sm.setVersion(_version);

        FieldMetaData[] fmds = _meta.getFields();
        for (int i = 0; i < fmds.length; i++)
            if (fields.get(i))
                sm.store(i, toLoadable(sm, fmds[i], _data[i], fetch));
    }

    /**
     * Convert the stored value <code>val</code> into a value for loading
     * into a state manager.
     */
    private static Object toLoadable(OpenJPAStateManager sm,
        FieldMetaData fmd, Object val, FetchConfiguration fetch) {
        if (val == null)
            return null;

        Collection c;
        switch (fmd.getTypeCode()) {
            case JavaTypes.COLLECTION:
                // the stored value must be a collection
                c = (Collection) val;

                // the state manager will create a proxy collection of the needed
                // type depending on the declared type of the user's field; the
                // proxy will perform dirty tracking, etc
                Collection c2 = (Collection) sm.newFieldProxy(fmd.getIndex());

                // populate the proxy collection with our stored data, converting
                // it to the right type from its stored form
                for (Iterator itr = c.iterator(); itr.hasNext();)
                    c2.add(toNestedLoadable(sm, fmd.getElement(), itr.next(),
                        fetch));
                return c2;

            case JavaTypes.ARRAY:
                // the stored value must be a collection; we put arrays into
                // collections for storage
                c = (Collection) val;

                // create a new array of the right type; unlike collections in
                // the case above, arrays cannot be proxied
                Object a = Array.newInstance(fmd.getElement().getType(),
                    c.size());

                // populate the array with our stored data, converting it to the
                // right type from its stored form
                int idx = 0;
                for (Iterator itr = c.iterator(); itr.hasNext(); idx++)
                    Array.set(a, idx, toNestedLoadable(sm, fmd.getElement(),
                        itr.next(), fetch));
                return a;

            case JavaTypes.MAP:
                // the stored value must be a map
                Map m = (Map) val;

                // the state manager will create a proxy map of the needed
                // type depending on the declared type of the user's field; the
                // proxy will perform dirty tracking, etc
                Map m2 = (Map) sm.newFieldProxy(fmd.getIndex());

                // populate the proxy map with our stored data, converting
                // it to the right type from its stored form
                for (Iterator itr = m.entrySet().iterator(); itr.hasNext();) {
                    Map.Entry e = (Map.Entry) itr.next();
                    m2.put(toNestedLoadable(sm, fmd.getKey(), e.getKey(),fetch),
                        toNestedLoadable(sm, fmd.getElement(), e.getValue(),
                            fetch));
                }
                return m2;

            default:
                // just convert the stored value into its loadable equivalent.
                return toNestedLoadable(sm, fmd, val, fetch);
        }
    }

    /**
     * Convert the given stored value <code>val</code> to a value for loading
     * into a state manager. The value <code>val</code> must be a singular
     * value; it cannot be a container.
     */
    private static Object toNestedLoadable(OpenJPAStateManager sm,
        ValueMetaData vmd, Object val, FetchConfiguration fetch) {
        if (val == null)
            return null;

        switch (vmd.getTypeCode()) {
            // clone the date to prevent direct modification of our stored value
            case JavaTypes.DATE:
                return ((Date) val).clone();

            case JavaTypes.PC:
            case JavaTypes.PC_UNTYPED:
                // for relations to other persistent objects, we store the related
                // object's oid -- convert it back into a persistent instance
                StoreContext ctx = sm.getContext();
                Object pc = ctx.find(val, fetch, null, null, 0);
                if (pc != null)
                    return pc;
                OrphanedKeyAction action = ctx.getConfiguration().
                    getOrphanedKeyActionInstance();
                return action.orphan(val, sm, vmd);
            default:
                return val;
        }
    }

    /**
     * Store the data and version information for this object from the
     * given state manager. Only dirty fields will be stored.
     */
    public void store(OpenJPAStateManager sm) {
        _version = (Long) sm.getVersion();

        // if the version has not been set in the state manager (only true
        // when the object is new), set the version number to 0
        if (_version == null)
            _version = Numbers.valueOf(0L);

        // run through each persistent field in the state manager and store it
        FieldMetaData[] fmds = _meta.getFields();
        for (int i = 0; i < fmds.length; i++) {
            if (sm.getDirty().get(i)
                && fmds[i].getManagement() == fmds[i].MANAGE_PERSISTENT)
                _data[i] = toStorable(fmds[i], sm.fetch(i), sm.getContext());
        }
    }

    /**
     * Convert the given field value <code>val</code> to a form we can store.
     */
    private static Object toStorable(FieldMetaData fmd, Object val,
        StoreContext ctx) {
        if (val == null)
            return null;

        Collection c;
        switch (fmd.getTypeCode()) {
            case JavaTypes.COLLECTION:
                c = (Collection) val;

                // create a collection to copy the elements into for storage, and
                // populate it with converted element values
                Collection c2 = new ArrayList();
                for (Iterator itr = c.iterator(); itr.hasNext();)
                    c2.add(toNestedStorable(fmd.getElement(), itr.next(), ctx));
                return c2;

            case JavaTypes.ARRAY:
                // create a collection to copy the elements into for storage, and
                // populate it with converted element values
                c = new ArrayList();
                for (int i = 0, len = Array.getLength(val); i < len; i++)
                    c.add(toNestedStorable(fmd.getElement(), Array.get(val, i),
                        ctx));
                return c;

            case JavaTypes.MAP:
                Map m = (Map) val;

                // create a map to copy the entries into for storage, and
                // populate it with converted entry values
                Map m2 = new HashMap();
                for (Iterator itr = m.entrySet().iterator(); itr.hasNext();) {
                    Map.Entry e = (Map.Entry) itr.next();
                    m2.put(toNestedStorable(fmd.getKey(), e.getKey(), ctx),
                        toNestedStorable(fmd.getElement(), e.getValue(), ctx));
                }
                return m2;

            default:
                // just convert the loaded value into its storable equivalent
                return toNestedStorable(fmd, val, ctx);
        }
    }

    /**
     * Convert the given loaded value <code>val</code> to a value for storing.
     * The value <code>val</code> must be a singular value; it cannot be a
     * container.
     */
    private static Object toNestedStorable(ValueMetaData vmd, Object val,
        StoreContext ctx) {
        if (val == null)
            return null;

        switch (vmd.getTypeCode()) {
            case JavaTypes.DATE:
                // if the date is a proxy (since Dates are second class
                // objects (SCOs) they can be proxied for dirty tracking,
                // etc) then copy the value out of it for storage
                if (val instanceof Proxy)
                    return ((Proxy) val).copy(val);
                return ((Date) val).clone();

            case JavaTypes.PC:
            case JavaTypes.PC_UNTYPED:
                return ctx.getObjectId(val);

            case JavaTypes.COLLECTION:
            case JavaTypes.ARRAY:
            case JavaTypes.MAP:
                // nested relation types (e.g. collections of collections)
                // are not currently supported
                throw new UnsupportedException("This store does not support "
                    + "nested containers (e.g. collections of collections).");

            default:
                return val;
        }
    }

    /**
     * Clone this data.
     */
    public Object clone() {
        ObjectData data = new ObjectData(_oid, _meta);
        data.setVersion(_version);

        // copy each field
        FieldMetaData[] fmds = _meta.getFields();
        for (int i = 0; i < fmds.length; i++) {
            Object val = _data[i];
            if (val == null) {
                data.setField(i, null);
                continue;
            }

            switch (fmds[i].getTypeCode()) {
                case JavaTypes.COLLECTION:
                case JavaTypes.ARRAY:
                    data.setField(i, new ArrayList((Collection) val));
                    break;
                case JavaTypes.MAP:
                    data.setField(i, new HashMap((Map) val));
                    break;
                default:
                    data.setField(i, val);
            }
        }
        return data;
    }

    public String toString() {
        StringBuffer buf = new StringBuffer();
        buf.append("Class: (" + _meta.getDescribedType().getName() + ")\n");
        buf.append("Object Id: (" + _oid + ")\n");
        buf.append("Version: (" + _version + ")\n");
        FieldMetaData[] fmds = _meta.getFields();
        for (int i = 0; i < fmds.length; i++) {
            buf.append("  Field: (" + i + ")\n");
            buf.append("  Name: (" + fmds[i].getName() + ")\n");
            buf.append("  Value: (" + _data[i] + ")\n");
		}
		return buf.toString ();
	}
}