root/trunk/components/blitz/src/omero/util/IceMapper.java

/*
 *   $Id$
 *
 *   Copyright 2007 Glencoe Software, Inc. All rights reserved.
 *   Use is subject to license terms supplied in LICENSE.txt
 *
 */

package omero.util;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import static omero.rtypes.*;
import ome.api.IPojos;
import ome.conditions.InternalException;
import ome.model.IObject;
import ome.model.ModelBased;
import ome.system.Principal;
import ome.system.Roles;
import ome.util.Filterable;
import ome.util.ModelMapper;
import ome.util.ReverseModelMapper;
import ome.util.Utils;
import omeis.providers.re.RGBBuffer;
import omeis.providers.re.data.PlaneDef;
import omero.ApiUsageException;
import omero.RArray;
import omero.RBool;
import omero.RClass;
import omero.RDouble;
import omero.RFloat;
import omero.RInt;
import omero.RInternal;
import omero.RList;
import omero.RLong;
import omero.RObject;
import omero.RSet;
import omero.RString;
import omero.RTime;
import omero.RType;
import omero.ServerError;
import omero.romio.BlueBand;
import omero.romio.GreenBand;
import omero.romio.RedBand;
import omero.romio.XY;
import omero.romio.XZ;
import omero.romio.ZY;
import omero.sys.EventContext;
import omero.sys.Filter;
import omero.sys.Parameters;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import Ice.UserException;

/**
 * Responsible for the mapping of ome.* types to omero.* types and back again.
 * Not all types are bidirectional, rather only those mappings are needed that
 * actually appear in the blitz API.
 * 
 * As of Beta3.1, an {@link IceMapper} instance can also be configured to handle
 * return value mapping, though by default an exception will be thrown if
 * {@link #mapReturnValue(Object)} is called.
 */
public class IceMapper extends ome.util.ModelMapper implements
        ReverseModelMapper {

    private static Log log = LogFactory.getLog(IceMapper.class);

    // Return value mapping
    // =========================================================================

    private final ReturnMapping mapping;

    public IceMapper() {
        this.mapping = null;
    }

    public IceMapper(ReturnMapping mapping) {
        this.mapping = mapping;
    }

    public interface ReturnMapping {

        public Object mapReturnValue(IceMapper mapper, Object value)
                throws Ice.UserException;

    }

    public final static ReturnMapping VOID = new ReturnMapping() {

        public Object mapReturnValue(IceMapper mapper, Object value)
                throws UserException {
            if (value != null) {
                throw new IllegalArgumentException("Method is void");
            }
            return null;
        }

    };

    public final static ReturnMapping FILTERABLE = new ReturnMapping() {

        public Object mapReturnValue(IceMapper mapper, Object value)
                throws UserException {
            return mapper.map((Filterable) value);
        }

    };

    public final static ReturnMapping FILTERABLE_ARRAY = new ReturnMapping() {

        public Object mapReturnValue(IceMapper mapper, Object value)
                throws UserException {
            Filterable[] array = (Filterable[]) value;
            if (array == null) {
                return null;
            } else {
                List rv = new ArrayList(array.length);
                for (int i = 0; i < array.length; i++) {
                    rv.add(mapper.map(array[i]));
                }
                return rv;
            }
        }

    };

    public final static ReturnMapping FILTERABLE_COLLECTION = new ReturnMapping() {

        public Object mapReturnValue(IceMapper mapper, Object value)
                throws UserException {
            Collection<Filterable> coll = (Collection<Filterable>) value;
            if (coll == null) {
                return null;
            } else {
                List rv = new ArrayList();
                for (Filterable f : coll) {
                    rv.add(mapper.map(f));
                }
                return rv;
            }
        }

    };

    public final static ReturnMapping OBJECT_TO_RTYPE = new ReturnMapping() {
        public Object mapReturnValue(IceMapper mapper, Object value)
                throws Ice.UserException {
            return mapper.toRType(value);
        }
    };

    public final static ReturnMapping STRING_TO_RSTRING = new ReturnMapping() {

        public Object mapReturnValue(IceMapper mapper, Object value)
                throws Ice.UserException {
            String str = (String) value;
            return omero.rtypes.rstring(str);
        }
    };

    public final static ReturnMapping PRIMITIVE = new ReturnMapping() {

        public Object mapReturnValue(IceMapper mapper, Object value)
                throws Ice.UserException {
            if (value == null) {
                return null;
            } else {
                if (!IceMapper.isNullablePrimitive(value.getClass())) {
                    throw new RuntimeException(
                            "Object not nullable primitive: " + value);
                }
                Object rv = mapper.findTarget(value);
                return rv;
            }
        }
    };

    public final static ReturnMapping PRIMITIVE_MAP = new ReturnMapping() {

        public Object mapReturnValue(IceMapper mapper, Object value)
                throws Ice.UserException {
            if (value == null) {
                return null;
            } else {
                Map map = (Map) value;
                Map rv = new HashMap();
                for (Object k : map.keySet()) {
                    Object v = map.get(k);
                    if (k != null
                            && !IceMapper.isNullablePrimitive(k.getClass())) {
                        throw new RuntimeException(
                                "Key not nullable primitive: " + k);
                    }
                    if (v != null
                            && !IceMapper.isNullablePrimitive(v.getClass())) {
                        throw new RuntimeException(
                                "Object not nullable primitive: " + v);
                    }
                    Object kr = mapper.findTarget(k);
                    Object vr = mapper.findTarget(v);
                    rv.put(kr, vr);
                }
                return rv;
            }
        }
    };

    /**
     * Returns true only if the current mapping is the {@link #VOID} mapping.
     */
    public boolean isVoid() {
        return canMapReturnValue() && mapping == VOID;
    }

    /**
     * True if this instance has a {@link ReturnMapping}
     */
    public boolean canMapReturnValue() {
        return mapping != null;
    }

    /**
     * Convert the given Object via the set {@link ReturnMapping}. Throws a
     * {@link NullPointException} if no mapping is set.
     */
    public Object mapReturnValue(Object value) throws Ice.UserException {
        return mapping.mapReturnValue(this, value);
    }

    // Exception handling
    // =========================================================================

    public static ServerError fillServerError(ServerError se, Throwable t) {
        se.message = t.getMessage();
        se.serverExceptionClass = t.getClass().getName();
        se.serverStackTrace = stackAsString(t);
        return se;
    }

    public static String stackAsString(Throwable t) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        t.printStackTrace(pw);
        Throwable cause = t.getCause();
        while (cause != null && cause != t) {
            cause.printStackTrace(pw);
            t = cause;
            cause = t.getCause();
        }
        pw.flush();
        pw.close();

        return sw.getBuffer().toString();
    }

    // Classes
    // =========================================================================

    private static Class<? extends IObject> _class(String className) {
        Class k = null;
        try {
            k = Class.forName(className);
        } catch (Exception e) {
            // ok
        }
        return k;
    }

    public static Class<? extends IObject> omeroClass(String className,
            boolean strict) throws ApiUsageException {

        Class k = _class(className);

        // If that didn't work, try to prefix with "omero.model"
        if (k == null) {
            k = _class("omero.model." + className);
        }

        // If either of those attempts worked, map it with IceMap
        if (k != null) {
            k = IceMap.OMEROtoOME.get(k);
        }

        // For whatever reason, it's not valid. Log it.
        if (k == null) {
            if (log.isDebugEnabled()) {
                log.debug(className + " does not specify a valid class.");
            }
        }

        if (k == null && strict) {
            ApiUsageException aue = new ApiUsageException();
            aue.message = className + " does not specify a valid class.";
            throw aue;
        }

        // Return, even null.
        return k;
    }

    // Conversions
    // =========================================================================

    public RType toRType(Object o) throws omero.ApiUsageException {
        if (o == null) {
            return null;
        } else if (o instanceof RType) {
            return (RType) o;
        } else if (o instanceof Date) {
            Date date = (Date) o;
            omero.RTime time = rtime(date.getTime());
            return time;
        } else if (o instanceof Integer) {
            Integer i = (Integer) o;
            omero.RInt rint = rint(i);
            return rint;
        } else if (o instanceof Long) {
            Long lng = (Long) o;
            omero.RLong rlng = rlong(lng.longValue());
            return rlng;
        } else if (o instanceof Float) {
            Float flt = (Float) o;
            omero.RFloat rflt = rfloat(flt);
            return rflt;
        } else if (o instanceof Double) {
            Double dbl = (Double) o;
            omero.RDouble rdbl = rdouble(dbl.doubleValue());
            return rdbl;
        } else if (o instanceof String) {
            String str = (String) o;
            omero.RString rstr = rstring(str);
            return rstr;
        } else if (o instanceof IObject) {
            IObject obj = (IObject) o;
            omero.model.IObject om = (omero.model.IObject) map(obj);
            omero.RObject robj = robject(om);
            return robj;
        } else if (o instanceof Collection) {
            return rlist(map((Collection) o));
        } else if (o instanceof Map) {
            return rmap(map((Map) o));
        } else if (o instanceof omero.Internal) {
            return rinternal((omero.Internal) o);
        } else {
            throw new ApiUsageException(null, null,
                    "Unsupported conversion to rtype from:" + o);
        }
    }

    /**
     * Uses the omero.rtypes hierarchy to properly convert any {@link RType} to
     * its internal representation. This requires that the instance properly
     * implement {@link omero.rtypes.Conversion} otherwise ApiUsageException
     * will be thrown.
     * 
     * @param rt
     * @return
     * @throws omero.ApiUsageException
     */
    public Object fromRType(RType rt) throws omero.ApiUsageException {

        if (rt == null) {
            return null;
        }

        if (rt instanceof omero.rtypes.Conversion) {
            omero.rtypes.Conversion conv = (omero.rtypes.Conversion) rt;
            return conv.convert(this);
        } else {
            omero.ApiUsageException aue = new omero.ApiUsageException();
            aue.message = rt.getClass() + " is not a conversion type";
            throw aue;
        }

    }

    public static EventContext convert(ome.system.EventContext ctx) {
        EventContext ec = new EventContext();
        ec.sessionId = ctx.getCurrentSessionId();
        ec.sessionUuid = ctx.getCurrentSessionUuid();
        ec.eventId = ctx.getCurrentEventId();
        ec.eventType = ctx.getCurrentEventType();
        ec.groupId = ctx.getCurrentGroupId();
        ec.groupName = ctx.getCurrentGroupName();
        ec.userId = ctx.getCurrentUserId();
        ec.userName = ctx.getCurrentUserName();
        ec.leaderOfGroups = ctx.getLeaderOfGroupsList();
        ec.memberOfGroups = ctx.getMemberOfGroupsList();
        ec.isAdmin = ctx.isCurrentUserAdmin();
        ec.isReadOnly = ctx.isReadOnly();
        return ec;
    }

    public static omero.romio.RGBBuffer convert(RGBBuffer buffer) {
        omero.romio.RGBBuffer b = new omero.romio.RGBBuffer();
        b.bands = new byte[3][];
        b.bands[RedBand.value] = buffer.getRedBand();
        b.bands[GreenBand.value] = buffer.getGreenBand();
        b.bands[BlueBand.value] = buffer.getBlueBand();
        b.sizeX1 = buffer.getSizeX1();
        b.sizeX2 = buffer.getSizeX2();
        return b;
    }

    public static PlaneDef convert(omero.romio.PlaneDef def)
            throws omero.ApiUsageException {
        PlaneDef pd = new PlaneDef(def.slice, def.t);
        switch (def.slice) {
        case XY.value:
            pd.setZ(def.z);
            break;
        case ZY.value:
            pd.setX(def.x);
            break;
        case XZ.value:
            pd.setY(def.y);
            break;
        default:
            omero.ApiUsageException aue = new omero.ApiUsageException();
            aue.message = "Unknown slice for " + def;
            throw aue;
        }

        return pd;
    }

    public static Principal convert(omero.sys.Principal old) {
        if (old == null) {
            return null;
        }
        return new Principal(old.name, old.group, old.eventType);
    }

    public static omero.sys.Roles convert(Roles roles) {
        omero.sys.Roles r = new omero.sys.Roles();
        r.rootId = roles.getRootId();
        r.rootName = roles.getRootName();
        r.systemGroupId = roles.getSystemGroupId();
        r.systemGroupName = roles.getSystemGroupName();
        r.userGroupId = roles.getUserGroupId();
        r.userGroupName = roles.getUserGroupName();
        r.guestGroupName = roles.getGuestGroupName();
        return r;
    }

    public static RTime convert(Date date) {
        return rtime(date);
    }

    public static Timestamp convert(RTime time) {
        if (time == null) {
            return null;
        }
        return new Timestamp(time.getValue());
    }

    public ome.parameters.Parameters convert(Parameters params)
            throws ApiUsageException {

        if (params == null) {
            return null;
        }

        ome.parameters.Parameters p = new ome.parameters.Parameters();
        if (params.map != null) {
            for (String name : params.map.keySet()) {
                Object obj = params.map.get(name);
                p.add(convert(name, obj));
            }
        }
        if (params.theFilter != null) {
            p.setFilter(convert(params.theFilter));
        }
        return p;
    }

    public ome.parameters.QueryParameter convert(String key, Object o)
            throws ApiUsageException {

        if (o == null) {
            return null;
        }

        String name = key;
        Class klass = o.getClass();
        Object value = null;
        if (RType.class.isAssignableFrom(klass)) {
            value = fromRType((RType) o);
            // If fromRType passes correctly, then we're sure that we
            // can convert to rtypes.Conversion
            klass = ((Conversion) o).type();
        } else {
            omero.ApiUsageException aue = new omero.ApiUsageException();
            aue.message = "Query parameter must be a subclass of RType " + o;
            throw aue;
        }

        ome.parameters.QueryParameter qp = new ome.parameters.QueryParameter(
                name, klass, value);
        return qp;
    }

    public static ome.parameters.Filter convert(Filter f) {

        if (f == null) {
            return null;
        }

        ome.parameters.Filter filter = new ome.parameters.Filter();

        int offset = 0, limit = Integer.MAX_VALUE;
        if (f.offset != null) {
            offset = f.offset.getValue();
        }
        if (f.limit != null) {
            limit = f.limit.getValue();
        }
        filter.page(offset, limit);

        if (f.ownerId != null) {
            filter.owner(f.ownerId.getValue());
        }

        if (f.groupId != null) {
            filter.group(f.groupId.getValue());
        }

        if (f.unique) {
            filter.unique();
        }

        return filter;
    }

    /**
     * Overrides the findCollection logic of {@link ModelMapper}, since all
     * {@link Collection}s should be {@link List}s in Ice.
     * 
     * Originally necessitated by the Map<Long, Set<IObject>> return value of
     * {@link IPojos#findAnnotations(Class, Set, Set, Map)}
     */
    @Override
    public Collection findCollection(Collection source) {
        if (source == null) {
            return null;
        }

        Collection target = (Collection) model2target.get(source);
        if (null == target) {
            target = new ArrayList();
            model2target.put(source, target);
        }
        return target;
    }

    public List map(Filterable[] array) {
        if (array == null) {
            return null;
        } else if (array.length == 0) {
            return new ArrayList();
        } else {
            List l = new ArrayList(array.length);
            for (int i = 0; i < array.length; i++) {
                l.add(map(array[i]));
            }
            return l;
        }
    }

    // ~ For Reversing (omero->ome). Copied from ReverseModelMapper.
    // =========================================================================

    protected Map target2model = new IdentityHashMap();

    public ome.model.internal.Permissions convert(omero.model.Permissions p) {
        if (p == null) {
            return null;
        }
        return Utils.toPermissions(p.getPerm1());
    }

    // TODO copied with ModelMapper
    public boolean isImmutable(Object obj) {
        if (null == obj || obj instanceof Number || obj instanceof Number[]
                || obj instanceof String || obj instanceof String[]
                || obj instanceof Boolean || obj instanceof Boolean[]) {
            return true;
        }
        return false;
    }

    public Object reverse(Object source) throws ApiUsageException {
        if (source == null) {
            return null;
        } else if (Collection.class.isAssignableFrom(source.getClass())) {
            return reverse((Collection) source);
        } else if (ModelBased.class.isAssignableFrom(source.getClass())) {
            return reverse((ModelBased) source);
        } else if (isImmutable(source)) {
            return source;
        } else if (RType.class.isAssignableFrom(source.getClass())) {
            return fromRType((RType) source);
        } else {
            omero.ApiUsageException aue = new omero.ApiUsageException();
            aue.message = "Don't know how to reverse " + source;
            throw aue;
        }

    }

    /**
     * Copied from {@link ModelMapper#findCollection(Collection)} This could be
     * unified in that a method findCollection(Collection, Map) was added with
     * {@link ModelMapper} calling findCollection(source,model2target) and
     * {@link #reverseCollection(Collection)} calling
     * findCollection(source,target2model).
     * 
     * @param collection
     * @return
     */
    public Collection reverse(Collection source) { // FIXME throws
        // omero.ApiUsageException {
        return reverse(source, source == null ? null : source.getClass());
    }

    /**
     * Creates a collection assignable to the given type. Currently only
     * {@link Set} and {@link List} are supported, and {@link HashSet}s and
     * {@link ArrayList}s will be returned. The need for this arose from the
     * decision to have no {@link Set}s in the Ice Java mapping.
     * 
     * @param source
     * @param targetType
     * @return
     * @see ticket:684
     */
    public Collection reverse(Collection source, Class targetType) { // FIXME
        // throws
        // omero.ApiUsageException
        // {

        if (source == null) {
            return null;
        }

        Collection target = (Collection) target2model.get(source);
        if (null == target) {
            if (Set.class.isAssignableFrom(targetType)) {
                target = new HashSet();
            } else if (List.class.isAssignableFrom(targetType)) {
                target = new ArrayList();
            } else {
                // omero.ApiUsageException aue = new omero.ApiUsageException();
                // aue.message = "Unknown collection type "+targetType;
                // throw aue;
                throw new InternalException("Unknown collection type "
                        + targetType);
            }
            target2model.put(source, target);
            try {
                for (Object object : source) {
                    target.add(reverse(object));
                }
            } catch (ApiUsageException aue) { // FIXME reverse can't throw
                // ServerErrors!
                convertAndThrow(aue);
            }
        }
        return target;
    }

    /**
     * Supports the separate case of reversing for arrays. See
     * {@link #reverse(Collection, Class)} and {@link #map(Filterable[])}.
     * 
     * @param list<