OMEROMetadataStoreClient.java

/*
 * ome.formats.OMEROMetadataStoreClient
 *
 *------------------------------------------------------------------------------
 *  Copyright (C) 2006-2017 University of Dundee. All rights reserved.
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 *------------------------------------------------------------------------------
 *
 */

package ome.formats;

import static omero.rtypes.rbool;
import static omero.rtypes.rdouble;
import static omero.rtypes.rint;
import static omero.rtypes.rlong;
import static omero.rtypes.rstring;
import static omero.rtypes.rtime;

import static ome.formats.model.UnitsFactory.convertElectricPotential;
import static ome.formats.model.UnitsFactory.convertFrequency;
import static ome.formats.model.UnitsFactory.convertLength;
import static ome.formats.model.UnitsFactory.convertPower;
import static ome.formats.model.UnitsFactory.convertPressure;
import static ome.formats.model.UnitsFactory.convertTemperature;
import static ome.formats.model.UnitsFactory.convertTime;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Map.Entry;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import loci.formats.IFormatReader;
import loci.formats.ImageReader;
import loci.formats.meta.IMinMaxStore;
import loci.formats.meta.MetadataStore;
import ome.formats.enums.EnumerationProvider;
import ome.formats.enums.IQueryEnumProvider;
import ome.formats.importer.ImportEvent;
import ome.formats.importer.util.ClientKeepAlive;
import ome.formats.model.BlitzInstanceProvider;
import ome.formats.model.ChannelProcessor;
import ome.formats.model.IObjectContainerStore;
import ome.formats.model.InstanceProvider;
import ome.formats.model.InstrumentProcessor;
import ome.formats.model.ModelProcessor;
import ome.formats.model.PixelsProcessor;
import ome.formats.model.PlaneInfoProcessor;
import ome.formats.model.ReferenceProcessor;
import ome.formats.model.ShapeProcessor;
import ome.formats.model.TargetProcessor;
import ome.formats.model.WellProcessor;
import ome.units.quantity.ElectricPotential;
import ome.units.quantity.Frequency;
import ome.units.quantity.Length;
import ome.units.quantity.Power;
import ome.units.quantity.Pressure;
import ome.units.quantity.Temperature;
import ome.units.quantity.Time;
import ome.util.LSID;
import ome.xml.meta.MetadataRoot;
import ome.xml.model.AffineTransform;
import ome.xml.model.MapPair;
import ome.xml.model.enums.Compression;
import ome.xml.model.enums.FillRule;
import ome.xml.model.enums.FontFamily;
import ome.xml.model.enums.FontStyle;
import ome.xml.model.enums.IlluminationType;
import ome.xml.model.enums.Marker;
import ome.xml.model.enums.NamingConvention;
import ome.xml.model.enums.PixelType;
import ome.xml.model.primitives.Color;
import ome.xml.model.primitives.NonNegativeInteger;
import ome.xml.model.primitives.NonNegativeLong;
import ome.xml.model.primitives.PercentFraction;
import ome.xml.model.primitives.PositiveInteger;
import ome.xml.model.primitives.PositiveFloat;
import ome.xml.model.primitives.Timestamp;
import omero.RBool;
import omero.RDouble;
import omero.RInt;
import omero.RLong;
import omero.RString;
import omero.RTime;
import omero.ServerError;
import omero.client;
import omero.api.IAdminPrx;
import omero.api.IContainerPrx;
import omero.api.IQueryPrx;
import omero.api.IRenderingSettingsPrx;
import omero.api.IRepositoryInfoPrx;
import omero.api.IUpdatePrx;
import omero.api.MetadataStorePrx;
import omero.api.MetadataStorePrxHelper;
import omero.api.RawFileStorePrx;
import omero.api.RawPixelsStorePrx;
import omero.api.ServiceFactoryPrx;
import omero.api.ServiceInterfacePrx;
import omero.api.ThumbnailStorePrx;
import omero.constants.METADATASTORE;
import omero.grid.InteractiveProcessorPrx;
import omero.metadatastore.IObjectContainer;
import omero.model.AcquisitionMode;
import omero.model.Annotation;
import omero.model.Arc;
import omero.model.ArcType;
import omero.model.Binning;
import omero.model.BooleanAnnotation;
import omero.model.Channel;
import omero.model.CommentAnnotation;
import omero.model.ContrastMethod;
import omero.model.Correction;
import omero.model.Dataset;
import omero.model.DatasetI;
import omero.model.Detector;
import omero.model.DetectorSettings;
import omero.model.DetectorType;
import omero.model.Dichroic;
import omero.model.DimensionOrder;
import omero.model.DoubleAnnotation;
import omero.model.Ellipse;
import omero.model.Experiment;
import omero.model.ExperimentType;
import omero.model.ExperimenterGroup;
import omero.model.Filament;
import omero.model.FilamentType;
import omero.model.FileAnnotation;
import omero.model.FilesetJobLink;
import omero.model.Filter;
import omero.model.FilterSet;
import omero.model.FilterType;
import omero.model.Folder;
import omero.model.Format;
import omero.model.GenericExcitationSource;
import omero.model.IObject;
import omero.model.Illumination;
import omero.model.Image;
import omero.model.ImagingEnvironment;
import omero.model.Immersion;
import omero.model.Instrument;
import omero.model.Label;
import omero.model.Laser;
import omero.model.LaserMedium;
import omero.model.LaserType;
import omero.model.LightEmittingDiode;
import omero.model.LightPath;
import omero.model.LightSettings;
import omero.model.Line;
import omero.model.ListAnnotation;
import omero.model.LogicalChannel;
import omero.model.LongAnnotation;
import omero.model.MapAnnotation;
import omero.model.Mask;
import omero.model.Medium;
import omero.model.MicrobeamManipulation;
import omero.model.MicrobeamManipulationType;
import omero.model.Microscope;
import omero.model.MicroscopeType;
import omero.model.Objective;
import omero.model.ObjectiveSettings;
import omero.model.OriginalFile;
import omero.model.Permissions;
import omero.model.Pixels;
import omero.model.PixelsType;
import omero.model.PlaneInfo;
import omero.model.Plate;
import omero.model.PlateAcquisition;
import omero.model.Point;
import omero.model.Polygon;
import omero.model.Polyline;
import omero.model.Project;
import omero.model.ProjectI;
import omero.model.Pulse;
import omero.model.Reagent;
import omero.model.Rectangle;
import omero.model.Roi;
import omero.model.Screen;
import omero.model.ScreenI;
import omero.model.StageLabel;
import omero.model.TagAnnotation;
import omero.model.TermAnnotation;
import omero.model.TimestampAnnotation;
import omero.model.TransmittanceRange;
import omero.model.TransmittanceRangeI;
import omero.model.Well;
import omero.model.WellSample;
import omero.model.XmlAnnotation;
import omero.sys.EventContext;
import omero.sys.ParametersI;
import omero.util.IceMapper;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import Glacier2.CannotCreateSessionException;
import Glacier2.PermissionDeniedException;

/**
 * Client side implementation of the Bio-Formats {@link MetadataStore}. It is
 * responsible for handling metadata from Bio-Formats and maintaining
 * communication with an OMERO server.
 * @author Brian Loranger, brain at lifesci.dundee.ac.uk
 * @author Chris Allan, callan at lifesci.dundee.ac.uk
 */
public class OMEROMetadataStoreClient
    implements MetadataStore, IMinMaxStore, IObjectContainerStore
{

    /** Logger for this class */
    private Logger log = LoggerFactory.getLogger(OMEROMetadataStoreClient.class);

    private MetadataStorePrx delegate;

    /**
     * Begins empty to allow access to all groups. Once a target object
     * has been chosen, the id will be set to reflect the target.
     */
    private Long groupID = null;

    /** Our IObject container cache. */
    private Map<LSID, IObjectContainer> containerCache =
        new TreeMap<LSID, IObjectContainer>(new OMEXMLModelComparator());

    /** Our LSID reference cache. */
    private Map<LSID, List<LSID>> referenceCache =
        new HashMap<LSID, List<LSID>>();

    private Map<LSID, Set<LSID>> referenceCacheCheck =
        new HashMap<LSID, Set<LSID>>();

    /** Our authoritative LSID container cache. */
    private Map<Class<? extends IObject>, Map<String, IObjectContainer>>
        authoritativeContainerCache =
            new HashMap<Class<? extends IObject>, Map<String, IObjectContainer>>();

    /**
     * Our string based reference cache. This will be populated after all
     * model population has been completed by a ReferenceProcessor.
     */
    private Map<String, String[]> referenceStringCache;

    private LSID screenKey;

    /** Our model processors. Will be called on saveToDB(). */
    private List<ModelProcessor> modelProcessors;

    /** Bio-Formats reader that's populating us. */
    private IFormatReader reader;

    private OMEROMetadataStoreClientRoot pixelsList = new OMEROMetadataStoreClientRoot();

    private boolean encryptedConnection = false;

    private client c;
    private ServiceFactoryPrx serviceFactory;
    private EventContext eventContext;
    private IUpdatePrx iUpdate;
    private IQueryPrx iQuery;
    private IAdminPrx iAdmin;
    private RawFileStorePrx rawFileStore;
    private RawPixelsStorePrx rawPixelStore;
    private IRepositoryInfoPrx iRepoInfo;
    private IContainerPrx iContainer;
    private IRenderingSettingsPrx iSettings;
    private ThumbnailStorePrx thumbnailStore;

    /** Our enumeration provider. */
    private EnumerationProvider enumProvider;

    /** Our OMERO model object provider. */
    private InstanceProvider instanceProvider;

    /** Current pixels ID we're writing planes for. */
    private Long currentPixId;

    /** Annotations from the user for use by model processors. */
    private List<Annotation> userSpecifiedAnnotations;

    /** Image/Plate name the user specified for use by model processors. */
    private String userSpecifiedName;

    /** Image/Plate description the user specified for use by model processors. */
    private String userSpecifiedDescription;

    /** Filename of the log file where services will save logging output. */
    private String logFilename;

    /** Token passed together with the log file name into the call context. */
    private String token;

    /** Linkage target for all Images/Plates for use by model processors. */
    private IObject userSpecifiedTarget;

    /** Physical pixel sizes the user specified for use by model processors. */
    private Double[] userSpecifiedPhysicalPixelSizes;

    /** Image channel minimums and maximums. */
    private double[][][] imageChannelGlobalMinMax;

    /** Executor that will run our keep alive task. */
    private ScheduledThreadPoolExecutor executor;

    /** Emission filter LSID suffix.
     * See {@link #setFilterSetEmissionFilterRef(String, int, int, int)}
     * for an explanation of its usage.
     */
    public static final String OMERO_EMISSION_FILTER_SUFFIX =
        ":OMERO_EMISSION_FILTER";

    /** Excitation filter LSID suffix.
     * See {@link #setFilterSetExcitationFilterRef(String, int, int, int)}
     * for an explanation of its usage.
     */
    public static final String OMERO_EXCITATION_FILTER_SUFFIX =
        ":OMERO_EXCITATION_FILTER";

    /** The default longest side of a thumbnail in OMERO.insight. */
    private static final int DEFAULT_INSIGHT_THUMBNAIL_LONGEST_SIDE = 96;

    /** Keep alive runnable, pings all services. */
    private ClientKeepAlive keepAlive = new ClientKeepAlive();

    /**
     * Map of series vs. populated Image graph as set by <code>prepare</code>.
     * This map is valid for a single execution of <code>importImage()</code>
     * only.
     */
    private Map<Integer, Image> existingMetadata;

    /**
     * Returns clientKeepAlive created in store
     *
     * @return current ClientKeepAlive
     */
    public ClientKeepAlive getKeepAlive() {
        return keepAlive;
    }

    private void resetPixelsId(Long pixId) throws ServerError
    {
        if (pixId != null && !pixId.equals(currentPixId))
        {
            rawPixelStore.setPixelsId(pixId, true);
            currentPixId = pixId;
        }
    }

    public void logVersionInfo(String clientVersion) throws ServerError {
        if (serviceFactory != null) {
            log.info("Server: " + serviceFactory.getConfigService().getVersion());
        } else {
            log.info("Unknown server version (no service factory)");
        }
        if (clientVersion != null) {
            log.info("Client: " + clientVersion);
        } else {
            log.info("Unknown client version (null sent)");
        }
        log.info("Java Version: " + System.getProperty("java.version"));
        log.info("OS Name: " + System.getProperty("os.name"));
        log.info("OS Arch: " + System.getProperty("os.arch"));
        log.info("OS Version: " + System.getProperty("os.version"));
    }

    /**
     * Initialize all services needed
     *
     * @param manageLifecycle
     *
     *            Whether or not to call the {@link Thread#start()} method on
     *            the {@link #keepAlive} instance. This will be set to false
     *            when an {@link omero.client} or a {@link ServiceFactoryPrx}
     *            instance is provided to {@link #initialize(client)} since the
     *            assumption is that the consumer will take care of the keep
     *            alive. In that case, {@link #closeServices()} should be called
     *            when importing is finished.
     *
     *  @param group
     *
     *            Value to pass set in {@link #callCtx}
     *
     * @throws ServerError
     */
    private void initializeServices(boolean manageLifecycle)
        throws ServerError
    {

        closeServices();
        Map<String, String> callCtx = new HashMap<String, String>();
        if (groupID != null) {
            callCtx.put("omero.group", groupID.toString());
            log.info(String.format("Call context: {omero.group:%s}", groupID));
        }
        if (logFilename != null) {
            callCtx.put("omero.logfilename", logFilename);
            callCtx.put("omero.logfilename.token", token);
            log.info(String.format("Call context: {omero.logfilename:%s}",
                    logFilename));
        }

        // Blitz services
        iAdmin = (IAdminPrx) serviceFactory.getAdminService().ice_context(callCtx);
        iQuery = (IQueryPrx) serviceFactory.getQueryService().ice_context(callCtx);
        eventContext = iAdmin.getEventContext();
        iUpdate = (IUpdatePrx) serviceFactory.getUpdateService().ice_context(callCtx);
        rawFileStore = (RawFileStorePrx) serviceFactory.createRawFileStore().ice_context(callCtx);
        rawPixelStore = (RawPixelsStorePrx) serviceFactory.createRawPixelsStore().ice_context(callCtx);
        thumbnailStore = (ThumbnailStorePrx) serviceFactory.createThumbnailStore().ice_context(callCtx);
        iRepoInfo = (IRepositoryInfoPrx) serviceFactory.getRepositoryInfoService().ice_context(callCtx);
        iContainer = (IContainerPrx) serviceFactory.getContainerService().ice_context(callCtx);
        iSettings = (IRenderingSettingsPrx) serviceFactory.getRenderingSettingsService().ice_context(callCtx);
        delegate = (MetadataStorePrx) MetadataStorePrxHelper.checkedCast(
                serviceFactory.getByName(METADATASTORE.value)).ice_context(callCtx);

        // Client side services
        enumProvider = new IQueryEnumProvider(iQuery);
        instanceProvider = new BlitzInstanceProvider(enumProvider);

        // Default model processors
        modelProcessors = new ArrayList<ModelProcessor>();
        modelProcessors.add(new PixelsProcessor());
        modelProcessors.add(new ChannelProcessor());
        modelProcessors.add(new InstrumentProcessor());
        modelProcessors.add(new PlaneInfoProcessor());
        modelProcessors.add(new WellProcessor());
        modelProcessors.add(new ShapeProcessor());
        modelProcessors.add(new TargetProcessor());  // Should be second last
        modelProcessors.add(new ReferenceProcessor());  // Should be last

        // Fix check for broken 4.0 immersions table
        //checkImmersions();

        // Start our keep alive executor
        if (manageLifecycle)
        {
            if (executor == null)
            {
                executor = new ScheduledThreadPoolExecutor(1);
                executor.scheduleWithFixedDelay(keepAlive, 60, 60, TimeUnit.SECONDS);
            }
        }
        keepAlive.setClient(this); // This is used elsewhere.
    }

    /**
     * simpler helper for the {@link #getDefaultBatchSize()} and
     * {@link #getDefaultBlockSize()} methods.
     */
    private int getDefaultInt(String key, int def)
    {
        if (c != null)
        {
            try
            {
                return Integer.valueOf(c.getProperty(key));
            }

            catch (Exception e)
            {
                // pass. Return default
            }

        }
        return def;
    }

    /**
     * @return user-configured "omero.batch_size" or {@link omero.constants.DEFAULTBATCHSIZE}
     * if none is set.
     */
    public int getDefaultBatchSize()
    {
        return getDefaultInt("omero.batch_size", omero.constants.DEFAULTBATCHSIZE.value);
    }

    /**
     * @return user-configured "omero.block_size" or {@link omero.constants.DEFAULTBLOCKSIZE}
     * if none is set.
     */
    public int getDefaultBlockSize()
    {
        return getDefaultInt("omero.block_size", omero.constants.DEFAULTBLOCKSIZE.value);
    }

    /**
     * @return IQuery proxy
     */
    public IQueryPrx getIQuery()
    {
        return iQuery;
    }


    public void setEncryptedConnection(boolean encryptedConnection) {
        this.encryptedConnection = encryptedConnection;
    }

    public boolean isEncryptedConnection() {
        return encryptedConnection;
    }

    /**
     * Sets the id which will be used
     * to set the call context for all services. If null, the call context
     * will be left which will then use the context of the session.
     *
     * @param groupID the group ID to use for call contexts
     * @return the previous group ID, may be {@code null}
     */
    public Long setGroup(Long groupID) {
        Long old = this.groupID;
        this.groupID = groupID;
        return old;
    }

    /**
     * Initializes the MetadataStore with an already logged in, ready to go
     * service factory. When finished with this instance, close stateful
     * services via {@link #closeServices()}.
     * @param serviceFactory The factory. Mustn't be <code>null</code>.
     * @throws ServerError if the services could not be initialized
     */
    public void initialize(ServiceFactoryPrx serviceFactory)
        throws ServerError
    {
        if (serviceFactory == null)
            throw new IllegalArgumentException("No factory.");
        this.serviceFactory = serviceFactory;
        initializeServices(false);
    }

    /**
     * Initializes the MetadataStore with an already logged in, ready to go
     * service factory. When finished with this instance, close stateful
     * services via {@link #closeServices()}.
     *
     * @param c The client. Mustn't be <code>null</code>.
     * @throws ServerError if the services could not be initialized
     */
    public void initialize(omero.client c)
        throws ServerError
    {
        this.c = c;
        c.setAgent("OMERO.importer");
        serviceFactory = c.getSession();
        initializeServices(false);
    }

    /**
     * Initializes the MetadataStore taking string parameters to feed to the
     * OMERO Blitz client object. Using this method creates an unsecure
     * session. When finished with this instance, close all resources via
     * {@link #logout}
     *
     * @param username User's omename.
     * @param password User's password.
     * @param server Server hostname.
     * @param port Server port.
     * @throws CannotCreateSessionException If there is a session error when
     * creating the OMERO Blitz client object.
     * @throws PermissionDeniedException If there is a problem logging the user
     * in.
     * @throws ServerError If there is a critical error communicating with the
     * server.
     */
    public void initialize(String username, String password,
                           String server, int port)
        throws CannotCreateSessionException, PermissionDeniedException, ServerError
    {
    // Always make this an unsecure session
        initialize(username, password, server, port, false);
    }

    /**
     * Initializes the MetadataStore taking string parameters to feed to the
     * OMERO Blitz client object. Using this method to create either secure
     * or unsecure sessions. When finished with this instance, close all resources via
     * {@link #logout}
     *
     * @param username User's omename.
     * @param password User's password.
     * @param server Server hostname.
     * @param port Server port.
     * @param isSecure is this session secure
     * @throws CannotCreateSessionException If there is a session error when
     * creating the OMERO Blitz client object.
     * @throws PermissionDeniedException If there is a problem logging the user
     * in.
     * @throws ServerError If there is a critical error communicating with the
     * server.
     */
    public void initialize(String username, String password,
            String server, int port, boolean isSecure)
    throws CannotCreateSessionException, PermissionDeniedException, ServerError
    {
        secure(server, port);
        c.createSession(username, password);
    if (!isSecure)
    {
        unsecure();
    }
        initializeServices(true);
    }

    /**
     * Initializes the MetadataStore taking string parameters to feed to the
     * OMERO Blitz client object. Using this method to create either secure
     * or unsecure sessions and sets the user's group to supplied group.
     * When finished with this instance, close all resources via
     * {@link #logout}
     *
     * @param username User's omename.
     * @param password User's password.
     * @param server Server hostname.
     * @param port Server port.
     * @param group User's current group.
     * @param isSecure is this session secure
     * @throws CannotCreateSessionException If there is a session error when
     * creating the OMERO Blitz client object.
     * @throws PermissionDeniedException If there is a problem logging the user
     * in.
     * @throws ServerError If there is a critical error communicating with the
     * server.
     */
    public void initialize(String username, String password,
            String server, int port, Long group, boolean isSecure)
    throws CannotCreateSessionException, PermissionDeniedException, ServerError
    {
        secure(server, port);
        serviceFactory = c.createSession(username, password);
    if (!isSecure)
    {
        unsecure();
    }
        setGroup(group);
        initializeServices(true);
    }

    /**
     * Initializes the MetadataStore by joining an existing session.
     * Use this method only with unsecure sessions. When finished with this
     * instance, close all resources via {@link #logout}
     *
     * @param server Server hostname.
     * @param port Server port.
     * @param sessionKey Bind session key.
     * @throws CannotCreateSessionException if a session could not be created
     * @throws PermissionDeniedException if the services may not be initialized
     * @throws ServerError if the services could not be initialized
     */
    public void initialize(String server, int port, String sessionKey)
        throws CannotCreateSessionException, PermissionDeniedException, ServerError
    {
    // Always make this an 'unsecure' session
        initialize(server, port, sessionKey, false);
    }

    /**
     * Initializes the MetadataStore by joining an existing session.
     * Use this method only with unsecure sessions. When finished with this
     * instance, close all resources via {@link #logout}
     *
     * @param server Server hostname.
     * @param port Server port.
     * @param sessionKey Bind session key.
     * @param isSecure if a secure session should be created
     * @throws CannotCreateSessionException if a session could not be created
     * @throws PermissionDeniedException if the services may not be initialized
     * @throws ServerError if the services could not be initialized
     */
    public void initialize(String server, int port, String sessionKey, boolean isSecure)
        throws CannotCreateSessionException, PermissionDeniedException, ServerError
    {
        secure(server, port);
        serviceFactory = c.joinSession(sessionKey);
    if (!isSecure)
    {
            unsecure();
    }
        initializeServices(true);
    }

    /**
     * First phase of login is to make an SSL connection. Creates an
     * {@link omero.client} instance and calls {@link omero.client#setAgent(String)}
     * @param server
     * @param port
     * @throws CannotCreateSessionException
     * @throws PermissionDeniedException
     * @throws ServerError
     */
    private void secure(String server, int port) throws CannotCreateSessionException,
            PermissionDeniedException, ServerError {
        log.info(String.format(
                    "Attempting initial SSL connection to %s:%d",
                    server, port));
        c = new client(server, port);
        c.setAgent("OMERO.importer");
    }

    /**
     * Second phase of login is to drop down to a non-SSL connection. Uses
     * {@link omero.client#createClient(boolean)} to create a new instance and
     * closes the old.
     *
     * @throws ServerError
     * @throws CannotCreateSessionException
     * @throws PermissionDeniedException
     */
    private void unsecure() throws ServerError, CannotCreateSessionException,
            PermissionDeniedException {
        log.info("Insecure connection requested, falling back");
        omero.client tmp = c.createClient(false);
        logout();
        c = tmp;
        serviceFactory = c.getSession();
    }

    /**
     * Returns the currently active service factory.
     *
     * @return See above.
     */
    public ServiceFactoryPrx getServiceFactory()
    {
        return serviceFactory;
    }

    /**
     * Pings all registered OMERO Blitz proxies.
     *
     */
    public void ping()
    {
        try {
            serviceFactory.keepAllAlive(new ServiceInterfacePrx[]
                {iQuery, iAdmin, rawFileStore, rawPixelStore, thumbnailStore,
                iRepoInfo, iContainer, iUpdate, iSettings, delegate});
            log.debug("KeepAlive ping.");

        } catch (Exception e) {
            log.debug("KeepAlive failed.");
            throw new RuntimeException(e);
        }
    }

    //
    // SERVER-SIDE API
    //

    public void setCurrentLogFile(String logFilename, String token)
    {
        this.logFilename = logFilename;
        this.token = token;
    }

    public void updateFileSize(OriginalFile file, long size) throws ServerError {
        file = (OriginalFile) iQuery.get("OriginalFile", file.getId().getValue());
        file.setSize(rlong(size));
        iUpdate.saveObject(file);
    }

    //
    // ENUMERATIONS
    //

    /**
     * Sets the active enumeration provider.
     *
     * @param enumProvider Enumeration provider to use.
     */
    public void setEnumerationProvider(EnumerationProvider enumProvider)
    {
        this.enumProvider = enumProvider;
    }

    /**
     * Retrieves the active enumeration provider.
     *
     * @return See above.
     */
    public EnumerationProvider getEnumerationProvider()
    {
        return enumProvider;
    }

    /**
     * Sets the active instance provider.
     *
     * @param instanceProvider the instance provider to use
     */
    public void setInstanceProvider(InstanceProvider instanceProvider)
    {
        this.instanceProvider = instanceProvider;
    }

    /**
     * Retrieves the active instance provider.
     *
     * @return See above.
     */
    public InstanceProvider getInstanceProvider()
    {
        return instanceProvider;
    }

    //
    // RTYPES
    //

  /**
     * Transforms a Java type into the corresponding OMERO RType.
     *
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RInt toRType(Integer value)
    {
        return value == null? null : rint(value);
    }

    private omero.model.Time toRType(Time timeIncrement) {
        if (timeIncrement == null) return null;

        ome.model.enums.UnitsTime internal =
            ome.model.enums.UnitsTime.bySymbol(
                    timeIncrement.unit().getSymbol());

        omero.model.enums.UnitsTime ut =
            omero.model.enums.UnitsTime.valueOf(
                internal.toString());

        omero.model.Time t = new omero.model.TimeI();
        t.setValue(timeIncrement.value().doubleValue());
        t.setUnit(ut);

        return t;
    }


    /**
     * Transforms a Java type into the corresponding OMERO RType.
     *
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RInt toRType(NonNegativeInteger value)
    {
        return value == null? null : rint(value.getValue());
    }

    /**
     * Transforms a Java type into the corresponding OMERO RType.
     *
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RLong toRType(NonNegativeLong value)
    {
        return value == null? null : rlong(value.getValue());
    }

    /**
     * Transforms a Java type into the corresponding OMERO RType.
     *
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RDouble toRType(PositiveFloat value)
    {
        return value == null? null : rdouble(value.getValue());
    }

    /**
     * Transforms a Java type into the corresponding OMERO RType.
     *
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RDouble toRType(PercentFraction value)
    {
        return value == null? null : rdouble(value.getValue());
    }

    /**
     * Transforms a Java type into the corresponding OMERO RType.
     *
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RLong toRType(Long value)
    {
        return value == null? null : rlong(value);
    }

    /**
     * Transforms a Java type into the corresponding OMERO RType.
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RString toRType(String value)
    {
        return value == null? null : rstring(value);
    }

    /**
     * Transforms a Java type into the corresponding OMERO RType.
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RBool toRType(Boolean value)
    {
        return value == null? null : rbool(value);
    }

    /**
     * Transforms a Java type into the corresponding OMERO RType.
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RDouble toRType(Double value)
    {
        return value == null? null : rdouble(value);
    }

    /**
     * Transforms a Java type into the corresponding OMERO RType.
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RDouble toRType(Float value)
    {
        return value == null? null : rdouble(Double.parseDouble(value.toString()));
    }

    /**
     * Transforms a Java type into the corresponding OMERO RType.
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RTime toRType(Timestamp value)
    {
        return value == null? null : rtime(value.asInstant().getMillis());
    }

    /**
     * Transforms a Java type into the corresponding OMERO RType.
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RString toRType(NamingConvention value)
    {
        return value == null ? null : rstring(value.getValue());
    }

    /**
     * Transforms a Java type into the corresponding OMERO RType.
     * @param schemaTransform Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public omero.model.AffineTransform toRType(AffineTransform schemaTransform)
    {
        if (schemaTransform == null ||
                schemaTransform.getA00() == null || schemaTransform.getA01() == null || schemaTransform.getA02() == null ||
                schemaTransform.getA10() == null || schemaTransform.getA11() == null || schemaTransform.getA12() == null) {
            return null;
        }
        final omero.model.AffineTransform omeroTransform = new omero.model.AffineTransformI();
        omeroTransform.setA00(toRType(schemaTransform.getA00()));
        omeroTransform.setA01(toRType(schemaTransform.getA01()));
        omeroTransform.setA02(toRType(schemaTransform.getA02()));
        omeroTransform.setA10(toRType(schemaTransform.getA10()));
        omeroTransform.setA11(toRType(schemaTransform.getA11()));
        omeroTransform.setA12(toRType(schemaTransform.getA12()));
        return omeroTransform;
    }

    /**
     * Transforms a Java type into the corresponding OMERO RType.
     * @param value Java concrete type value.
     * @return RType or <code>null</code> if <code>value</code> is
     * <code>null</code>.
     */
    public RInt toRType(Color value)
    {
        return toRType(value.getValue());
    }

    //
    // CLOSING
    //

    private void closeQuietly(omero.api.StatefulServiceInterfacePrx prx)
    {
        if (prx != null) {
            try {
                prx.close();
            } catch (Ice.CommunicatorDestroyedException cde) {
                log.debug("Communicator already closed; cannot close " + prx);
            } catch (Exception e) {
                log.warn("Exception closing " + prx, e);
                log.debug(e.toString()); // slf4j migration: toString()
            }
        }
    }

    /**
     * Closes all stateful services.
     *
     * This method should be preferred over {@link #logout()} when initialized
     * via an {@link omero.client} or a {@link ServiceFactoryPrx} instance.
     *
     * @see #initialize(client)
     * @see #initialize(ServiceFactoryPrx)
     */
    public void closeServices()
    {
        closeQuietly(rawFileStore);
        rawFileStore = null;

        closeQuietly(rawPixelStore);
        rawPixelStore = null;

        closeQuietly(thumbnailStore);
        thumbnailStore = null;

        closeQuietly(delegate);
        delegate = null;

    }

    /**
     * Destroys the sessionFactory and closes the client.
     *
     * This method should not be called when initialized via an
     * {@link omero.client} or a {@link ServiceFactoryPrx} instance. * @see
     * #initialize(client)
     *
     * @see #initialize(ServiceFactoryPrx)
     * @see #closeServices()
     */
    public void logout()
    {
        closeServices();
        if (c != null)
        {
            log.debug("closing client session.");
            c.closeSession();
            c = null;
            log.debug("client closed.");
        }
        if (executor != null)
        {
            log.debug("Logout called, shutting keep alive down.");
            executor.shutdown();
            executor = null;
            log.debug("keepalive shut down.");
        }
    }

    /**
     * Prepares the metadata store using existing metadata that has been
     * pre-registered by OMERO.fs. The expected graph should be fully loaded:
     * <ul>
     *   <li>Image</li>
     *   <li>Pixels</li>
     * </ul>
     * <b>NOTE:</b> An execution of <code>prepare()</code> is only valid for
     * a <b>SINGLE</b> <code>importImage()</code> execution. Following
     * <code>importImage()</code> the existing metadata map will be reset
     * regardless of success or failure.
     * @param existingMetadata Map of imageIndex or series vs. populated Image
     * source graph with the fetched objects defined above.
     */
    public void prepare(Map<Integer, Image> existingMetadata)
    {
        this.existingMetadata = existingMetadata;
    }

    /**
     * Actually performs the preparation logic during createRoot().
     */
    private void prepare()
    {
        // Sanity check
        if (existingMetadata == null)
        {
            return;
        }

        IObjectContainer container;
        for (Entry<Integer, Image> entry : existingMetadata.entrySet())
        {
            Image image = entry.getValue();
            Integer series = entry.getKey();
            // Reset the image acquisition date as it has been inserted
            // erroneously by the OMERO.fs infrastructure.
            image.setAcquisitionDate(null);
            Pixels pixels = image.getPrimaryPixels();
            LinkedHashMap<Index, Integer> indexes =
                new LinkedHashMap<Index, Integer>();
            indexes.put(Index.IMAGE_INDEX, series);
            container = getIObjectContainer(Image.class, indexes);
            container.sourceObject = image;
            if (log.isDebugEnabled())
            {
                log.debug(String.format("Prepared(%d) == %s,%s",
                        series, container.sourceObject, container.LSID));
            }
            container = getIObjectContainer(Pixels.class, indexes);
            container.sourceObject = pixels;
            if (log.isDebugEnabled())
            {
                log.debug(String.format("Prepared(%d) == %s,%s",
                        series, container.sourceObject, container.LSID));
            }
        }
    }

    //
    // MetadataStore INTERFACE
    //

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#createRoot()
     */
    @Override
    public void createRoot()
    {
        try
        {
            log.debug("Creating root!");
            initializeServices(false); // Reset group
            authoritativeContainerCache =
                new HashMap<Class<? extends IObject>, Map<String, IObjectContainer>>();
            containerCache =
                new TreeMap<LSID, IObjectContainer>(new OMEXMLModelComparator());
            referenceCache = new HashMap<LSID, List<LSID>>();
            referenceCacheCheck = new HashMap<LSID, Set<LSID>>();
            referenceStringCache = null;
            imageChannelGlobalMinMax = null;
            userSpecifiedAnnotations = null;
            userSpecifiedName = null;
            userSpecifiedDescription = null;
            userSpecifiedTarget = null;
            userSpecifiedPhysicalPixelSizes = null;
            delegate.createRoot();
            // Ensures that any prepared objects go into the container cache
            prepare();
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
        finally
        {
            existingMetadata = null;
        }
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#getRoot(omx.xml.meta.MetadataRoot)
     */
    public MetadataRoot getRoot()
    {
        return pixelsList;
    }

    /**
     * Retrieves a given enumeration from the current enumeration provider.
     * @param klass Enumeration type.
     * @param value Enumeration value.
     * @return See above.
     */
    private IObject getEnumeration(Class<? extends IObject> klass, String value)
    {
        return enumProvider.getEnumeration(klass, value, false);
    }

    /**
     * Checks for duplicate authoritative LSIDs for a given class in the
     * container cache.
     * @param klass Filter class for IObjectContainer types.
     * @param lsid LSID to check against.
     */
    private void checkDuplicateLSID(Class<? extends IObject> klass, String lsid)
    {
        if (log.isTraceEnabled())
        {
            List<IObjectContainer> containers = getIObjectContainers(klass);
            for (IObjectContainer container : containers)
            {
                if (container.LSID.equals(lsid))
                {
                    log.trace(String.format("Duplicate LSID %s exists in %s,%s",
                            lsid, container.sourceObject, container.LSID));
                        return;
                }
            }
        }
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getReader()
     */
    public IFormatReader getReader()
    {
        return reader;
    }

    /**
     * Retrieves a Format enumeration for the current reader's type.
     * @return See above.
     */
    private Format getImageFormat()
    {
        IFormatReader reader = getReader();
        if (reader instanceof ImageReader) {
            reader = ((ImageReader) reader).getReader();
        }
        String value = reader.getClass().toString();
        value = value.replace("class loci.formats.in.", "");
        value = value.replace("Reader", "");
        return (Format) getEnumeration(Format.class, value);
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#setReader(loci.formats.IFormatReader)
     */
    @Override
    public void setReader(IFormatReader reader)
    {
        this.reader = reader;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getUserSpecifiedAnnotations()
     */
    public List<Annotation> getUserSpecifiedAnnotations()
    {
        return userSpecifiedAnnotations;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#setUserSpecifiedAnnotations(java.util.List)
     */
    @Override
    public void setUserSpecifiedAnnotations(List<Annotation> annotations)
    {
        this.userSpecifiedAnnotations = annotations;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getUserSpecifiedPlateName()
     */
    public String getUserSpecifiedName()
    {
        return userSpecifiedName;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getUserSpecifiedName()
     */
    public String getUserSpecifiedImageName()
    {
        return userSpecifiedName;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#setUserSpecifiedName(java.lang.String)
     */
    @Override
    public void setUserSpecifiedName(String name)
    {
        if (log.isDebugEnabled())
        {
            log.debug("Using user specified name: " + name);
        }
        this.userSpecifiedName = name;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getUserSpecifiedDescription()
     */
    public String getUserSpecifiedDescription()
    {
        return userSpecifiedDescription;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#setUserSpecifiedDescription(java.lang.String)
     */
    @Override
    public void setUserSpecifiedDescription(String description)
    {
        if (log.isDebugEnabled())
        {
            log.debug("Using user specified description: " + description);
        }
        this.userSpecifiedDescription = description;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getUserSpecifiedTarget()
     */
    public IObject getUserSpecifiedTarget()
    {
        return userSpecifiedTarget;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#setUserSpecifiedTarget(omero.model.IObject)
     */
    @Override
    public void setUserSpecifiedTarget(IObject target)
    {
        if (target instanceof Screen && null != screenKey) {
          log.info("deleting screen ref in favor of user-specified one");
          referenceCache.remove(screenKey);
        }
        this.userSpecifiedTarget = target;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getUserSpecifiedPhysicalPixelSizes()
     */
    public Double[] getUserSpecifiedPhysicalPixelSizes()
    {
        return userSpecifiedPhysicalPixelSizes;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#setUserSpecifiedPhysicalPixelSizes(java.lang.Double, java.lang.Double, java.lang.Double)
     */
    @Override
    public void setUserSpecifiedPhysicalPixelSizes(Double physicalSizeX,
                                                   Double physicalSizeY,
                                                   Double physicalSizeZ)
    {
        userSpecifiedPhysicalPixelSizes =
            new Double[] { physicalSizeX, physicalSizeY, physicalSizeZ };
    }

    /**
     * Retrieves the current list of model processors the metadata store is
     * using.
     * @return See above.
     */
    public List<ModelProcessor> getModelProcessors()
    {
        return modelProcessors;
    }

    /**
     * Sets the current set of model processors.
     * @param modelProcessors List of model processors to use.
     */
    public void setModelProcessors(List<ModelProcessor> modelProcessors)
    {
        this.modelProcessors = modelProcessors;
    }

    /**
     * Removes a model processor from use.
     * @param processor Model processor to remove.
     */
    public void removeModelProcessor(ModelProcessor processor)
    {
        modelProcessors.remove(processor);
    }

    /**
     * Adds a model processor to the end of the processing chain.
     * @param processor Model processor to add.
     * @return <code>true</code> as specified by {@link Collection#add(Object)}
     */
    public boolean addModelProcessor(ModelProcessor processor)
    {
        return modelProcessors.add(processor);
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getContainerCache()
     */
    public Map<LSID, IObjectContainer> getContainerCache()
    {
        return containerCache;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getReferenceCache()
     */
    public Map<LSID, List<LSID>> getReferenceCache()
    {
        return Collections.unmodifiableMap(referenceCache);
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getAuthoritativeContainerCache()
     */
    public Map<Class<? extends IObject>, Map<String, IObjectContainer>>
        getAuthoritativeContainerCache()
    {
        return authoritativeContainerCache;
    }

    /**
     * Adds a container to the authoritative LSID cache.
     * @param klass Type of container we're adding.
     * @param lsid String LSID of the container.
     * @param container Container to add.
     */
    private void addAuthoritativeContainer(Class<? extends IObject> klass,
        String lsid,
        IObjectContainer container)
    {
      Map<String, IObjectContainer> lsidContainerMap =
          authoritativeContainerCache.get(klass);
      if (lsidContainerMap == null)
      {
          lsidContainerMap = new HashMap<String, IObjectContainer>();
          authoritativeContainerCache.put(klass, lsidContainerMap);
      }
      lsidContainerMap.put(lsid, container);
    }

    /**
     * Adds a reference to the reference cache.
     * @param source Source LSID to add.
     * @param target Target LSID to add.
     */
    @Override
    public void addReference(LSID source, LSID target)
    {
        List<LSID> targets = null;
        Set<LSID> targetsCheck = null;
        if (referenceCache.containsKey(source))
        {
            targets = referenceCache.get(source);
            targetsCheck = referenceCacheCheck.get(source);
        }
        else
        {
            targets = new ArrayList<LSID>();
            targetsCheck = new HashSet<LSID>();
            referenceCache.put(source, targets);
            referenceCacheCheck.put(source, targetsCheck);
        }
        // Adding to a list is VERY slow.
        if (!targetsCheck.contains(target))
        {
            targetsCheck.add(target);
            targets.add(target);
        }
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getReferenceStringCache()
     */
    public Map<String, String[]> getReferenceStringCache()
    {
        return referenceStringCache;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#setReferenceStringCache(Map<String, String[]>)
     */
    @Override
    public void setReferenceStringCache(Map<String, String[]> referenceStringCache)
    {
        this.referenceStringCache = referenceStringCache;
    }

    /**
     * Retrieves an OMERO Blitz source object for a given Java class and
     * indexes.
     * @param klass Source object class.
     * @param indexes Indexes into the OME-XML data model.
     * @return See above.
     */
    @SuppressWarnings("unchecked")
    private <T extends IObject> T getSourceObject(Class<T> klass, LinkedHashMap<Index, Integer> indexes)
    {
        return (T) getIObjectContainer(klass, indexes).sourceObject;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getSourceObject(ome.util.LSID)
     */
    public IObject getSourceObject(LSID LSID)
    {
        IObjectContainer o = containerCache.get(LSID);
        if (o == null)
        {
            return null;
        }
        return o.sourceObject;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getSourceObjects(java.lang.Class)
     */
    @SuppressWarnings("unchecked")
    public <T extends IObject> List<T> getSourceObjects(Class<T> klass)
    {
        List<IObjectContainer> containers = getIObjectContainers(klass);
        List<T> toReturn = new ArrayList<T>(containers.size());
        for (IObjectContainer container: containers)
        {
            toReturn.add((T) container.sourceObject);
        }
        return toReturn;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#hasReference(ome.util.LSID, ome.util.LSID)
     */
    public boolean hasReference(LSID source, LSID target)
    {
        if (!referenceCache.containsKey(source)
            || !referenceCache.get(source).contains(target))
        {
            return false;
        }
        return true;
    }

    /**
     * Sets the path, name and repo in the pixels table.
     * @param pixelsId the ID of the Pixels object
     * @param file the file's filename, with path in the repository
     * @param repo the file's repository's UUID
     * @throws ServerError in the event of a server error
     */
    public void setPixelsFile(long pixelsId, String file, String repo) throws ServerError {
        try
        {
            delegate.setPixelsFile(pixelsId, file, repo);
        }
        catch (Exception e)
        {
            log.error("Server error setting extended properties for Pixels:" +
                      pixelsId + " Target file:" + file, e);
            throw e instanceof RuntimeException ?
                (RuntimeException) e : new RuntimeException(e);
        }
    }

    /**
     * Changes the default group of the currently logged in user.
     *
     * @param groupID The id of the group.
     * @throws ServerError if the group could not be set or the services initialized accordingly
     */
    public void setCurrentGroup(long groupID)
        throws ServerError
    {
        setGroup(groupID);
        initializeServices(false);
    }

    /**
     * Retrieves the groups visible by the current experimenter.
     *
     * @return List of ExperimenterGroups the user is in
     * @throws Exception If an error occurred while trying to
     * retrieve data from OMERO service.
     */
    List<ExperimenterGroup> getUserGroups()
        throws ServerError
    {
        List<ExperimenterGroup> myGroups = new ArrayList<ExperimenterGroup>();
        //Need method server side.
        ParametersI p = new ParametersI();
        p.addId(eventContext.userId);
        List<IObject> groups = iQuery.findAllByQuery(
            "select distinct g from ExperimenterGroup as g "
            + "join fetch g.groupExperimenterMap as map "
            + "join fetch map.parent e "
            + "left outer join fetch map.child u "
            + "left outer join fetch u.groupExperimenterMap m2 "
            + "left outer join fetch m2.parent p "
            + "where g.id in "
            + "  (select m.parent from GroupExperimenterMap m "
            + "  where m.child.id = :id )", p);

        ExperimenterGroup group;
        Iterator<IObject> i = groups.iterator();
        while (i.hasNext()) {
            group = (ExperimenterGroup) i.next();
            myGroups.add(group);
        }
        return myGroups;
    }

    /**
     * Maps the user's groups for use by ScreenLogin.registerGroup()
     * Also strips system groups from this map
     *
     * @return map of group id & name
     * @throws ServerError if the groups could not be mapped
     */
    public Map<Long, String> mapUserGroups() throws ServerError
    {
        List<String> systemGroups = new ArrayList<String>();
        systemGroups.add("system");
        systemGroups.add("user");
        systemGroups.add("guest");

        Map<Long, String> names = new LinkedHashMap<Long, String>();

        List<ExperimenterGroup> groups = getUserGroups();

        if (groups == null || groups.size() == 0)
            return null;

        ExperimenterGroup currentDefaultGroup =
            iAdmin.getDefaultGroup(eventContext.userId);

        Iterator<ExperimenterGroup> i = groups.iterator();
        ExperimenterGroup group = null;

        // Add all groups excluding the default group
        while (i.hasNext()) {
            group = i.next();

            String n = group.getName() == null ? null : group.getName().getValue();

            if (!systemGroups.contains(n) && group.getId().getValue() != currentDefaultGroup.getId().getValue()) {
                names.put(group.getId().getValue(), group.getName().getValue());
            }
        }

        String dn = currentDefaultGroup.getName() == null ? null
            : currentDefaultGroup.getName().getValue();

        // Add the default group last (unless its a system group)
        if (!systemGroups.contains(dn))
            names.put(currentDefaultGroup.getId().getValue(),
            currentDefaultGroup.getName().getValue());

        if (names.size() == 0) names = null;
        return names;
    }

    /**
     * Retrieve the default group's name
     *
     * @return the name of the default group
     * @throws ServerError if the default group could not be retrieved
     */
    public String getDefaultGroupName() throws ServerError
    {
        ExperimenterGroup currentDefaultGroup =
            iAdmin.getDefaultGroup(eventContext.userId);

        String dn = currentDefaultGroup.getName() == null ? ""
            : currentDefaultGroup.getName().getValue();

        return dn;
    }

    /**
     * Retrieve the default group's permission 'level'.
     *
     * @return ImportEvent's group level
     * @throws ServerError if the default group could not be retrieved
     */
    @Deprecated
    public int getDefaultGroupLevel() throws ServerError {

        int groupLevel = 0;

        ExperimenterGroup currentDefaultGroup =
            iAdmin.getDefaultGroup(eventContext.userId);

        Permissions perm = currentDefaultGroup.getDetails().getPermissions();

        if (perm.isGroupRead()) {
            if (perm.isGroupWrite())  groupLevel = ImportEvent.GROUP_COLLAB_READ_LINK;
            else groupLevel = ImportEvent.GROUP_COLLAB_READ;
        }
        else if (perm.isWorldRead()) {
            groupLevel = ImportEvent.GROUP_PUBLIC;
        } else {
            groupLevel = ImportEvent.GROUP_PRIVATE;
        }
        return groupLevel;
    }

    /**
     * @return repository space as a long
     */
    public long getRepositorySpace()
    {
        try
        {
            return iRepoInfo.getFreeSpaceInKilobytes();
        } catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * Post processes the internal structure of the client side MetadataStore.
     * Should be called before {@link #saveToDB(FilesetJobLink)}.
     */
    public void postProcess()
    {
        // Perform model processing
        for (ModelProcessor processor : modelProcessors)
        {
            processor.process(this);
        }
    }

    /**
     * Updates the server side MetadataStore with a list of our objects and
     * references and saves them into the database.
     * @param link the link to save to the database
     * @return List of Pixels after database commit.
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public Map<String, List<IObject>> saveToDB(FilesetJobLink link)
    {
        try
        {
            Collection<IObjectContainer> containers = containerCache.values();
            IObjectContainer[] containerArray =
                containers.toArray(new IObjectContainer[containers.size()]);

            if (log.isDebugEnabled())
            {
                log.debug("Starting containers....");
                for (LSID key : containerCache.keySet())
                {
                    String s = String.format("%s == %s,%s",
                            key, containerCache.get(key).sourceObject,
                            containerCache.get(key).LSID);
                    log.debug(s);
                }

                log.debug("Starting references....");
                for (String key : referenceStringCache.keySet())
                {
                    for (String value : referenceStringCache.get(key))
                    {
                        String s = String.format("%s == %s", key, value);
                        log.debug(s);
                    }
                }

                log.debug("containerCache contains " + containerCache.size()
                          + " entries.");
                log.debug("referenceCache contains " + countCachedReferences(null, null)
                          + " entries.");
            }

            int maxBatchSize = getDefaultBatchSize();
            int containerBatchCount = 0;
            int containerPointer = 0;
            log.info("Handling # of containers: {}", containerArray.length);
            while (containerPointer < containerArray.length)
            {
                int nObjects = (int) Math.min(
                    maxBatchSize, containerArray.length - containerPointer);

                IObjectContainer[] batch = Arrays.copyOfRange(
                        containerArray, containerPointer, containerPointer+nObjects);

                delegate.updateObjects(batch);
                containerPointer += nObjects;

                containerBatchCount += 1;
                if (containerBatchCount > 1)
                {
                    log.info("Starting containerBatch #{}", containerBatchCount);
                }
            }

            int referenceBatchCount = 0;
            int referencePointer = 0;
            String[] referenceKeys = referenceStringCache.keySet().toArray(
              new String[referenceStringCache.size()]);

            log.info("Handling # of references: {}", referenceKeys.length);
            while (referencePointer < referenceKeys.length) {

                referenceBatchCount += 1;
                if (referenceBatchCount > 1)
                {
                    log.info("Starting referenceBatch #{}", referenceBatchCount);
                }

                Map<String, String[]> referenceBatch = new HashMap<String, String[]>();
                int batchSize = (int) Math.min(
                    maxBatchSize, referenceKeys.length - referencePointer);
                for (int i=0; i<batchSize; i++) {
                    String key = referenceKeys[referencePointer + i];
                    referenceBatch.put(key, referenceStringCache.get(key));
                }
                delegate.updateReferences(referenceBatch);
                referencePointer += batchSize;
            }

            Map<String, List<IObject>> rv = delegate.saveToDB(link);
            pixelsList = new OMEROMetadataStoreClientRoot((List) rv.get("Pixels"));

            if (log.isDebugEnabled())
            {
                long pixelsId;
                for (Pixels pixels : pixelsList)
                {
                    pixelsId = pixels.getId().getValue();
                    log.debug("Saved Pixels with ID: "  + pixelsId);
                }
            }
            return rv;
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    public List<InteractiveProcessorPrx> launchProcessing()
    {
        try {
            return delegate.postProcess();
        } catch (Exception e) {
            // Because this method is evolving, we're going to
            // permit an exception to not stop import. Eventually,
            // this could be dangerous. ~Josh.
            log.warn("Failed to launch post-processing", e);
            return null;
        }
    }

    /**
     * Helper method to retrieve an object from iQuery
     *
     * @param <T> the kind of model object to retrieve
     * @param klass the class of the model object
     * @param id the ID of the model object
     * @return the model object
     */
    @SuppressWarnings("unchecked")
    public <T extends IObject> T getTarget(Class<T> klass, long id)
    {
        try
        {
            Map<String, String> allGroups = new HashMap<String, String>();
            allGroups.put("omero.group", "-1");
            T obj = (T) iQuery.get(klass.getName(), id, allGroups);
            if (obj == null) {
                throw new RuntimeException(String.format("Cannot find target: %s:%s",
                            klass.getName(), id));
            }
            long grpID = obj.getDetails().getGroup().getId().getValue();
            if (grpID != eventContext.groupId) {
                throw new RuntimeException(String.format("Target container in group: %s, not current group: %s",
                            grpID, eventContext.groupId));
            }
            setCurrentGroup(grpID);
            return obj;
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * @param projectId
     * @return project with given id
     */
    public Project getProject(long projectId)
    {
        try
        {
            return (Project) iQuery.get("Project", projectId);
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * @param datasetName the name of the dataset
     * @param datasetDescription the description of the dataset
     * @param project the project in which the dataset is (if any)
     * @return the newly persisted dataset
     */
    public Dataset addDataset(String datasetName, String datasetDescription,
            Project project)
    {
        Dataset dataset = new DatasetI();
        if (datasetName.length() != 0)
            dataset.setName(toRType(datasetName));
        if (datasetDescription.length() != 0)
            dataset.setDescription(toRType(datasetDescription));
        if (project.getId() != null) {
            Project p = new ProjectI(project.getId().getValue(), false);
            dataset.linkProject(p);
        }

        try
        {
            return (Dataset) iUpdate.saveAndReturnObject(dataset);
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * @return - experimenter id
     */
    public long getExperimenterID()
    {
        return eventContext.userId;
    }

    /**
     * Retrieves a configuration value from the <code>IConfig</code> service.
     * @param key Key for the string encoded value.
     * @return String encoded configuration value.
     */
    public String getConfigValue(String key)
    {
        try
        {
            return serviceFactory.getConfigService().getConfigValue(key);
        }
        catch (omero.SecurityViolation sv)
        {
            return null;
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * @return the screens
     */
    public List<Screen> getScreens()
    {
        try
        {
            List<IObject> objects =
                iContainer.loadContainerHierarchy(Screen.class.getName(), null, new ParametersI().exp(rlong(getExperimenterID())));
            List<Screen> screens = new ArrayList<Screen>(objects.size());
            for (IObject object : objects)
            {
                screens.add((Screen) object);
            }
            return screens;
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }


    /**
     * @return the projects
     */
    public List<Project> getProjects()
    {
        try
        {
            List<IObject> objects =
                iContainer.loadContainerHierarchy(Project.class.getName(), null, new ParametersI().exp(rlong(getExperimenterID())));
            List<Project> projects = new ArrayList<Project>(objects.size());
            for (IObject object : objects)
            {
                projects.add((Project) object);
            }

            Collections.sort(projects, new SortProjectsByName());

            return projects;
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * @param p the project whose datasets to get ({@code null} for orphaned datasets)
     * @return the datasets
     */
    public List<Dataset> getDatasets(Project p)
    {
        if (p.getId() == null || p.getId().getValue() == 0)
            return getDatasetsWithoutProjects();
        try
        {
            List<Long> ids = new ArrayList<Long>(1);
            ids.add(p.getId().getValue());
            List<IObject> objects =
                iContainer.loadContainerHierarchy(Project.class.getName(), ids, null);
            if (objects.size() > 0)
            {
                Project project = (Project) objects.get(0);

                List<Dataset> datasets = project.linkedDatasetList();
                Collections.sort(datasets, new SortDatasetsByName());
                return datasets;
            }
            return null;
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * @return the orphaned datasets
     */
    public List<Dataset> getDatasetsWithoutProjects()
    {
        try
        {
            ParametersI param = new ParametersI();
            param.exp(rlong(getExperimenterID()));
            param.orphan();
            List<IObject> objects =
                iContainer.loadContainerHierarchy(Project.class.getName(), null, param);
            List<Dataset> datasets = new ArrayList<Dataset>(0);
            for (IObject object : objects)
            {
                if (object instanceof DatasetI)
                    datasets.add((Dataset) object);
            }
            return datasets;
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * @param projectName the name of the project
     * @param projectDescription the description of the project
     * @return the newly persisted project
     */
    public Project addProject(String projectName, String projectDescription)
    {
        Project project = new ProjectI();
        if (projectName.length() != 0)
            project.setName(toRType(projectName));
        if (projectDescription.length() != 0)
            project.setDescription(toRType(projectDescription));

        try
        {
            return (Project) iUpdate.saveAndReturnObject(project);
        } catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * @param screenName the name of the screen
     * @param screenDescription the description of the screen
     * @return the newly persisted screen
     */
    public Screen addScreen(String screenName, String screenDescription)
    {
        Screen screen = new ScreenI();
        if (screenName.length() != 0)
            screen.setName(toRType(screenName));
        if (screenDescription.length() != 0)
            screen.setDescription(toRType(screenDescription));

        try
        {
            return (Screen) iUpdate.saveAndReturnObject(screen);
        } catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * Prepares the server side RawPixelsStore.
     * @param pixelsIds List of Pixels IDs we'll be populating.
     */
    public void preparePixelsStore(List<Long> pixelsIds)
    {
        try
        {
            rawPixelStore.prepare(pixelsIds);
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * Closes the active raw pixels store. Finalizing any open server side
     * resources.
     *
     * The call to close on the RawPixelsStorePrx may throw, in which case
     * the current import should be considered failed, since the saving of
     * the pixels server-side will have not completed successfully.
     *
     * @throws ServerError if the pixel store could not be finalized or a new one created
     * @see <a href="http://trac.openmicroscopy.org/ome/ticket/5594">Trac ticket #5594</a>
     */
    public void finalizePixelStore() throws ServerError
    {
        if (rawPixelStore != null)
        {
            try
            {
                rawPixelStore.close();
            } finally
            {
                rawPixelStore = null;
            }
        }
        rawPixelStore = serviceFactory.createRawPixelsStore();
    }

    /**
     * Retrieves the suggested tile size for a pixels set.
     * @param pixId Pixels set to write to.
     * @return Width and height of the tile as an array.
     * @throws ServerError If there is an error writing this tile to the
     * server.
     */
    public int[] getTileSize(Long pixId)
        throws ServerError
    {
        resetPixelsId(pixId);
        return rawPixelStore.getTileSize();
    }

    /**
     * Writes a tile of pixels to the server.
     * @param pixId Pixels set to write to.
     * @param arrayBuf Byte array containing all pixels for this plane.
     * @param z Z offset within the Pixels set.
     * @param c Channel offset within the Pixels set.
     * @param t Timepoint offset within the Pixels set.
     * @param x X offset of the tile.
     * @param y Y offset of the tile.
     * @param w Width of the tile.
     * @param h Height of the tile.
     * @throws ServerError If there is an error writing this tile to the
     * server.
     * @see #setPlane(Long, byte[], int, int, int)
     */
    public void setTile(Long pixId, byte[] arrayBuf, int z, int c, int t,
                        int x, int y, int w, int h)
        throws ServerError
    {
        resetPixelsId(pixId);
        rawPixelStore.setTile(arrayBuf, z, c, t, x, y, w, h);
    }

    /**
     * Writes a plane to the server.
     * @param pixId Pixels set to write to.
     * @param arrayBuf Byte array containing all pixels for this plane.
     * @param z Z offset within the Pixels set.
     * @param c Channel offset within the Pixels set.
     * @param t Timepoint offset within the Pixels set.
     * @throws ServerError If there is an error writing this plane to the
     * server.
     */
    public void setPlane(Long pixId, byte[] arrayBuf, int z, int c, int t)
        throws ServerError
    {
        resetPixelsId(pixId);
        rawPixelStore.setPlane(arrayBuf, z, c, t);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.IMinMaxStore#setChannelGlobalMinMax(int, double, double, int)
     */
    @Override
    public void setChannelGlobalMinMax(int channel, double minimum,
            double maximum, int series)
    {
        Pixels pixels =
            (Pixels) getSourceObject(new LSID(Pixels.class, series));
        if (imageChannelGlobalMinMax == null)
        {
            int imageCount = countCachedContainers(Image.class);
            imageChannelGlobalMinMax = new double[imageCount][][];
        }
        double[][] channelGlobalMinMax = imageChannelGlobalMinMax[series];
        if (channelGlobalMinMax == null)
        {
            imageChannelGlobalMinMax[series] = channelGlobalMinMax =
                new double[pixels.getSizeC().getValue()][];
        }
        double[] globalMinMax = channelGlobalMinMax[channel];
        if (globalMinMax == null)
        {
            imageChannelGlobalMinMax[series][channel] = globalMinMax =
                new double[2];
        }
        globalMinMax[0] = minimum;
        globalMinMax[1] = maximum;
    }

    /**
     * Updates a list of Pixels.
     * @param pixelsList List of Pixels to update.
     */
    public void updatePixels(List<Pixels> pixelsList)
    {
        try
        {
            List<IObject> objectList = new ArrayList<IObject>(pixelsList.size());
            for (Pixels pixels : pixelsList)
            {
                pixels.unloadPixelsFileMaps();
                pixels.unloadPlaneInfo();
                pixels.unloadSettings();
                pixels.unloadThumbnails();
                pixels.unloadDetails();
                objectList.add(pixels);
            }
            iUpdate.saveArray(objectList);
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * Sends all the minimums and maximums for all images processed so far to
     * the server.
     */
    public void populateMinMax()
    {
        try
        {
            delegate.populateMinMax(imageChannelGlobalMinMax);
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * Resets the defaults and generates thumbnails for a given set of Pixels
     * IDs.
     * @param plateIds Set of Plate IDs to reset defaults and thumbnails for.
     * @param pixelsIds Set of Pixels IDs to reset defaults and thumbnails for.
     */
    public void resetDefaultsAndGenerateThumbnails(List<Long> plateIds,
        List<Long> pixelsIds)
    {
        try
        {
            if (plateIds.size() > 0)
            {
                iSettings.resetDefaultsInSet("Plate", plateIds);
            }
            else
            {
                iSettings.resetDefaultsInSet("Pixels", pixelsIds);
            }
            thumbnailStore.createThumbnailsByLongestSideSet(
                rint(DEFAULT_INSIGHT_THUMBNAIL_LONGEST_SIDE), pixelsIds);
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    //////////////////////////////////////////////

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getIObjectContainer(java.lang.Class, java.util.LinkedHashMap)
     */
    public IObjectContainer getIObjectContainer(Class<? extends IObject> klass,
                                                LinkedHashMap<Index, Integer> indexes)
    {
        // Transform an integer collection into an integer array without using
        // wrapper objects.
        Collection<Integer> indexValues = indexes.values();
        int[] indexesArray = new int[indexValues.size()];
        int i = 0;
        for (Integer index : indexValues)
        {
            indexesArray[i] = index;
            i++;
        }

        // Create a new LSID.
        LSID lsid = new LSID(klass, indexesArray);

        Map<String, Integer> asString = new HashMap<String, Integer>();
        for (Entry<Index, Integer> v : indexes.entrySet())
        {
            asString.put(v.getKey().toString(), v.getValue());
        }

        if (!containerCache.containsKey(lsid))
        {
            IObjectContainer c = new IObjectContainer();
            c.indexes = asString;
            c.LSID = lsid.toString();
            c.sourceObject = getSourceObjectInstance(klass);
            containerCache.put(lsid, c);
        }

        return containerCache.get(lsid);
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#removeIObjectContainer(ome.util.LSID)
     */
    @Override
    public void removeIObjectContainer(LSID lsid)
    {
        containerCache.remove(lsid);
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#getIObjectContainers(java.lang.Class)
     */
    @SuppressWarnings("unchecked")
    public List<IObjectContainer> getIObjectContainers(Class<? extends IObject> klass)
    {
        Set<LSID> keys = containerCache.keySet();
        List<IObjectContainer> toReturn = new ArrayList<IObjectContainer>();
        for (LSID key : keys)
        {
            Class<? extends IObject> keyClass = key.getJavaClass();
            if (keyClass != null && keyClass.equals(klass))
            {
                toReturn.add(containerCache.get(key));
            }
        }
        return toReturn;
    }

    /**
     * Performs the task of actual source object instantiation using
     * reflection.
     * @param klass Class to instantiate a source object for.
     * @return An OMERO Blitz model object.
     */
    private <T extends IObject> T getSourceObjectInstance(Class<T> klass)
    {
        return instanceProvider.getInstance(klass);
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#countCachedContainers(java.lang.Class, int[])
     */
    @SuppressWarnings("unchecked")
    public int countCachedContainers(Class<? extends IObject> klass,
                                     int... indexes)
    {
        if (klass == null)
        {
            return new HashSet<IObjectContainer>(containerCache.values()).size();
        }

        int count = 0;
        for (LSID lsid : containerCache.keySet())
        {
            Class<? extends IObject> lsidClass = lsid.getJavaClass();
            if (lsidClass != null && lsidClass.equals(klass))
            {
                if (indexes == null)
                {
                    // We're just doing a class match, increment the count
                    count++;
                }
                else
                {
                    // We're doing a class and index match, loop over and
                    // check the indexes based on the shortest array.
                    int[] lsidIndexes = lsid.getIndexes();
                    int n = Math.min(indexes.length, lsidIndexes.length);
                    boolean match = true;
                    for (int i = 0; i < n; i++)
                    {
                        if (lsidIndexes[i] != indexes[i])
                        {
                            match = false;
                            break;
                        }
                    }
                    if (match)
                    {
                        count++;
                    }
                }
            }
        }
        return count;
    }

    /* (non-Javadoc)
     * @see ome.formats.model.IObjectContainerStore#countCachedReferences(java.lang.Class, java.lang.Class)
     */
    public int countCachedReferences(Class<? extends IObject> source,
                                     Class<? extends IObject> target)
    {
        if (source == null && target == null)
        {
            int count = 0;
            for (LSID key : referenceCache.keySet())
            {
                count += referenceCache.get(key).size();
            }
            return count;
        }

        int count = 0;
        if (target == null)
        {
            for (LSID lsid : referenceCache.keySet())
            {
                Class<?> containerClass = lsid.getJavaClass();
                if (containerClass.equals(source))
                {
                    count++;
                }
            }
            return count;
        }

        if (source == null)
        {
            for (LSID sourceLSID : referenceCache.keySet())
            {
                for (LSID targetLSID : referenceCache.get(sourceLSID))
                {
                    Class<?> containerClass = targetLSID.getJavaClass();
                    if (containerClass.equals(target))
                    {
                        count++;
                    }
                }
            }
            return count;
        }

        for (LSID sourceLSID : referenceCache.keySet())
        {
            Class<?> sourceClass = sourceLSID.getJavaClass();
            if (sourceClass.equals(source))
            {
            for (LSID targetLSID : referenceCache.get(sourceLSID))
                {
                    Class<?> targetClass = targetLSID.getJavaClass();
                    if (targetClass.equals(target))
                    {
                        count++;
                    }
                }
            }
        }
        return count;
    }




    /*
     *
     * Bio-formats method calls start here
     *
     */


    //////// Arc /////////

    /**
     * Retrieve Arc
     * @param instrumentIndex the index of the instrument
     * @param lightSourceIndex the index of the light source within the instrument
     * @return the arc
     */
    private Arc getArc(int instrumentIndex, int lightSourceIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.LIGHT_SOURCE_INDEX, lightSourceIndex);
        return getSourceObject(Arc.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setArcID(java.lang.String, int, int)
     */
    @Override
    public void setArcID(String id, int instrumentIndex, int lightSourceIndex)
    {
        checkDuplicateLSID(Arc.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.LIGHT_SOURCE_INDEX, lightSourceIndex);
        IObjectContainer o = getIObjectContainer(Arc.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Arc.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setArcLotNumber(java.lang.String, int, int)
     */
    @Override
    public void setArcLotNumber(String lotNumber, int instrumentIndex,
            int lightSourceIndex)
    {
        Arc o = getArc(instrumentIndex, lightSourceIndex);
        o.setLotNumber(toRType(lotNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setArcManufacturer(java.lang.String, int, int)
     */
    @Override
    public void setArcManufacturer(String manufacturer, int instrumentIndex,
            int lightSourceIndex)
    {
        Arc o = getArc(instrumentIndex, lightSourceIndex);
        o.setManufacturer(toRType(manufacturer));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setArcModel(java.lang.String, int, int)
     */
    @Override
    public void setArcModel(String model, int instrumentIndex,
            int lightSourceIndex)
    {
        Arc o = getArc(instrumentIndex, lightSourceIndex);
        o.setModel(toRType(model));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setArcPower(java.lang.Double, int, int)
     */
    @Override
    public void setArcPower(Power power, int instrumentIndex,
            int lightSourceIndex)
    {
        Arc o = getArc(instrumentIndex, lightSourceIndex);
        o.setPower(convertPower(power));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setArcSerialNumber(java.lang.String, int, int)
     */
    @Override
    public void setArcSerialNumber(String serialNumber, int instrumentIndex,
            int lightSourceIndex)
    {
        Arc o = getArc(instrumentIndex, lightSourceIndex);
        o.setSerialNumber(toRType(serialNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setArcType(ome.xml.model.enums.ArcType, int, int)
     */
    @Override
    public void setArcType(ome.xml.model.enums.ArcType type,
            int instrumentIndex, int lightSourceIndex)
    {
        Arc o = getArc(instrumentIndex, lightSourceIndex);
        o.setType((ArcType) getEnumeration(ArcType.class, type.toString()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setArcType(ome.xml.model.enums.ArcType, int, int)
     */
    @Override
    public void setArcAnnotationRef(String annotation, int instrumentIndex, int lightSourceIndex, int annotationRefIndex)
    {
        LSID key = new LSID(Arc.class, instrumentIndex, lightSourceIndex);
        addReference(key, new LSID(annotation));
    }

    //////// BooleanAnnotation /////////

    /**
     * @param booleanAnnotationIndex the index of the Boolean annotation
     * @return the Boolean annotation
     */
    private BooleanAnnotation getBooleanAnnotation(int booleanAnnotationIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.BOOLEAN_ANNOTATION_INDEX, booleanAnnotationIndex);
        return getSourceObject(BooleanAnnotation.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setBooleanAnnotationID(java.lang.String, int)
     */
    @Override
    public void setBooleanAnnotationID(String id, int booleanAnnotationIndex)
    {
        checkDuplicateLSID(BooleanAnnotation.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.BOOLEAN_ANNOTATION_INDEX, booleanAnnotationIndex);
        IObjectContainer o = getIObjectContainer(BooleanAnnotation.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(BooleanAnnotation.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setBooleanAnnotationNamespace(java.lang.String, int)
     */
    @Override
    public void setBooleanAnnotationNamespace(String namespace,
            int booleanAnnotationIndex)
    {
        BooleanAnnotation o = getBooleanAnnotation(booleanAnnotationIndex);
        o.setNs(toRType(namespace));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setBooleanAnnotationValue(java.lang.Boolean, int)
     */
    @Override
    public void setBooleanAnnotationValue(Boolean value,
            int booleanAnnotationIndex)
    {
        BooleanAnnotation o = getBooleanAnnotation(booleanAnnotationIndex);
        o.setBoolValue(toRType(value));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setBinaryOnlyUUID(java.lang.String)
     */
    @Override
    public void setBinaryOnlyUUID(String uuid)
    {
        ignoreUnneeded("BinaryOnlyUUID", uuid);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setBinaryOnlyMetadataFile(java.lang.String)
     */
    @Override
    public void setBinaryOnlyMetadataFile(String metadataFile)
    {
        ignoreUnneeded("BinaryMetadataFile", metadataFile);
    }

    //////// Channel /////////

    public Channel getChannel(int imageIndex, int channelIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.IMAGE_INDEX, imageIndex);
        indexes.put(Index.CHANNEL_INDEX, channelIndex);
        Channel c = getSourceObject(Channel.class, indexes);
        c.setLogicalChannel(getSourceObject(LogicalChannel.class, indexes));
        return getSourceObject(Channel.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelID(java.lang.String, int, int)
     */
    @Override
    public void setChannelID(String id, int imageIndex, int channelIndex)
    {
        checkDuplicateLSID(Channel.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.IMAGE_INDEX, imageIndex);
        indexes.put(Index.CHANNEL_INDEX, channelIndex);
        IObjectContainer o = getIObjectContainer(Channel.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Channel.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelAcquisitionMode(ome.xml.model.enums.AcquisitionMode, int, int)
     */
    @Override
    public void setChannelAcquisitionMode(
            ome.xml.model.enums.AcquisitionMode acquisitionMode,
            int imageIndex, int channelIndex)
    {
        Channel o = getChannel(imageIndex, channelIndex);
        o.getLogicalChannel().setMode((AcquisitionMode) getEnumeration(AcquisitionMode.class, acquisitionMode.toString()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setChannelColor(Color color, int imageIndex, int channelIndex)
    {
        Channel o = getChannel(imageIndex, channelIndex);
        o.setRed(toRType(color.getRed()));
        o.setGreen(toRType(color.getGreen()));
        o.setBlue(toRType(color.getBlue()));
        o.setAlpha(toRType(color.getAlpha()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelContrastMethod(ome.xml.model.enums.ContrastMethod, int, int)
     */
    @Override
    public void setChannelContrastMethod(
            ome.xml.model.enums.ContrastMethod contrastMethod,
            int imageIndex, int channelIndex)
    {
        Channel o = getChannel(imageIndex, channelIndex);
        o.getLogicalChannel().setContrastMethod((ContrastMethod) getEnumeration(ContrastMethod.class, contrastMethod.toString()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelEmissionWavelength(ome.xml.model.primitives.PositiveFloat, int, int)
     */
    @Override
    public void setChannelEmissionWavelength(
            Length emissionWavelength, int imageIndex, int channelIndex)
    {
        Channel o = getChannel(imageIndex, channelIndex);
        o.getLogicalChannel().setEmissionWave(convertLength(emissionWavelength));
    }

    /**
     * @see loci.formats.meta.MetadataStore#setChannelExcitationWavelength(Length, int, int)
     */
    @Override
    public void setChannelExcitationWavelength(
            Length excitationWavelength, int imageIndex,
            int channelIndex)
    {
        Channel o = getChannel(imageIndex, channelIndex);
        o.getLogicalChannel().setExcitationWave(convertLength(excitationWavelength));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelFilterSetsjava.lang.String, int, int)
     */
    @Override
    public void setChannelFilterSetRef(String filterSet, int imageIndex,
            int channelIndex)
    {
        LSID key = new LSID(LogicalChannel.class, imageIndex, channelIndex);
        addReference(key, new LSID(filterSet));

    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelFluor(java.lang.String, int, int)
     */
    @Override
    public void setChannelFluor(String fluor, int imageIndex, int channelIndex)
    {
        Channel o = getChannel(imageIndex, channelIndex);
        o.getLogicalChannel().setFluor(toRType(fluor));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelIlluminationType(ome.xml.model.enums.IlluminationType, int, int)
     */
    @Override
    public void setChannelIlluminationType(IlluminationType illuminationType,
            int imageIndex, int channelIndex)
    {
        Channel o = getChannel(imageIndex, channelIndex);
        o.getLogicalChannel().setIllumination((Illumination) getEnumeration(Illumination.class, illuminationType.toString()));
    }


    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelNDFilter(java.lang.Double, int, int)
     */
    @Override
    public void setChannelNDFilter(Double ndfilter, int imageIndex,
            int channelIndex)
    {
        Channel o = getChannel(imageIndex, channelIndex);
        o.getLogicalChannel().setNdFilter(toRType(ndfilter));
    }


    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelName(java.lang.String, int, int)
     */
    @Override
    public void setChannelName(String name, int imageIndex, int channelIndex)
    {
        Channel o = getChannel(imageIndex, channelIndex);
        o.getLogicalChannel().setName(toRType(name));
    }


    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelPinholeSize(java.lang.Double, int, int)
     */
    @Override
    public void setChannelPinholeSize(Length pinholeSize, int imageIndex,
            int channelIndex)
    {
        Channel o = getChannel(imageIndex, channelIndex);
        o.getLogicalChannel().setPinHoleSize(convertLength(pinholeSize));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelPockelCellSetting(java.lang.Integer, int, int)
     */
    @Override
    public void setChannelPockelCellSetting(Integer pockelCellSetting,
            int imageIndex, int channelIndex)
    {
        Channel o = getChannel(imageIndex, channelIndex);
        o.getLogicalChannel().setPockelCellSetting(toRType(pockelCellSetting));
    }


    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelSamplesPerPixel(java.lang.Integer, int, int)
     */
    @Override
    public void setChannelSamplesPerPixel(PositiveInteger samplesPerPixel,
            int imageIndex, int channelIndex)
    {
        Channel o = getChannel(imageIndex, channelIndex);
        o.getLogicalChannel().setSamplesPerPixel(toRType(samplesPerPixel));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelAnnotationRef(java.lang.String, int, int, int)
     */
    @Override
    public void setChannelAnnotationRef(String annotation, int imageIndex,
            int channelIndex, int annotationRefIndex)
    {
        LSID key = new LSID(Channel.class, imageIndex, channelIndex);
        addReference(key, new LSID(annotation));
    }

     ////////Lightsource Settings/////////

    /**
     * Logical Channel and Channel combined in the new model
     *
     * @param imageIndex the index of the image
     * @param channelIndex the index of the channel within the image
     * @return the light settings
     */
    private LightSettings getChannelLightSourceSettings(int imageIndex, int channelIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.IMAGE_INDEX, imageIndex);
        indexes.put(Index.CHANNEL_INDEX, channelIndex);
        return getSourceObject(LightSettings.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelLightSourceSettingsID(java.lang.String, int, int)
     */
    @Override
    public void setChannelLightSourceSettingsID(String id, int imageIndex,
            int channelIndex)
    {
        getChannelLightSourceSettings(imageIndex, channelIndex);
        LSID key = new LSID(LightSettings.class, imageIndex, channelIndex);
        addReference(key, new LSID(id));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelLightSourceSettingsAttenuation(ome.xml.model.primitives.PercentFraction, int, int)
     */
    @Override
    public void setChannelLightSourceSettingsAttenuation(
            PercentFraction attenuation, int imageIndex, int channelIndex)
    {
        LightSettings o = getChannelLightSourceSettings(imageIndex, channelIndex);
        o.setAttenuation(toRType(attenuation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setChannelLightSourceSettingsWavelength(ome.xml.model.primitives.PositiveFloat, int, int)
     */
    @Override
    public void setChannelLightSourceSettingsWavelength(
            Length wavelength, int imageIndex, int channelIndex)
    {
        LightSettings o = getChannelLightSourceSettings(imageIndex, channelIndex);
        o.setWavelength(convertLength(wavelength));
    }

    ////////Dataset/////////

    @Override
    public void setDatasetID(String id, int datasetIndex)
    {
        ignoreUnsupported("setDatasetID", id, datasetIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDatasetAnnotationRef(java.lang.String, int, int)
     */
    @Override
    public void setDatasetAnnotationRef(String annotation, int datasetIndex,
            int annotationRefIndex)
    {
        ignoreUnsupported("setDatasetAnnotationRef", annotation, datasetIndex,
                annotationRefIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDatasetDescription(java.lang.String, int)
     */
    @Override
    public void setDatasetDescription(String description, int datasetIndex)
    {
        ignoreUnsupported("setDatasetDescription", description, datasetIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDatasetExperimenterRef(java.lang.String, int)
     */
    @Override
    public void setDatasetExperimenterRef(String experimenter, int datasetIndex)
    {
        ignoreUnsupported("setDatasetExperimenterRef", experimenter,
                datasetIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDatasetExperimenterGroupRef(java.lang.String, int)
     */
    @Override
    public void setDatasetExperimenterGroupRef(String group, int datasetIndex)
    {
        ignoreUnsupported("setDatasetExperimenterGroupRef",
                group, datasetIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDatasetName(java.lang.String, int)
     */
    @Override
    public void setDatasetName(String name, int datasetIndex)
    {
        ignoreUnsupported("setDatasetName", name, datasetIndex);
    }

    ////////Detector/////////

    /**
     * @param instrumentIndex the instrument index
     * @param detectorIndex the detector index within the instrument
     * @return the detector
     */
    public Detector getDetector(int instrumentIndex, int detectorIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.DETECTOR_INDEX, detectorIndex);
        return getSourceObject(Detector.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorID(java.lang.String, int, int)
     */
    @Override
    public void setDetectorID(String id, int instrumentIndex, int detectorIndex)
    {
        checkDuplicateLSID(Detector.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.DETECTOR_INDEX, detectorIndex);
        IObjectContainer o = getIObjectContainer(Detector.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Detector.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorAmplificationGain(java.lang.Double, int, int)
     */
    @Override
    public void setDetectorAmplificationGain(Double amplificationGain,
            int instrumentIndex, int detectorIndex)
    {
        Detector o = getDetector(instrumentIndex, detectorIndex);
        o.setAmplificationGain(toRType(amplificationGain));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorGain(java.lang.Double, int, int)
     */
    @Override
    public void setDetectorGain(Double gain, int instrumentIndex,
            int detectorIndex)
    {
        Detector o = getDetector(instrumentIndex, detectorIndex);
        o.setGain(toRType(gain));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorLotNumber(java.lang.String, int, int)
     */
    @Override
    public void setDetectorLotNumber(String lotNumber, int instrumentIndex,
            int detectorIndex)
    {
        Detector o = getDetector(instrumentIndex, detectorIndex);
        o.setLotNumber(toRType(lotNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorManufacturer(java.lang.String, int, int)
     */
    @Override
    public void setDetectorManufacturer(String manufacturer,
            int instrumentIndex, int detectorIndex)
    {
        Detector o = getDetector(instrumentIndex, detectorIndex);
        o.setManufacturer(toRType(manufacturer));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorModel(java.lang.String, int, int)
     */
    @Override
    public void setDetectorModel(String model, int instrumentIndex,
            int detectorIndex)
    {
        Detector o = getDetector(instrumentIndex, detectorIndex);
        o.setModel(toRType(model));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorOffset(java.lang.Double, int, int)
     */
    @Override
    public void setDetectorOffset(Double offset, int instrumentIndex,
            int detectorIndex)
    {
        Detector o = getDetector(instrumentIndex, detectorIndex);
        o.setOffsetValue(toRType(offset));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorSerialNumber(java.lang.String, int, int)
     */
    @Override
    public void setDetectorSerialNumber(String serialNumber,
            int instrumentIndex, int detectorIndex)
    {
        Detector o = getDetector(instrumentIndex, detectorIndex);
        o.setSerialNumber(toRType(serialNumber));
    }


    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorType(ome.xml.model.enums.DetectorType, int, int)
     */
    @Override
    public void setDetectorType(ome.xml.model.enums.DetectorType type,
            int instrumentIndex, int detectorIndex)
    {
        Detector o = getDetector(instrumentIndex, detectorIndex);
        o.setType((DetectorType) getEnumeration(DetectorType.class, type.toString()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorVoltage(java.lang.Double, int, int)
     */
    @Override
    public void setDetectorVoltage(ElectricPotential voltage, int instrumentIndex,
            int detectorIndex)
    {
        Detector o = getDetector(instrumentIndex, detectorIndex);
        o.setVoltage(convertElectricPotential(voltage));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorZoom(java.lang.Double, int, int)
     */
    @Override
    public void setDetectorZoom(Double zoom, int instrumentIndex,
            int detectorIndex)
    {
        Detector o = getDetector(instrumentIndex, detectorIndex);
        o.setZoom(toRType(zoom));
    }

    ////////Detector Settings/////////

    /**
     * @param imageIndex the index of the image
     * @param channelIndex the index of the channel within the image
     * @return the detector settings
     */
    private DetectorSettings getDetectorSettings(int imageIndex, int channelIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.IMAGE_INDEX, imageIndex);
        indexes.put(Index.CHANNEL_INDEX, channelIndex);
        return getSourceObject(DetectorSettings.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorSettingsID(java.lang.String, int, int)
     */
    @Override
    public void setDetectorSettingsID(String id, int imageIndex,
            int channelIndex)
    {
        getDetectorSettings(imageIndex, channelIndex);
        LSID key = new LSID(DetectorSettings.class, imageIndex, channelIndex);
        addReference(key, new LSID(id));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorSettingsBinning(ome.xml.model.enums.Binning, int, int)
     */
    @Override
    public void setDetectorSettingsBinning(
            ome.xml.model.enums.Binning binning, int imageIndex,
            int channelIndex)
    {
        DetectorSettings o = getDetectorSettings(imageIndex, channelIndex);
        o.setBinning((Binning) getEnumeration(Binning.class, binning.toString()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorSettingsGain(java.lang.Double, int, int)
     */
    @Override
    public void setDetectorSettingsGain(Double gain, int imageIndex,
            int channelIndex)
    {
        DetectorSettings o = getDetectorSettings(imageIndex, channelIndex);
        o.setGain(toRType(gain));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorSettingsIntegration(ome.xml.model.primitives.PositiveInteger,int,int)
     */
    @Override
    public void  setDetectorSettingsIntegration(PositiveInteger integration, int imageIndex, int channelIndex)
    {
        DetectorSettings o = getDetectorSettings(imageIndex, channelIndex);
        o.setIntegration(toRType(integration));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorSettingsOffset(java.lang.Double, int, int)
     */
    @Override
    public void setDetectorSettingsOffset(Double offset, int imageIndex,
            int channelIndex)
    {
        DetectorSettings o = getDetectorSettings(imageIndex, channelIndex);
        o.setOffsetValue(toRType(offset));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorSettingsReadOutRate(java.lang.Double, int, int)
     */
    @Override
    public void setDetectorSettingsReadOutRate(Frequency readOutRate,
            int imageIndex, int channelIndex)
    {
        DetectorSettings o = getDetectorSettings(imageIndex, channelIndex);
        o.setReadOutRate(convertFrequency(readOutRate));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorSettingsVoltage(java.lang.Double, int, int)
     */
    @Override
    public void setDetectorSettingsVoltage(ElectricPotential voltage, int imageIndex,
            int channelIndex)
    {
        DetectorSettings o = getDetectorSettings(imageIndex, channelIndex);
        o.setVoltage(convertElectricPotential(voltage));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorSettingsZoom(java.lang.Double,int,int)
     */
    @Override
    public void  setDetectorSettingsZoom(Double zoom, int imageIndex, int channelIndex)
    {
        DetectorSettings o = getDetectorSettings(imageIndex, channelIndex);
        o.setZoom(toRType(zoom));
    }

    ////////Dichroic/////////

    /**
     * @param instrumentIndex the index of the instrument
     * @param dichroicIndex the index of the dichroic within the instrument
     * @return the dichroic
     */
    private Dichroic getDichroic(int instrumentIndex, int dichroicIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.DICHROIC_INDEX, dichroicIndex);
        return getSourceObject(Dichroic.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDichroicID(java.lang.String, int, int)
     */
    @Override
    public void setDichroicID(String id, int instrumentIndex, int dichroicIndex)
    {
        checkDuplicateLSID(Dichroic.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.DICHROIC_INDEX, dichroicIndex);
        IObjectContainer o = getIObjectContainer(Dichroic.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Dichroic.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDichroicLotNumber(java.lang.String, int, int)
     */
    @Override
    public void setDichroicLotNumber(String lotNumber, int instrumentIndex,
            int dichroicIndex)
    {
        Dichroic o = getDichroic(instrumentIndex, dichroicIndex);
        o.setLotNumber(toRType(lotNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDichroicManufacturer(java.lang.String, int, int)
     */
    @Override
    public void setDichroicManufacturer(String manufacturer,
            int instrumentIndex, int dichroicIndex)
    {
        Dichroic o = getDichroic(instrumentIndex, dichroicIndex);
        o.setManufacturer(toRType(manufacturer));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDichroicModel(java.lang.String, int, int)
     */
    @Override
    public void setDichroicModel(String model, int instrumentIndex,
            int dichroicIndex)
    {
        Dichroic o = getDichroic(instrumentIndex, dichroicIndex);
        o.setModel(toRType(model));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDichroicSerialNumber(java.lang.String, int, int)
     */
    @Override
    public void setDichroicSerialNumber(String serialNumber,
            int instrumentIndex, int dichroicIndex)
    {
        Dichroic o = getDichroic(instrumentIndex, dichroicIndex);
        o.setSerialNumber(toRType(serialNumber));
    }

    ////////Double Annotation/////////

    private DoubleAnnotation getDoubleAnnotation(int doubleAnnotationIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.DOUBLE_ANNOTATION_INDEX, doubleAnnotationIndex);
        return getSourceObject(DoubleAnnotation.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDoubleAnnotationID(java.lang.String, int)
     */
    @Override
    public void setDoubleAnnotationID(String id, int doubleAnnotationIndex)
    {
        checkDuplicateLSID(DoubleAnnotation.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.DOUBLE_ANNOTATION_INDEX, doubleAnnotationIndex);
        IObjectContainer o = getIObjectContainer(DoubleAnnotation.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(DoubleAnnotation.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDoubleAnnotationNamespace(java.lang.String, int)
     */
    @Override
    public void setDoubleAnnotationNamespace(String namespace,
            int doubleAnnotationIndex)
    {
        DoubleAnnotation o = getDoubleAnnotation(doubleAnnotationIndex);
        o.setNs(toRType(namespace));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDoubleAnnotationValue(java.lang.Double, int)
     */
    @Override
    public void setDoubleAnnotationValue(Double value, int doubleAnnotationIndex)
    {
        DoubleAnnotation o = getDoubleAnnotation(doubleAnnotationIndex);
        o.setDoubleValue(toRType(value));
    }

    ////////Eclipse/////////

    /**
     * @param ROIIndex the index of the ROI
     * @param shapeIndex the index of the shape within the ROI
     * @return the ellipse
     */
    private Ellipse getEllipse(int ROIIndex, int shapeIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        return getSourceObject(Ellipse.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseID(java.lang.String, int, int)
     */
    @Override
    public void setEllipseID(String id, int ROIIndex, int shapeIndex)
    {
        checkDuplicateLSID(Ellipse.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        IObjectContainer o = getIObjectContainer(Ellipse.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Ellipse.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseFillColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setEllipseFillColor(Color fill, int ROIIndex, int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setFillColor(toRType(fill));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseFontSize(java.lang.Integer, int, int)
     */
    @Override
    public void setEllipseFontSize(Length fontSize, int ROIIndex,
            int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setFontSize(convertLength(fontSize));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseText(java.lang.String, int, int)
     */
    @Override
    public void setEllipseText(String text, int ROIIndex, int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setTextValue(toRType(text));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseRadiusX(java.lang.Double, int, int)
     */
    @Override
    public void setEllipseRadiusX(Double radiusX, int ROIIndex, int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setRadiusX(toRType(radiusX));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseRadiusY(java.lang.Double, int, int)
     */
    @Override
    public void setEllipseRadiusY(Double radiusY, int ROIIndex, int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setRadiusY(toRType(radiusY));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseStrokeColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setEllipseStrokeColor(Color stroke, int ROIIndex, int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setStrokeColor(toRType(stroke));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseStrokeDashArray(java.lang.String, int, int)
     */
    @Override
    public void setEllipseStrokeDashArray(String strokeDashArray, int ROIIndex,
            int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setStrokeDashArray(toRType(strokeDashArray));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseStrokeWidth(java.lang.Double, int, int)
     */
    @Override
    public void setEllipseStrokeWidth(Length strokeWidth, int ROIIndex,
            int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setStrokeWidth(convertLength(strokeWidth));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseTheC(java.lang.Integer, int, int)
     */
    @Override
    public void setEllipseTheC(NonNegativeInteger theC, int ROIIndex, int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setTheC(toRType(theC));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseTheT(java.lang.Integer, int, int)
     */
    @Override
    public void setEllipseTheT(NonNegativeInteger theT, int ROIIndex, int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setTheT(toRType(theT));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseTheZ(java.lang.Integer, int, int)
     */
    @Override
    public void setEllipseTheZ(NonNegativeInteger theZ, int ROIIndex, int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setTheZ(toRType(theZ));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseTransform(ome.xml.model.AffineTransform, int, int)
     */
    @Override
    public void setEllipseTransform(AffineTransform transform, int ROIIndex,
            int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setTransform(toRType(transform));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseX(java.lang.Double, int, int)
     */
    @Override
    public void setEllipseX(Double x, int ROIIndex, int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setX(toRType(x));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseY(java.lang.Double, int, int)
     */
    @Override
    public void setEllipseY(Double y, int ROIIndex, int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setY(toRType(y));
    }

    ////////Experiment/////////

    private Experiment getExperiment(int experimentIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.EXPERIMENT_INDEX, experimentIndex);
        return getSourceObject(Experiment.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimentID(java.lang.String, int)
     */
    @Override
    public void setExperimentID(String id, int experimentIndex)
    {
        checkDuplicateLSID(Experiment.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.EXPERIMENT_INDEX, experimentIndex);
        IObjectContainer o = getIObjectContainer(Experiment.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Experiment.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimentDescription(java.lang.String, int)
     */
    @Override
    public void setExperimentDescription(String description, int experimentIndex)
    {
        Experiment o = getExperiment(experimentIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimentExperimenterRef(java.lang.String, int)
     */
    @Override
    public void setExperimentExperimenterRef(String experimenter,
            int experimentIndex)
    {
        ignoreInsecure("setExperimenterExperiemnterRef", experimenter,
                experimentIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimentType(ome.xml.model.enums.ExperimentType, int)
     */
    @Override
    public void setExperimentType(ome.xml.model.enums.ExperimentType type,
            int experimentIndex)
    {
        Experiment o = getExperiment(experimentIndex);
        o.setType((ExperimentType) getEnumeration(ExperimentType.class, type.toString()));
    }

    ////////Experimenter/////////

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterID(java.lang.String, int)
     */
    @Override
    public void setExperimenterID(String id, int experimenterIndex)
    {
        ignoreUnsupported("setExperimenterID", id, experimenterIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterAnnotationRef(java.lang.String, int, int)
     */
    @Override
    public void setExperimenterAnnotationRef(String annotation,
            int experimenterIndex, int annotationRefIndex)
    {
        ignoreUnsupported("setExperimenterAnnotationRef",
                annotation, experimenterIndex, annotationRefIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterEmail(java.lang.String, int)
     */
    @Override
    public void setExperimenterEmail(String email, int experimenterIndex)
    {
        ignoreUnsupported("setExperimenterEmail", email, experimenterIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterFirstName(java.lang.String, int)
     */
    @Override
    public void setExperimenterFirstName(String firstName, int experimenterIndex)
    {
        ignoreUnsupported("setExperimenterFirstName",
                firstName, experimenterIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterInstitution(java.lang.String, int)
     */
    @Override
    public void setExperimenterInstitution(String institution,
            int experimenterIndex)
    {
        ignoreUnsupported("setExperimenterInstitution",
                institution, experimenterIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterLastName(java.lang.String, int)
     */
    @Override
    public void setExperimenterLastName(String lastName, int experimenterIndex)
    {
        ignoreUnsupported("setExperimenterLastName",
                lastName, experimenterIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterMiddleName(java.lang.String, int)
     */
    @Override
    public void setExperimenterMiddleName(String middleName,
            int experimenterIndex)
    {
        ignoreUnsupported("setExperimenterMiddleName",
                middleName, experimenterIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterUserName(java.lang.String, int)
     */
    @Override
    public void setExperimenterUserName(String userName, int experimenterIndex)
    {
        ignoreUnsupported("setExperimenterUserName",
                userName, experimenterIndex);
    }

    ////////Filament/////////

    public Filament getFilament(int instrumentIndex, int lightSourceIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.LIGHT_SOURCE_INDEX, lightSourceIndex);
        return getSourceObject(Filament.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilamentID(java.lang.String, int, int)
     */
    @Override
    public void setFilamentID(String id, int instrumentIndex,
            int lightSourceIndex)
    {
        checkDuplicateLSID(Filament.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.LIGHT_SOURCE_INDEX, lightSourceIndex);
        IObjectContainer o = getIObjectContainer(Filament.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Filament.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilamentLotNumber(java.lang.String, int, int)
     */
    @Override
    public void setFilamentLotNumber(String lotNumber, int instrumentIndex,
            int lightSourceIndex)
    {
        Filament o = getFilament(instrumentIndex, lightSourceIndex);
        o.setLotNumber(toRType(lotNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilamentManufacturer(java.lang.String, int, int)
     */
    @Override
    public void setFilamentManufacturer(String manufacturer,
            int instrumentIndex, int lightSourceIndex)
    {
        Filament o = getFilament(instrumentIndex, lightSourceIndex);
        o.setManufacturer(toRType(manufacturer));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilamentModel(java.lang.String, int, int)
     */
    @Override
    public void setFilamentModel(String model, int instrumentIndex,
            int lightSourceIndex)
    {
        Filament o = getFilament(instrumentIndex, lightSourceIndex);
        o.setModel(toRType(model));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilamentPower(java.lang.Double, int, int)
     */
    @Override
    public void setFilamentPower(Power power, int instrumentIndex,
            int lightSourceIndex)
    {
        Filament o = getFilament(instrumentIndex, lightSourceIndex);
        o.setPower(convertPower(power));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilamentSerialNumber(java.lang.String, int, int)
     */
    @Override
    public void setFilamentSerialNumber(String serialNumber,
            int instrumentIndex, int lightSourceIndex)
    {
        Filament o = getFilament(instrumentIndex, lightSourceIndex);
        o.setSerialNumber(toRType(serialNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilamentType(ome.xml.model.enums.FilamentType, int, int)
     */
    @Override
    public void setFilamentType(ome.xml.model.enums.FilamentType type,
            int instrumentIndex, int lightSourceIndex)
    {
        Filament o = getFilament(instrumentIndex, lightSourceIndex);
        o.setType((FilamentType) getEnumeration(FilamentType.class, type.toString()));
    }

    ////////FileAnnotation/////////

    private FileAnnotation getFileAnnotation(int fileAnnotationIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.FILE_ANNOTATION_INDEX, fileAnnotationIndex);
        return getSourceObject(FileAnnotation.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFileAnnotationID(java.lang.String, int)
     */
    @Override
    public void setFileAnnotationID(String id, int fileAnnotationIndex)
    {
        checkDuplicateLSID(FileAnnotation.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.FILE_ANNOTATION_INDEX, fileAnnotationIndex);
        IObjectContainer o = getIObjectContainer(FileAnnotation.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(FileAnnotation.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFileAnnotationNamespace(java.lang.String, int)
     */
    @Override
    public void setFileAnnotationNamespace(String namespace,
            int fileAnnotationIndex)
    {
        FileAnnotation o = getFileAnnotation(fileAnnotationIndex);
        o.setNs(toRType(namespace));
    }

    ////////Filter/////////

    private Filter getFilter(int instrumentIndex, int filterIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.FILTER_INDEX, filterIndex);
        return getSourceObject(Filter.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterID(java.lang.String, int, int)
     */
    @Override
    public void setFilterID(String id, int instrumentIndex, int filterIndex)
    {
        checkDuplicateLSID(Filter.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.FILTER_INDEX, filterIndex);
        IObjectContainer o = getIObjectContainer(Filter.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Filter.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterFilterWheel(java.lang.String, int, int)
     */
    @Override
    public void setFilterFilterWheel(String filterWheel, int instrumentIndex,
            int filterIndex)
    {
        Filter o = getFilter(instrumentIndex, filterIndex);
        o.setFilterWheel(toRType(filterWheel));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterLotNumber(java.lang.String, int, int)
     */
    @Override
    public void setFilterLotNumber(String lotNumber, int instrumentIndex,
            int filterIndex)
    {
        Filter o = getFilter(instrumentIndex, filterIndex);
        o.setLotNumber(toRType(lotNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterManufacturer(java.lang.String, int, int)
     */
    @Override
    public void setFilterManufacturer(String manufacturer, int instrumentIndex,
            int filterIndex)
    {
        Filter o = getFilter(instrumentIndex, filterIndex);
        o.setManufacturer(toRType(manufacturer));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterModel(java.lang.String, int, int)
     */
    @Override
    public void setFilterModel(String model, int instrumentIndex,
            int filterIndex)
    {
        Filter o = getFilter(instrumentIndex, filterIndex);
        o.setModel(toRType(model));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterSerialNumber(java.lang.String, int, int)
     */
    @Override
    public void setFilterSerialNumber(String serialNumber, int instrumentIndex,
            int filterIndex)
    {
        Filter o = getFilter(instrumentIndex, filterIndex);
        o.setSerialNumber(toRType(serialNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterType(ome.xml.model.enums.FilterType, int, int)
     */
    @Override
    public void setFilterType(ome.xml.model.enums.FilterType type,
            int instrumentIndex, int filterIndex)
    {
        Filter o = getFilter(instrumentIndex, filterIndex);
        o.setType((FilterType) getEnumeration(FilterType.class, type.toString()));
    }

    ////////Filter Set/////////

    public FilterSet getFilterSet(int instrumentIndex, int filterSetIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.FILTER_SET_INDEX, filterSetIndex);
        return getSourceObject(FilterSet.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterSetID(java.lang.String, int, int)
     */
    @Override
    public void setFilterSetID(String id, int instrumentIndex,
            int filterSetIndex)
    {
        checkDuplicateLSID(FilterSet.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.FILTER_SET_INDEX, filterSetIndex);
        IObjectContainer o = getIObjectContainer(FilterSet.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(FilterSet.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterSetDichroicRef(java.lang.String, int, int)
     */
    @Override
    public void setFilterSetDichroicRef(String dichroic, int instrumentIndex,
            int filterSetIndex)
    {
        LSID key = new LSID(FilterSet.class, instrumentIndex, filterSetIndex);
        addReference(key, new LSID(dichroic));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterSetEmissionFilterRef(java.lang.String, int, int, int)
     */
    @Override
    public void setFilterSetEmissionFilterRef(String emissionFilter,
            int instrumentIndex, int filterSetIndex, int emissionFilterRefIndex)
    {
        // Using this suffix is kind of a gross hack but the reference
        // processing logic does not easily handle multiple A --> B or B --> A
        // linkages of the same type so we'll compromise.
        // Thu Jul 16 13:34:37 BST 2009 -- Chris Allan <callan@blackcat.ca>
        emissionFilter += OMERO_EMISSION_FILTER_SUFFIX;
        LSID key = new LSID(FilterSet.class, instrumentIndex, filterSetIndex);
        addReference(key, new LSID(emissionFilter));
        // TODO EmissionFilter.class not in OMERO model
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterSetExcitationFilterRef(java.lang.String, int, int, int)
     */
    @Override
    public void setFilterSetExcitationFilterRef(String excitationFilter,
            int instrumentIndex, int filterSetIndex,
            int excitationFilterRefIndex)
    {
        // Using this suffix is kind of a gross hack but the reference
        // processing logic does not easily handle multiple A --> B or B --> A
        // linkages of the same type so we'll compromise.
        // Thu Jul 16 13:34:37 BST 2009 -- Chris Allan <callan@blackcat.ca>
        excitationFilter += OMERO_EXCITATION_FILTER_SUFFIX;
        LSID key = new LSID(FilterSet.class, instrumentIndex, filterSetIndex);
        addReference(key, new LSID(excitationFilter));
        // TODO ExcitationFilter.class not in OMERO model
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterSetLotNumber(java.lang.String, int, int)
     */
    @Override
    public void setFilterSetLotNumber(String lotNumber, int instrumentIndex,
            int filterSetIndex)
    {
        FilterSet o = getFilterSet(instrumentIndex, filterSetIndex);
        o.setLotNumber(toRType(lotNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterSetManufacturer(java.lang.String, int, int)
     */
    @Override
    public void setFilterSetManufacturer(String manufacturer,
            int instrumentIndex, int filterSetIndex)
    {
        FilterSet o = getFilterSet(instrumentIndex, filterSetIndex);
        o.setManufacturer(toRType(manufacturer));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterSetModel(java.lang.String, int, int)
     */
    @Override
    public void setFilterSetModel(String model, int instrumentIndex,
            int filterSetIndex)
    {
        FilterSet o = getFilterSet(instrumentIndex, filterSetIndex);
        o.setModel(toRType(model));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterSetSerialNumber(java.lang.String, int, int)
     */
    @Override
    public void setFilterSetSerialNumber(String serialNumber,
            int instrumentIndex, int filterSetIndex)
    {
        FilterSet o = getFilterSet(instrumentIndex, filterSetIndex);
        o.setSerialNumber(toRType(serialNumber));
    }

    private GenericExcitationSource getGenericExcitationSource(int instrumentIndex, int lightSourceIndex) {
        final LinkedHashMap<Index, Integer> indexes = new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.LIGHT_SOURCE_INDEX, lightSourceIndex);
        return getSourceObject(GenericExcitationSource.class, indexes);
    }

    /**
     * @param folderIndex the index of a folder
     * @return the corresponding folder
     */
    private Folder getFolder(int folderIndex) {
        final LinkedHashMap<Index, Integer> indexes = new LinkedHashMap<Index, Integer>();
        indexes.put(Index.FOLDER_INDEX, folderIndex);
        return getSourceObject(Folder.class, indexes);
    }

    /* Documentation copied from ome.xml.meta.MetadataStore:
     *
     * Set the AnnotationRef property of Folder.
     *
     * @param annotation AnnotationRef to set.
     * @param folderIndex the Folder index.
     * @param annotationRefIndex AnnotationRef index (unused).
     */
    @Override
    public void setFolderAnnotationRef(String annotation, int folderIndex, int annotationRefIndex) {
        final LSID key = new LSID(Folder.class, folderIndex);
        addReference(key, new LSID(annotation));
    }

    /* Documentation copied from ome.xml.meta.MetadataStore:
     *
     * Set the Description property of Folder.
     *
     * @param description Description to set.
     * @param folderIndex the Folder index.
     */
    @Override
    public void setFolderDescription(String description, int folderIndex) {
        final Folder folder = getFolder(folderIndex);
        folder.setDescription(toRType(description));
    }

    /* Documentation copied from ome.xml.meta.MetadataStore:
     *
     * Set the FolderRef property of Folder.
     *
     * @param folder FolderRef to set.
     * @param folderIndex the Folder index.
     * @param folderRefIndex FolderRef index (unused).
     */
    @Override
    public void setFolderFolderRef(String folder, int folderIndex, int folderRefIndex) {
        final LSID key = new LSID(Folder.class, folderIndex);
        addReference(key, new LSID(folder));
    }

    /* Documentation copied from ome.xml.meta.MetadataStore:
     *
     * Set the ID property of Folder.
     *
     * @param id ID to set.
     * @param folderIndex the Folder index.
     */
    @Override
    public void setFolderID(String id, int folderIndex) {
        checkDuplicateLSID(Folder.class, id);
        final LinkedHashMap<Index, Integer> indexes = new LinkedHashMap<Index, Integer>();
        indexes.put(Index.FOLDER_INDEX, folderIndex);
        final IObjectContainer newFolder = getIObjectContainer(Folder.class, indexes);
        newFolder.LSID = id;
        addAuthoritativeContainer(Folder.class, id, newFolder);
    }

    /* Documentation copied from ome.xml.meta.MetadataStore:
     *
     * Set the ImageRef property of Folder.
     *
     * @param roi ImageRef to set.
     * @param folderIndex the Folder index.
     * @param imageRefIndex ImageRef index (unused).
     */
    @Override
    public void setFolderImageRef(String image, int folderIndex, int imageRefIndex) {
        final LSID key = new LSID(Folder.class, folderIndex);
        addReference(key, new LSID(image));
    }

    /* Documentation copied from ome.xml.meta.MetadataStore:
     *
     * Set the Name property of Folder.
     *
     * @param name Name to set.
     * @param folderIndex the Folder index.
     */
    @Override
    public void setFolderName(String name, int folderIndex) {
        final Folder folder = getFolder(folderIndex);
        folder.setName(toRType(name));
    }

    /* Documentation copied from ome.xml.meta.MetadataStore:
     *
     * Set the ROIRef property of Folder.
     *
     * @param roi ROIRef to set.
     * @param folderIndex the Folder index.
     * @param ROIRefIndex ROIRef index (unused).
     */
    @Override
    public void setFolderROIRef(String roi, int folderIndex, int ROIRefIndex) {
        final LSID key = new LSID(Folder.class, folderIndex);
        addReference(key, new LSID(roi));
    }

    // ID accessor from parent LightSource
    // @Override
    public void setGenericExcitationSourceID(String id, int instrumentIndex, int lightSourceIndex) {
        checkDuplicateLSID(GenericExcitationSource.class, id);
        final LinkedHashMap<Index, Integer> indexes = new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.LIGHT_SOURCE_INDEX, lightSourceIndex);
        IObjectContainer o = getIObjectContainer(GenericExcitationSource.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(GenericExcitationSource.class, id, o);
    }

    // LotNumber accessor from parent LightSource
    // @Override
    public void setGenericExcitationSourceLotNumber(String lotNumber, int instrumentIndex, int lightSourceIndex) {
        final GenericExcitationSource o = getGenericExcitationSource(instrumentIndex, lightSourceIndex);
        o.setLotNumber(toRType(lotNumber));
    }

    @Override
    public void setGenericExcitationSourceMap(List<MapPair> map, int instrumentIndex, int lightSourceIndex) {
        final GenericExcitationSource o = getGenericExcitationSource(instrumentIndex, lightSourceIndex);
        o.setMap(IceMapper.convertMapPairs(map));
    }

    // Manufacturer accessor from parent LightSource
    // @Override
    public void setGenericExcitationSourceManufacturer(String manufacturer, int instrumentIndex, int lightSourceIndex) {
        final GenericExcitationSource o = getGenericExcitationSource(instrumentIndex, lightSourceIndex);
        o.setManufacturer(toRType(manufacturer));
    }

    // Model accessor from parent LightSource
    // @Override
    public void setGenericExcitationSourceModel(String model, int instrumentIndex, int lightSourceIndex) {
        final GenericExcitationSource o = getGenericExcitationSource(instrumentIndex, lightSourceIndex);
        o.setModel(toRType(model));
    }

    // Power accessor from parent LightSource
    // @Override
    public void setGenericExcitationSourcePower(Power power, int instrumentIndex, int lightSourceIndex) {
        final GenericExcitationSource o = getGenericExcitationSource(instrumentIndex, lightSourceIndex);
        o.setPower(convertPower(power));
    }

    // SerialNumber accessor from parent LightSource
    // @Override
    public void setGenericExcitationSourceSerialNumber(String serialNumber, int instrumentIndex, int lightSourceIndex) {
        final GenericExcitationSource o = getGenericExcitationSource(instrumentIndex, lightSourceIndex);
        o.setSerialNumber(toRType(serialNumber));
    }

    ////////ExperimenterGroup/////////

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterGroupID(java.lang.String, int)
     */
    @Override
    public void setExperimenterGroupID(String id, int groupIndex)
    {
        ignoreInsecure("setExperimenterGroupID", id, groupIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterGroupDescription(java.lang.String, int)
     */
    @Override
    public void setExperimenterGroupDescription(String description, int groupIndex)
    {
        ignoreInsecure("setExperimenterGroupDescription", description, groupIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterGroupLeader(java.lang.String, int, int)
     */
    @Override
    public void setExperimenterGroupLeader(String leader, int groupIndex,
            int leaderIndex)
    {
        ignoreInsecure("setExperimenterGroupLeader", leader, groupIndex, leaderIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterGroupName(java.lang.String, int)
     */
    @Override
    public void setExperimenterGroupName(String name, int groupIndex)
    {
        ignoreInsecure("setExperimenterGroupName",name, groupIndex);
    }

    //////// Image /////////

    /**
     * Retrieve Image
     * @param imageIndex the index of the image
     * @return the image
     */
    private Image getImage(int imageIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.IMAGE_INDEX, imageIndex);
        Image o = getSourceObject(Image.class, indexes);
        o.setFormat(getImageFormat());
        return o;
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImageID(java.lang.String, int)
     */
    @Override
    public void setImageID(String id, int imageIndex)
    {
        checkDuplicateLSID(Image.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.IMAGE_INDEX, imageIndex);
        IObjectContainer o = getIObjectContainer(Image.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Image.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImageAcquisitionDate(ome.xml.model.primitives.Timestamp, int)
     */
    @Override
    public void setImageAcquisitionDate(Timestamp acquiredDate, int imageIndex)
    {
        if (acquiredDate == null)
        {
            return;
        }
        Image o = getImage(imageIndex);
        o.setAcquisitionDate(toRType(acquiredDate));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImageAnnotationRef(java.lang.String, int, int)
     */
    @Override
    public void setImageAnnotationRef(String annotation, int imageIndex,
            int annotationRefIndex)
    {
        LSID key = new LSID(Image.class, imageIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImageDescription(java.lang.String, int)
     */
    @Override
    public void setImageDescription(String description, int imageIndex)
    {
        Image o = getImage(imageIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#/erimentRef(java.lang.String, int)
     */
    @Override
    public void setImageExperimentRef(String experiment, int imageIndex)
    {
        LSID key = new LSID(Image.class, imageIndex);
        addReference(key, new LSID(experiment));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImageExperimenterRef(java.lang.String, int)
     */
    @Override
    public void setImageExperimenterRef(String experimenter, int imageIndex)
    {
        ignoreInsecure("setImageExperimenterRef", experimenter, imageIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImageGroupRef(java.lang.String, int)
     */
    @Override
    public void setImageExperimenterGroupRef(String group, int imageIndex)
    {
        ignoreInsecure("setImageExperimenterGroupRef", group, imageIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImageInstrumentRef(java.lang.String, int)
     */
    @Override
    public void setImageInstrumentRef(String instrument, int imageIndex)
    {
        LSID key = new LSID(Image.class, imageIndex);
        addReference(key, new LSID(instrument));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImageMicrobeamManipulationRef(java.lang.String, int, int)
     */
    @Override
    public void setImageMicrobeamManipulationRef(String microbeamManipulation,
            int imageIndex, int microbeamManipulationRefIndex)
    {
        LSID key = new LSID(Image.class, imageIndex);
        addReference(key, new LSID(microbeamManipulation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImageName(java.lang.String, int)
     */
    @Override
    public void setImageName(String name, int imageIndex)
    {
        Image o = getImage(imageIndex);
        o.setName(toRType(name));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImageROIRef(java.lang.String, int, int)
     */
    @Override
    public void setImageROIRef(String roi, int imageIndex, int ROIRefIndex)
    {
        LSID key = new LSID(Image.class, imageIndex);
        addReference(key, new LSID(roi));
    }

    //////// Objective Settings /////////

    public ObjectiveSettings getObjectiveSettings(int imageIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.IMAGE_INDEX, imageIndex);
        return getSourceObject(ObjectiveSettings.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveSettingsID(java.lang.String, int)
     */
    @Override
    public void setObjectiveSettingsID(String id, int imageIndex)
    {
        getObjectiveSettings(imageIndex);
        LSID key = new LSID(ObjectiveSettings.class, imageIndex);
        addReference(key, new LSID(id));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setbjectiveSettingsCorrectionCollar(java.lang.Double, int)
     */
    @Override
    public void setObjectiveSettingsCorrectionCollar(
            Double correctionCollar, int imageIndex)
    {
        ObjectiveSettings o = getObjectiveSettings(imageIndex);
        o.setCorrectionCollar(toRType(correctionCollar));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveSettingsMedium(ome.xml.model.enums.Medium, int)
     */
    @Override
    public void setObjectiveSettingsMedium(
            ome.xml.model.enums.Medium medium, int imageIndex)
    {
        ObjectiveSettings o = getObjectiveSettings(imageIndex);
        o.setMedium((Medium) getEnumeration(Medium.class, medium.toString()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveSettingsRefractiveIndex(java.lang.Double, int)
     */
    @Override
    public void setObjectiveSettingsRefractiveIndex(
            Double refractiveIndex, int imageIndex)
    {
        ObjectiveSettings o = getObjectiveSettings(imageIndex);
        o.setRefractiveIndex(toRType(refractiveIndex));
    }

    //////// Imaging Environment /////////

    public ImagingEnvironment getImagingEnvironment(int imageIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.IMAGE_INDEX, imageIndex);
        return getSourceObject(ImagingEnvironment.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImagingEnvironmentAirPressure(java.lang.Double, int)
     */
    @Override
    public void setImagingEnvironmentAirPressure(Pressure airPressure,
            int imageIndex)
    {
        ImagingEnvironment o = getImagingEnvironment(imageIndex);
        o.setAirPressure(convertPressure(airPressure));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImagingEnvironmentCO2Percent(ome.xml.model.primitives.PercentFraction, int)
     */
    @Override
    public void setImagingEnvironmentCO2Percent(PercentFraction co2percent,
            int imageIndex)
    {
        ImagingEnvironment o = getImagingEnvironment(imageIndex);
        o.setCo2percent(toRType(co2percent));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImagingEnvironmentHumidity(ome.xml.model.primitives.PercentFraction, int)
     */
    @Override
    public void setImagingEnvironmentHumidity(PercentFraction humidity,
            int imageIndex)
    {
        ImagingEnvironment o = getImagingEnvironment(imageIndex);
        o.setHumidity(toRType(humidity));
    }

    @Override
    public void setImagingEnvironmentMap(List<MapPair> map, int imageIndex) {
        final ImagingEnvironment o = getImagingEnvironment(imageIndex);
        o.setMap(IceMapper.convertMapPairs(map));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setImagingEnvironmentTemperature(java.lang.Double, int)
     */
    @Override
    public void setImagingEnvironmentTemperature(Temperature temperature,
            int imageIndex)
    {
        ImagingEnvironment o = getImagingEnvironment(imageIndex);
        o.setTemperature(convertTemperature(temperature));
    }

    //////// Instrument /////////

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setInstrumentID(java.lang.String, int)
     */
    @Override
    public void setInstrumentID(String id, int instrumentIndex)
    {
        checkDuplicateLSID(Instrument.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        IObjectContainer o = getIObjectContainer(Instrument.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Instrument.class, id, o);
    }

    //////// Laser /////////

    public Laser getLaser(int instrumentIndex, int lightSourceIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.LIGHT_SOURCE_INDEX, lightSourceIndex);
        return getSourceObject(Laser.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserID(java.lang.String, int, int)
     */
    @Override
    public void setLaserID(String id, int instrumentIndex, int lightSourceIndex)
    {
        checkDuplicateLSID(Laser.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.LIGHT_SOURCE_INDEX, lightSourceIndex);
        IObjectContainer o = getIObjectContainer(Laser.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Laser.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserFrequencyMultiplication(ome.xml.model.primitives.PositiveInteger, int, int)
     */
    @Override
    public void setLaserFrequencyMultiplication(
            PositiveInteger frequencyMultiplication, int instrumentIndex,
            int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setFrequencyMultiplication(toRType(frequencyMultiplication));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserLaserMedium(ome.xml.model.enums.LaserMedium, int, int)
     */
    @Override
    public void setLaserLaserMedium(
            ome.xml.model.enums.LaserMedium laserMedium, int instrumentIndex,
            int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setLaserMedium((LaserMedium) getEnumeration(LaserMedium.class, laserMedium.toString()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserLotNumber(java.lang.String, int, int)
     */
    @Override
    public void setLaserLotNumber(String lotNumber, int instrumentIndex,
            int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setLotNumber(toRType(lotNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserManufacturer(java.lang.String, int, int)
     */
    @Override
    public void setLaserManufacturer(String manufacturer, int instrumentIndex,
            int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setManufacturer(toRType(manufacturer));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserModel(java.lang.String, int, int)
     */
    @Override
    public void setLaserModel(String model, int instrumentIndex,
            int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setModel(toRType(model));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserPockelCell(java.lang.Boolean, int, int)
     */
    @Override
    public void setLaserPockelCell(Boolean pockelCell, int instrumentIndex,
            int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setPockelCell(toRType(pockelCell));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserPower(java.lang.Double, int, int)
     */
    @Override
    public void setLaserPower(Power power, int instrumentIndex,
            int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setPower(convertPower(power));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserPulse(ome.xml.model.enums.Pulse, int, int)
     */
    @Override
    public void setLaserPulse(ome.xml.model.enums.Pulse pulse,
            int instrumentIndex, int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setPulse((Pulse) getEnumeration(Pulse.class, pulse.toString()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserPump(java.lang.String, int, int)
     */
    @Override
    public void setLaserPump(String pump, int instrumentIndex,
            int lightSourceIndex)
    {
        LSID key = new LSID(Laser.class, instrumentIndex, lightSourceIndex);
        addReference(key, new LSID(pump));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserRepetitionRate(java.lang.Double, int, int)
     */
    @Override
    public void setLaserRepetitionRate(Frequency repetitionRate,
            int instrumentIndex, int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setRepetitionRate(convertFrequency(repetitionRate));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserSerialNumber(java.lang.String, int, int)
     */
    @Override
    public void setLaserSerialNumber(String serialNumber, int instrumentIndex,
            int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setSerialNumber(toRType(serialNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserTuneable(java.lang.Boolean, int, int)
     */
    @Override
    public void setLaserTuneable(Boolean tuneable, int instrumentIndex,
            int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setTuneable(toRType(tuneable));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserType(ome.xml.model.enums.LaserType, int, int)
     */
    @Override
    public void setLaserType(ome.xml.model.enums.LaserType type,
            int instrumentIndex, int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setType((LaserType) getEnumeration(LaserType.class, type.toString()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserWavelength(ome.xml.model.primitives.PositiveFloat, int, int)
     */
    @Override
    public void setLaserWavelength(Length wavelength,
            int instrumentIndex, int lightSourceIndex)
    {
        Laser o = getLaser(instrumentIndex, lightSourceIndex);
        o.setWavelength(convertLength(wavelength));
    }

    //////// Laser Emitting Diode /////////

    public LightEmittingDiode getLightEmittingDiode(int instrumentIndex, int lightSourceIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.LIGHT_SOURCE_INDEX, lightSourceIndex);
        return getSourceObject(LightEmittingDiode.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLightEmittingDiodeID(java.lang.String, int, int)
     */
    @Override
    public void setLightEmittingDiodeID(String id, int instrumentIndex,
            int lightSourceIndex)
    {
        checkDuplicateLSID(LightEmittingDiode.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.LIGHT_SOURCE_INDEX, lightSourceIndex);
        IObjectContainer o = getIObjectContainer(LightEmittingDiode.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(LightEmittingDiode.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLightEmittingDiodeLotNumber(java.lang.String, int, int)
     */
    @Override
    public void setLightEmittingDiodeLotNumber(String lotNumber,
            int instrumentIndex, int lightSourceIndex)
    {
        LightEmittingDiode o = getLightEmittingDiode(instrumentIndex,
            lightSourceIndex);
        o.setLotNumber(toRType(lotNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLightEmittingDiodeManufacturer(java.lang.String, int, int)
     */
    @Override
    public void setLightEmittingDiodeManufacturer(String manufacturer,
            int instrumentIndex, int lightSourceIndex)
    {
        LightEmittingDiode o = getLightEmittingDiode(instrumentIndex, lightSourceIndex);
        o.setManufacturer(toRType(manufacturer));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLightEmittingDiodeModel(java.lang.String, int, int)
     */
    @Override
    public void setLightEmittingDiodeModel(String model, int instrumentIndex,
            int lightSourceIndex)
    {
        LightEmittingDiode o = getLightEmittingDiode(instrumentIndex, lightSourceIndex);
        o.setModel(toRType(model));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLightEmittingDiodePower(java.lang.Double, int, int)
     */
    @Override
    public void setLightEmittingDiodePower(Power power, int instrumentIndex,
            int lightSourceIndex)
    {
        LightEmittingDiode o = getLightEmittingDiode(instrumentIndex, lightSourceIndex);
        o.setPower(convertPower(power));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLightEmittingDiodeSerialNumber(java.lang.String, int, int)
     */
    @Override
    public void setLightEmittingDiodeSerialNumber(String serialNumber,
            int instrumentIndex, int lightSourceIndex)
    {
        LightEmittingDiode o = getLightEmittingDiode(instrumentIndex, lightSourceIndex);
        o.setSerialNumber(toRType(serialNumber));
    }


    //////// Light Path /////////

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLightPathDichroicRef(java.lang.String, int, int)
     */
    @Override
    public void setLightPathDichroicRef(String dichroic, int imageIndex,
            int channelIndex)
    {
        LSID key = new LSID(LightPath.class, imageIndex, channelIndex);
        addReference(key, new LSID(dichroic));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLightPathEmissionFilterRef(java.lang.String, int, int, int)
     */
    @Override
    public void setLightPathEmissionFilterRef(String emissionFilter,
            int imageIndex, int channelIndex, int emissionFilterRefIndex)
    {
        // Using this suffix is kind of a gross hack but the reference
        // processing logic does not easily handle multiple A --> B or B --> A
        // linkages of the same type so we'll compromise.
        // Tue 18 May 2010 17:07:51 BST -- Chris Allan <callan@blackcat.ca>
        emissionFilter += OMERO_EMISSION_FILTER_SUFFIX;
        LSID key = new LSID(LightPath.class, imageIndex, channelIndex);
        addReference(key, new LSID(emissionFilter));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLightPathExcitationFilterRef(java.lang.String, int, int, int)
     */
    @Override
    public void setLightPathExcitationFilterRef(String excitationFilter,
            int imageIndex, int channelIndex, int excitationFilterRefIndex)
    {
        // Using this suffix is kind of a gross hack but the reference
        // processing logic does not easily handle multiple A --> B or B --> A
        // linkages of the same type so we'll compromise.
        // Tue 18 May 2010 17:07:51 BST -- Chris Allan <callan@blackcat.ca>
        excitationFilter += OMERO_EXCITATION_FILTER_SUFFIX;
        LSID key = new LSID(LightPath.class, imageIndex, channelIndex);
        addReference(key, new LSID(excitationFilter));
    }


    //////// Line /////////

    public Line getLine(int ROIIndex, int shapeIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX,ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        return getSourceObject(Line.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineID(java.lang.String, int, int)
     */
    @Override
    public void setLineID(String id, int ROIIndex, int shapeIndex)
    {
        checkDuplicateLSID(Line.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX,ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        IObjectContainer o = getIObjectContainer(Line.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Line.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineText(java.lang.String, int, int)
     */
    @Override
    public void setLineText(String text, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setTextValue(toRType(text));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineFillColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setLineFillColor(Color fill, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setFillColor(toRType(fill));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineFontSize(java.lang.Integer, int, int)
     */
    @Override
    public void setLineFontSize(Length fontSize, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setFontSize(convertLength(fontSize));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineStroke(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setLineStrokeColor(Color stroke, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setStrokeColor(toRType(stroke));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineStrokeDashArray(java.lang.String, int, int)
     */
    @Override
    public void setLineStrokeDashArray(String strokeDashArray, int ROIIndex,
            int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setStrokeDashArray(toRType(strokeDashArray));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineStrokeWidth(java.lang.Double, int, int)
     */
    @Override
    public void setLineStrokeWidth(Length strokeWidth, int ROIIndex,
            int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setStrokeWidth(convertLength(strokeWidth));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineTheC(java.lang.Integer, int, int)
     */
    @Override
    public void setLineTheC(NonNegativeInteger theC, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setTheC(toRType(theC));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineTheT(java.lang.Integer, int, int)
     */
    @Override
    public void setLineTheT(NonNegativeInteger theT, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setTheT(toRType(theT));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineTheZ(java.lang.Integer, int, int)
     */
    @Override
    public void setLineTheZ(NonNegativeInteger theZ, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setTheZ(toRType(theZ));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineTransform(ome.xml.model.AffineTransform, int, int)
     */
    @Override
    public void setLineTransform(AffineTransform transform, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setTransform(toRType(transform));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineX1(java.lang.Double, int, int)
     */
    @Override
    public void setLineX1(Double x1, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setX1(toRType(x1));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineX2(java.lang.Double, int, int)
     */
    @Override
    public void setLineX2(Double x2, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setX2(toRType(x2));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineY1(java.lang.Double, int, int)
     */
    @Override
    public void setLineY1(Double y1, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setY1(toRType(y1));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineY2(java.lang.Double, int, int)
     */
    @Override
    public void setLineY2(Double y2, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setY2(toRType(y2));
    }


    //////// List Annotation /////////

    public ListAnnotation getListAnnotation(int listAnnotationIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.LIST_ANNOTATION_INDEX, listAnnotationIndex);
        return getSourceObject(ListAnnotation.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setListAnnotationID(java.lang.String, int)
     */
    @Override
    public void setListAnnotationID(String id, int listAnnotationIndex)
    {
        checkDuplicateLSID(ListAnnotation.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.LIST_ANNOTATION_INDEX, listAnnotationIndex);
        IObjectContainer o = getIObjectContainer(ListAnnotation.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(ListAnnotation.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setListAnnotationAnnotationRef(java.lang.String, int, int)
     */
    @Override
    public void setListAnnotationAnnotationRef(String annotation,
            int listAnnotationIndex, int annotationRefIndex)
    {
        LSID key = new LSID(ListAnnotation.class, listAnnotationIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setListAnnotationNamespace(java.lang.String, int)
     */
    @Override
    public void setListAnnotationNamespace(String namespace,
            int listAnnotationIndex)
    {
        ListAnnotation o = getListAnnotation(listAnnotationIndex);
        o.setNs(toRType(namespace));
    }


    //////// Long Annotation /////////

    public LongAnnotation getLongAnnotation(int longAnnotationIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.LONG_ANNOTATION_INDEX, longAnnotationIndex);
        return getSourceObject(LongAnnotation.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLongAnnotationID(java.lang.String, int)
     */
    @Override
    public void setLongAnnotationID(String id, int longAnnotationIndex)
    {
        checkDuplicateLSID(LongAnnotation.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.LONG_ANNOTATION_INDEX, longAnnotationIndex);
        IObjectContainer o = getIObjectContainer(LongAnnotation.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(LongAnnotation.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLongAnnotationNamespace(java.lang.String, int)
     */
    @Override
    public void setLongAnnotationNamespace(String namespace,
            int longAnnotationIndex)
    {
        LongAnnotation o = getLongAnnotation(longAnnotationIndex);
        o.setNs(toRType(namespace));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLongAnnotationValue(java.lang.Long, int)
     */
    @Override
    public void setLongAnnotationValue(Long value, int longAnnotationIndex)
    {
        LongAnnotation o = getLongAnnotation(longAnnotationIndex);
        o.setLongValue(toRType(value));
    }

    ///////// Mask ////////

    public Mask getMask(int ROIIndex, int shapeIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        return getSourceObject(Mask.class, indexes);
    }

    @Override
    public void setMaskBinData(byte[] binData, int roiIndex, int shapeIndex)
    {
        Mask o = getMask(roiIndex, shapeIndex);
        if (o != null)
        {
            o.setBytes(binData);
        }
    }

    @Override
    public void setMaskBinDataBigEndian(Boolean isBigEndian, int roiIndex, int shapeIndex) {
        ignoreMissing("setMaskBinDataBigEndian", isBigEndian, roiIndex, shapeIndex);
    }

    @Override
    public void setMaskBinDataCompression(Compression compression, int roiIndex, int shapeIndex) {
        ignoreMissing("setMaskBinDataCompression", compression, roiIndex, shapeIndex);
    }

    @Override
    public void setMaskBinDataLength(NonNegativeLong length, int roiIndex, int shapeIndex) {
        ignoreMissing("setMaskBinDataLength", length, roiIndex, shapeIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskText(java.lang.String, int, int)
     */
    @Override
    public void setMaskText(String description, int ROIIndex,
            int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setTextValue(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskFillColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setMaskFillColor(Color fill, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setFillColor(toRType(fill));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskFontSize(java.lang.Integer, int, int)
     */
    @Override
    public void setMaskFontSize(Length fontSize, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setFontSize(convertLength(fontSize));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskID(java.lang.String, int, int)
     */
    @Override
    public void setMaskID(String id, int ROIIndex, int shapeIndex)
    {
        checkDuplicateLSID(Mask.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        IObjectContainer o = getIObjectContainer(Mask.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Mask.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskStroke(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setMaskStrokeColor(Color stroke, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setStrokeColor(toRType(stroke));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskStrokeDashArray(java.lang.String, int, int)
     */
    @Override
    public void setMaskStrokeDashArray(String strokeDashArray, int ROIIndex,
            int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setStrokeDashArray(toRType(strokeDashArray));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskStrokeWidth(java.lang.Double, int, int)
     */
    @Override
    public void setMaskStrokeWidth(Length strokeWidth, int ROIIndex,
            int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setStrokeWidth(convertLength(strokeWidth));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskTheC(java.lang.Integer, int, int)
     */
    @Override
    public void setMaskTheC(NonNegativeInteger theC, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setTheC(toRType(theC));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskTheT(java.lang.Integer, int, int)
     */
    @Override
    public void setMaskTheT(NonNegativeInteger theT, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setTheT(toRType(theT));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskTheZ(java.lang.Integer, int, int)
     */
    @Override
    public void setMaskTheZ(NonNegativeInteger theZ, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setTheZ(toRType(theZ));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskTransform(java.lang.String, int, int)
     */
    @Override
    public void setMaskTransform(AffineTransform transform, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setTransform(toRType(transform));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskX(java.lang.Double, int, int)
     */
    @Override
    public void setMaskX(Double x, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setX(toRType(x));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskY(java.lang.Double, int, int)
     */
    @Override
    public void setMaskY(Double y, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setY(toRType(y));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskHeight(java.lang.Double, int, int)
     */
    @Override
    public void setMaskHeight(Double height, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setHeight(toRType(height));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskWidth(java.lang.Double, int, int)
     */
    @Override
    public void setMaskWidth(Double width, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setWidth(toRType(width));
    }

    //////// Microbean Manipulation /////////

    public MicrobeamManipulation getMicrobeamManipulation(int experimentIndex, int microbeamManipulationIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.EXPERIMENT_INDEX, experimentIndex);
        indexes.put(Index.MICROBEAM_MANIPULATION_INDEX, microbeamManipulationIndex);
        return getSourceObject(MicrobeamManipulation.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMicrobeamManipulationID(java.lang.String, int, int)
     */
    @Override
    public void setMicrobeamManipulationID(String id, int experimentIndex,
            int microbeamManipulationIndex)
    {
        checkDuplicateLSID(MicrobeamManipulation.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.EXPERIMENT_INDEX, experimentIndex);
        indexes.put(Index.MICROBEAM_MANIPULATION_INDEX, microbeamManipulationIndex);
        IObjectContainer o = getIObjectContainer(MicrobeamManipulation.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(MicrobeamManipulation.class, id, o);
    }

    @Override
    public void setMicrobeamManipulationDescription(String description, int experimentIndex, int microbeamManipulationIndex)
    {
        MicrobeamManipulation o = getMicrobeamManipulation(experimentIndex, microbeamManipulationIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMicrobeamManipulationExperimenterRef(java.lang.String, int, int)
     */
    @Override
    public void setMicrobeamManipulationExperimenterRef(String experimenter,
            int experimentIndex, int microbeamManipulationIndex)
    {
        //LSID key = new LSID(MicrobeamManipulation.class, experimentIndex, microbeamManipulationIndex);
        //addReference(key, new LSID(experimenter));
    }


    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMicrobeamManipulationROIRef(java.lang.String, int, int, int)
     */
    @Override
    public void setMicrobeamManipulationROIRef(String roi, int experimentIndex,
            int microbeamManipulationIndex, int ROIRefIndex)
    {
        LSID key = new LSID(MicrobeamManipulation.class, experimentIndex, microbeamManipulationIndex);
        addReference(key, new LSID(roi));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMicrobeamManipulationType(ome.xml.model.enums.MicrobeamManipulationType, int, int)
     */
    @Override
    public void setMicrobeamManipulationType(ome.xml.model.enums.MicrobeamManipulationType type,
            int experimentIndex, int microbeamManipulationIndex)
    {
        MicrobeamManipulation o = getMicrobeamManipulation(experimentIndex, microbeamManipulationIndex);
        o.setType((MicrobeamManipulationType) getEnumeration(MicrobeamManipulationType.class, type.toString()));
    }

    ////////Microbeam Manipulation Light Source Settings /////////

    public LightSettings getMicrobeamManipulationLightSourceSettings(int experimentIndex, int microbeamManipulationIndex,
            int lightSourceSettingsIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.EXPERIMENT_INDEX, experimentIndex);
        indexes.put(Index.MICROBEAM_MANIPULATION_INDEX, microbeamManipulationIndex);
        indexes.put(Index.LIGHT_SOURCE_SETTINGS_INDEX, lightSourceSettingsIndex);
        return getSourceObject(LightSettings.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMicrobeamManipulationLightSourceSettingsID(java.lang.String, int, int, int)
     */
    @Override
    public void setMicrobeamManipulationLightSourceSettingsID(String id,
            int experimentIndex, int microbeamManipulationIndex,
            int lightSourceSettingsIndex)
    {
        getMicrobeamManipulationLightSourceSettings(
                experimentIndex, microbeamManipulationIndex,
                lightSourceSettingsIndex);
        LSID key = new LSID(LightSettings.class, experimentIndex,
            microbeamManipulationIndex, lightSourceSettingsIndex);
        addReference(key, new LSID(id));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMicrobeamManipulationLightSourceSettingsAttenuation(ome.xml.model.primitives.PercentFraction, int, int, int)
     */
    @Override
    public void setMicrobeamManipulationLightSourceSettingsAttenuation(
            PercentFraction attenuation, int experimentIndex,
            int microbeamManipulationIndex, int lightSourceSettingsIndex)
    {
        LightSettings o = getMicrobeamManipulationLightSourceSettings(experimentIndex,
                microbeamManipulationIndex, lightSourceSettingsIndex);
        o.setAttenuation(toRType(attenuation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMicrobeamManipulationLightSourceSettingsWavelength(ome.xml.model.primitives.PositiveFloat, int, int, int)
     */
    @Override
    public void setMicrobeamManipulationLightSourceSettingsWavelength(
            Length wavelength, int experimentIndex,
            int microbeamManipulationIndex, int lightSourceSettingsIndex)
    {
        LightSettings o = getMicrobeamManipulationLightSourceSettings(experimentIndex,
                microbeamManipulationIndex, lightSourceSettingsIndex);
        o.setWavelength(convertLength(wavelength));
    }

    //////// Microscope ////////

    private Microscope getMicroscope(int instrumentIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        return getSourceObject(Microscope.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMicroscopeLotNumber(java.lang.String, int)
     */
    @Override
    public void setMicroscopeLotNumber(String lotNumber, int instrumentIndex)
    {
        Microscope o = getMicroscope(instrumentIndex);
        o.setLotNumber(toRType(lotNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMicroscopeManufacturer(java.lang.String, int)
     */
    @Override
    public void setMicroscopeManufacturer(String manufacturer,
            int instrumentIndex)
    {
        Microscope o = getMicroscope(instrumentIndex);
        o.setManufacturer(toRType(manufacturer));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMicroscopeModel(java.lang.String, int)
     */
    @Override
    public void setMicroscopeModel(String model, int instrumentIndex)
    {
        Microscope o = getMicroscope(instrumentIndex);
        o.setModel(toRType(model));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMicroscopeSerialNumber(java.lang.String, int)
     */
    @Override
    public void setMicroscopeSerialNumber(String serialNumber,
            int instrumentIndex)
    {
        Microscope o = getMicroscope(instrumentIndex);
        o.setSerialNumber(toRType(serialNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMicroscopeType(ome.xml.model.enums.MicroscopeType, int)
     */
    @Override
    public void setMicroscopeType(ome.xml.model.enums.MicroscopeType type,
            int instrumentIndex)
    {
        Microscope o = getMicroscope(instrumentIndex);
        o.setType((MicroscopeType)
                getEnumeration(MicroscopeType.class, type.toString()));
    }

    //////// Objective /////////

    public Objective getObjective(int instrumentIndex, int objectiveIndex)
    {
      LinkedHashMap<Index, Integer> indexes =
          new LinkedHashMap<Index, Integer>();
      indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
      indexes.put(Index.OBJECTIVE_INDEX, objectiveIndex);
      return getSourceObject(Objective.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveCalibratedMagnification(java.lang.Double, int, int)
     */
    @Override
    public void setObjectiveCalibratedMagnification(
            Double calibratedMagnification, int instrumentIndex,
            int objectiveIndex)
    {
        Objective o = getObjective(instrumentIndex, objectiveIndex);
        o.setCalibratedMagnification(toRType(calibratedMagnification));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveCorrection(ome.xml.model.enums.Correction, int, int)
     */
    @Override
    public void setObjectiveCorrection(
            ome.xml.model.enums.Correction correction, int instrumentIndex,
            int objectiveIndex)
    {
        Objective o = getObjective(instrumentIndex, objectiveIndex);
        o.setCorrection((Correction) getEnumeration(
            Correction.class, correction.toString()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveID(java.lang.String, int, int)
     */
    @Override
    public void setObjectiveID(String id, int instrumentIndex,
            int objectiveIndex)
    {
        checkDuplicateLSID(Objective.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.INSTRUMENT_INDEX, instrumentIndex);
        indexes.put(Index.OBJECTIVE_INDEX, objectiveIndex);
        IObjectContainer o = getIObjectContainer(Objective.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Objective.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveImmersion(ome.xml.model.enums.Immersion, int, int)
     */
    @Override
    public void setObjectiveImmersion(
            ome.xml.model.enums.Immersion immersion, int instrumentIndex,
            int objectiveIndex)
    {
        Objective o = getObjective(instrumentIndex, objectiveIndex);
        o.setImmersion(
            (Immersion) getEnumeration(Immersion.class, immersion.toString()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveIris(java.lang.Boolean, int, int)
     */
    @Override
    public void setObjectiveIris(Boolean iris, int instrumentIndex,
            int objectiveIndex)
    {
        Objective o = getObjective(instrumentIndex, objectiveIndex);
        o.setIris(toRType(iris));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveLensNA(java.lang.Double, int, int)
     */
    @Override
    public void setObjectiveLensNA(Double lensNA, int instrumentIndex,
            int objectiveIndex)
    {
        Objective o = getObjective(instrumentIndex, objectiveIndex);
        o.setLensNA(toRType(lensNA));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveLotNumber(java.lang.String, int, int)
     */
    @Override
    public void setObjectiveLotNumber(String lotNumber, int instrumentIndex,
            int objectiveIndex)
    {
        Objective o = getObjective(instrumentIndex, objectiveIndex);
        o.setLotNumber(toRType(lotNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveManufacturer(java.lang.String, int, int)
     */
    @Override
    public void setObjectiveManufacturer(String manufacturer,
            int instrumentIndex, int objectiveIndex)
    {
        Objective o = getObjective(instrumentIndex, objectiveIndex);
        o.setManufacturer(toRType(manufacturer));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveModel(java.lang.String, int, int)
     */
    @Override
    public void setObjectiveModel(String model, int instrumentIndex,
            int objectiveIndex)
    {
        Objective o = getObjective(instrumentIndex, objectiveIndex);
        o.setModel(toRType(model));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveNominalMagnification(java.lang.Double, int, int)
     */
    @Override
    public void setObjectiveNominalMagnification(Double nominalMagnification,
            int instrumentIndex, int objectiveIndex)
    {
        Objective o = getObjective(instrumentIndex, objectiveIndex);
        o.setNominalMagnification(toRType(nominalMagnification));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveSerialNumber(java.lang.String, int, int)
     */
    @Override
    public void setObjectiveSerialNumber(String serialNumber,
            int instrumentIndex, int objectiveIndex)
    {
        Objective o = getObjective(instrumentIndex, objectiveIndex);
        o.setSerialNumber(toRType(serialNumber));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveWorkingDistance(java.lang.Double, int, int)
     */
    @Override
    public void setObjectiveWorkingDistance(Length workingDistance,
            int instrumentIndex, int objectiveIndex)
    {
        Objective o = getObjective(instrumentIndex, objectiveIndex);
        o.setWorkingDistance(convertLength(workingDistance));
    }

    //////// Pixels /////////

    private Pixels getPixels(int imageIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.IMAGE_INDEX, imageIndex);
        Pixels p = getSourceObject(Pixels.class, indexes);
        p.setSha1(rstring("Pending..."));
        return p;

    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsID(java.lang.String, int)
     */
    @Override
    public void setPixelsID(String id, int imageIndex)
    {
        checkDuplicateLSID(Pixels.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.IMAGE_INDEX, imageIndex);
        IObjectContainer o = getIObjectContainer(Pixels.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Pixels.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsBigEndian(java.lang.Boolean,int)
     */
    @Override
    public void setPixelsBigEndian(Boolean value, int index)
    {
        ignoreUnneeded("setPixelsBigEndian", value, index);
    }

    @Override
    public void setPixelsBinData(byte[] binData, int imageIndex, int binDataIndex) {
        ignoreMissing("setPixelsBinData", imageIndex, binDataIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsBinDataBigEndian(java.lang.Boolean, int, int)
     */
    @Override
    public void setPixelsBinDataBigEndian(Boolean bigEndian, int imageIndex,
            int binDataIndex)
    {
        ignoreUnneeded("setPixelsBinDataBigEndian", bigEndian, imageIndex);
    }

    @Override
    public void setPixelsBinDataCompression(Compression compression, int imageIndex, int binDataIndex) {
        ignoreMissing("setPixelsBinDataCompression", compression, imageIndex, binDataIndex);
    }

    @Override
    public void setPixelsBinDataLength(NonNegativeLong length, int imageIndex, int binDataIndex) {
        ignoreMissing("setPixelsBinDataLength", length, imageIndex, binDataIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsDimensionOrder(ome.xml.model.enums.DimensionOrder, int)
     */
    @Override
    public void setPixelsDimensionOrder(
            ome.xml.model.enums.DimensionOrder dimensionOrder, int imageIndex)
    {
        Pixels o = getPixels(imageIndex);
        // We're always the same dimension order in the server; force it to
        // "XYZCT" (ticket:3124, ticket:3718, ticket:3668)
        o.setDimensionOrder((DimensionOrder) getEnumeration(
            DimensionOrder.class, "XYZCT"));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsInterleaved(java.lang.Boolean,int)
     */
    @Override
    public void  setPixelsInterleaved(Boolean value,  int index)
    {
        ignoreUnneeded("setPixelsInterleaved", value, index);
    }


    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsPhysicalSizeX(ome.xml.model.primitives.PositiveFloat, int)
     */
    @Override
    public void setPixelsPhysicalSizeX(Length physicalSizeX, int imageIndex)
    {
        Pixels o = getPixels(imageIndex);
        o.setPhysicalSizeX(convertLength(physicalSizeX));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsPhysicalSizeY(ome.xml.model.primitives.PositiveFloat, int)
     */
    @Override
    public void setPixelsPhysicalSizeY(Length physicalSizeY, int imageIndex)
    {
        Pixels o = getPixels(imageIndex);
        o.setPhysicalSizeY(convertLength(physicalSizeY));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsPhysicalSizeZ(ome.xml.model.primitives.PositiveFloat, int)
     */
    @Override
    public void setPixelsPhysicalSizeZ(Length physicalSizeZ, int imageIndex)
    {
        Pixels o = getPixels(imageIndex);
        o.setPhysicalSizeZ(convertLength(physicalSizeZ));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsSignificantBits(ome.xml.model.primitives.PositiveInteger,int)
     */
    @Override
    public void  setPixelsSignificantBits(PositiveInteger value,  int imageIndex)
    {
        Pixels o = getPixels(imageIndex);
        o.setSignificantBits(toRType(value));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsSizeC(ome.xml.model.primitives.PositiveInteger, int)
     */
    @Override
    public void setPixelsSizeC(PositiveInteger sizeC, int imageIndex)
    {
        Pixels o = getPixels(imageIndex);
        o.setSizeC(toRType(sizeC));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsSizeT(ome.xml.model.primitives.PositiveInteger, int)
     */
    @Override
    public void setPixelsSizeT(PositiveInteger sizeT, int imageIndex)
    {
        Pixels o = getPixels(imageIndex);
        o.setSizeT(toRType(sizeT));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsSizeX(ome.xml.model.primitives.PositiveInteger, int)
     */
    @Override
    public void setPixelsSizeX(PositiveInteger sizeX, int imageIndex)
    {
        Pixels o = getPixels(imageIndex);
        o.setSizeX(toRType(sizeX));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsSizeY(ome.xml.model.primitives.PositiveInteger, int)
     */
    @Override
    public void setPixelsSizeY(PositiveInteger sizeY, int imageIndex)
    {
        Pixels o = getPixels(imageIndex);
        o.setSizeY(toRType(sizeY));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsSizeZ(ome.xml.model.primitives.PositiveInteger, int)
     */
    @Override
    public void setPixelsSizeZ(PositiveInteger sizeZ, int imageIndex)
    {
        Pixels o = getPixels(imageIndex);
        o.setSizeZ(toRType(sizeZ));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsTimeIncrement(java.lang.Double, int)
     */
    @Override
    public void setPixelsTimeIncrement(Time timeIncrement, int imageIndex)
    {
        Pixels o = getPixels(imageIndex);
        o.setTimeIncrement(toRType(timeIncrement));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPixelsType(ome.xml.model.enums.PixelType, int)
     */
    @Override
    public void setPixelsType(PixelType type, int imageIndex)
    {
        Pixels o = getPixels(imageIndex);
        o.setPixelsType(
            (PixelsType) getEnumeration(PixelsType.class, type.toString()));
    }

    //////// Plane /////////

    private PlaneInfo getPlane(int imageIndex, int planeIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.IMAGE_INDEX, imageIndex);
        indexes.put(Index.PLANE_INDEX, planeIndex);
        return getSourceObject(PlaneInfo.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlaneAnnotationRef(java.lang.String, int, int, int)
     */
    @Override
    public void setPlaneAnnotationRef(String annotation, int imageIndex,
            int planeIndex, int annotationRefIndex)
    {
        LSID key = new LSID(
            PlaneInfo.class, imageIndex, planeIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlaneDeltaT(java.lang.Double, int, int)
     */
    @Override
    public void setPlaneDeltaT(Time deltaT, int imageIndex, int planeIndex)
    {
        PlaneInfo o = getPlane(imageIndex, planeIndex);
        o.setDeltaT(convertTime(deltaT));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlaneExposureTime(java.lang.Double, int, int)
     */
    @Override
    public void setPlaneExposureTime(Time exposureTime, int imageIndex,
            int planeIndex)
    {
        PlaneInfo o = getPlane(imageIndex, planeIndex);
        o.setExposureTime(convertTime(exposureTime));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlaneHashSHA1(java.lang.String, int, int)
     */
    @Override
    public void setPlaneHashSHA1(String hashSHA1, int imageIndex, int planeIndex)
    {
        ignoreUnneeded("setPlaneHashSHA1", hashSHA1, imageIndex, planeIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlanePositionX(java.lang.Double, int, int)
     */
    @Override
    public void setPlanePositionX(Length positionX, int imageIndex,
            int planeIndex)
    {
        PlaneInfo o = getPlane(imageIndex, planeIndex);
        o.setPositionX(convertLength(positionX));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlanePositionY(java.lang.Double, int, int)
     */
    @Override
    public void setPlanePositionY(Length positionY, int imageIndex,
            int planeIndex)
    {
        PlaneInfo o = getPlane(imageIndex, planeIndex);
        o.setPositionY(convertLength(positionY));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlanePositionZ(java.lang.Double, int, int)
     */
    @Override
    public void setPlanePositionZ(Length positionZ, int imageIndex,
            int planeIndex)
    {
        PlaneInfo o = getPlane(imageIndex, planeIndex);
        o.setPositionZ(convertLength(positionZ));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlaneTheC(java.lang.Integer, int, int)
     */
    @Override
    public void setPlaneTheC(NonNegativeInteger theC, int imageIndex, int planeIndex)
    {
        PlaneInfo o = getPlane(imageIndex, planeIndex);
        o.setTheC(toRType(theC));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlaneTheT(java.lang.Integer, int, int)
     */
    @Override
    public void setPlaneTheT(NonNegativeInteger theT, int imageIndex, int planeIndex)
    {
        PlaneInfo o = getPlane(imageIndex, planeIndex);
        o.setTheT(toRType(theT));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlaneTheZ(java.lang.Integer, int, int)
     */
    @Override
    public void setPlaneTheZ(NonNegativeInteger theZ, int imageIndex, int planeIndex)
    {
        PlaneInfo o = getPlane(imageIndex, planeIndex);
        o.setTheZ(toRType(theZ));
    }

    //////// PlateAcquisition /////////

    private PlateAcquisition getPlateAcquisition(
        int plateIndex, int plateAcquisitionIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.PLATE_INDEX, plateIndex);
        indexes.put(Index.PLATE_ACQUISITION_INDEX, plateAcquisitionIndex);
        return getSourceObject(PlateAcquisition.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateAcquisitionAnnotationRef(java.lang.String, int, int, int)
     */
    @Override
    public void setPlateAcquisitionAnnotationRef(String annotation,
            int plateIndex, int plateAcquisitionIndex, int annotationRefIndex)
    {
        LSID key = new LSID(PlateAcquisition.class, plateIndex,
            plateAcquisitionIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateAcquisitionDescription(java.lang.String, int, int)
     */
    @Override
    public void setPlateAcquisitionDescription(String description,
            int plateIndex, int plateAcquisitionIndex)
    {
        PlateAcquisition o =
            getPlateAcquisition(plateIndex, plateAcquisitionIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateAcquisitionEndTime(ome.xml.model.primitives.Timestamp, int, int)
     */
    @Override
    public void setPlateAcquisitionEndTime(Timestamp endTime, int plateIndex,
            int plateAcquisitionIndex)
    {
        PlateAcquisition o =
            getPlateAcquisition(plateIndex, plateAcquisitionIndex);
        o.setEndTime(toRType(endTime));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateAcquisitionID(java.lang.String, int, int)
     */
    @Override
    public void setPlateAcquisitionID(String id, int plateIndex,
            int plateAcquisitionIndex)
    {
        checkDuplicateLSID(PlateAcquisition.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.PLATE_INDEX, plateIndex);
        indexes.put(Index.PLATE_ACQUISITION_INDEX, plateAcquisitionIndex);
        IObjectContainer o =
            getIObjectContainer(PlateAcquisition.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(PlateAcquisition.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateAcquisitionMaximumFieldCount(java.lang.Integer, int, int)
     */
    @Override
    public void setPlateAcquisitionMaximumFieldCount(PositiveInteger maximumFieldCount,
            int plateIndex, int plateAcquisitionIndex)
    {
        PlateAcquisition o =
            getPlateAcquisition(plateIndex, plateAcquisitionIndex);
        o.setMaximumFieldCount(toRType(maximumFieldCount));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateAcquisitionName(java.lang.String, int, int)
     */
    @Override
    public void setPlateAcquisitionName(String name, int plateIndex,
            int plateAcquisitionIndex)
    {
        PlateAcquisition o =
            getPlateAcquisition(plateIndex, plateAcquisitionIndex);
        o.setName(toRType(name));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateAcquisitionStartTime(ome.xml.model.primitives.Timestamp, int, int)
     */
    @Override
    public void setPlateAcquisitionStartTime(Timestamp startTime, int plateIndex,
            int plateAcquisitionIndex)
    {
        PlateAcquisition o =
            getPlateAcquisition(plateIndex, plateAcquisitionIndex);
        o.setStartTime(toRType(startTime));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateAcquisitionWellSampleRef(java.lang.String, int, int, int)
     */
    @Override
    public void setPlateAcquisitionWellSampleRef(String wellSample,
            int plateIndex, int plateAcquisitionIndex, int wellSampleRefIndex)
    {
        LSID key = new LSID(PlateAcquisition.class, plateIndex,
            plateAcquisitionIndex);
        addReference(key, new LSID(wellSample));
    }

    //////// Plate /////////

    private Plate getPlate(int plateIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.PLATE_INDEX, plateIndex);
        return getSourceObject(Plate.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateAnnotationRef(java.lang.String, int, int)
     */
    @Override
    public void setPlateAnnotationRef(String annotation, int plateIndex,
            int annotationRefIndex)
    {
        LSID key = new LSID(Plate.class, plateIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateColumnNamingConvention(ome.xml.model.enums.NamingConvention, int)
     */
    @Override
    public void setPlateColumnNamingConvention(
            NamingConvention columnNamingConvention, int plateIndex)
    {
        Plate o = getPlate(plateIndex);
        o.setColumnNamingConvention(toRType(columnNamingConvention));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateColumns(java.lang.Integer, int)
     */
    @Override
    public void setPlateColumns(PositiveInteger columns, int plateIndex)
    {
        Plate o = getPlate(plateIndex);
        o.setColumns(toRType(columns));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateDescription(java.lang.String, int)
     */
    @Override
    public void setPlateDescription(String description, int plateIndex)
    {
        Plate o = getPlate(plateIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateExternalIdentifier(java.lang.String, int)
     */
    @Override
    public void setPlateExternalIdentifier(String externalIdentifier,
            int plateIndex)
    {
        Plate o = getPlate(plateIndex);
        o.setExternalIdentifier(toRType(externalIdentifier));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateID(java.lang.String, int)
     */
    @Override
    public void setPlateID(String id, int plateIndex)
    {
        checkDuplicateLSID(Plate.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.PLATE_INDEX, plateIndex);
        IObjectContainer o = getIObjectContainer(Plate.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Plate.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateName(java.lang.String, int)
     */
    @Override
    public void setPlateName(String name, int plateIndex)
    {
        Plate o = getPlate(plateIndex);
        o.setName(toRType(name));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateRowNamingConvention(ome.xml.model.enums.NamingConvention, int)
     */
    @Override
    public void setPlateRowNamingConvention(
            NamingConvention rowNamingConvention, int plateIndex)
    {
        Plate o = getPlate(plateIndex);
        o.setRowNamingConvention(toRType(rowNamingConvention));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateRows(java.lang.Integer, int)
     */
    @Override
    public void setPlateRows(PositiveInteger rows, int plateIndex)
    {
        Plate o = getPlate(plateIndex);
        o.setRows(toRType(rows));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateStatus(java.lang.String, int)
     */
    @Override
    public void setPlateStatus(String status, int plateIndex)
    {
        Plate o = getPlate(plateIndex);
        o.setStatus(toRType(status));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateWellOriginX(java.lang.Double, int)
     */
    @Override
    public void setPlateWellOriginX(Length wellOriginX, int plateIndex)
    {
        Plate o = getPlate(plateIndex);
        o.setWellOriginX(convertLength(wellOriginX));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateWellOriginY(java.lang.Double, int)
     */
    @Override
    public void setPlateWellOriginY(Length wellOriginY, int plateIndex)
    {
        Plate o = getPlate(plateIndex);
        o.setWellOriginY(convertLength(wellOriginY));
    }

    //////// Point /////////

    private Point getPoint(int ROIIndex, int shapeIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        return getSourceObject(Point.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointText(java.lang.String, int, int)
     */
    @Override
    public void setPointText(String text, int ROIIndex, int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setTextValue(toRType(text));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointFillColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setPointFillColor(Color fill, int ROIIndex, int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setFillColor(toRType(fill));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointFontSize(java.lang.Integer, int, int)
     */
    @Override
    public void setPointFontSize(Length fontSize, int ROIIndex, int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setFontSize(convertLength(fontSize));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointID(java.lang.String, int, int)
     */
    @Override
    public void setPointID(String id, int ROIIndex, int shapeIndex)
    {
        checkDuplicateLSID(Point.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        IObjectContainer o = getIObjectContainer(Point.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Point.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointStroke(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setPointStrokeColor(Color stroke, int ROIIndex, int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setStrokeColor(toRType(stroke));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointStrokeDashArray(java.lang.String, int, int)
     */
    @Override
    public void setPointStrokeDashArray(String strokeDashArray, int ROIIndex,
            int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setStrokeDashArray(toRType(strokeDashArray));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointStrokeWidth(java.lang.Double, int, int)
     */
    @Override
    public void setPointStrokeWidth(Length strokeWidth, int ROIIndex,
            int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setStrokeWidth(convertLength(strokeWidth));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointTheC(java.lang.Integer, int, int)
     */
    @Override
    public void setPointTheC(NonNegativeInteger theC, int ROIIndex, int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setTheC(toRType(theC));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointTheT(java.lang.Integer, int, int)
     */
    @Override
    public void setPointTheT(NonNegativeInteger theT, int ROIIndex, int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setTheT(toRType(theT));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointTheZ(java.lang.Integer, int, int)
     */
    @Override
    public void setPointTheZ(NonNegativeInteger theZ, int ROIIndex, int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setTheZ(toRType(theZ));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointTransform(ome.xml.model.AffineTransform, int, int)
     */
    @Override
    public void setPointTransform(AffineTransform transform, int ROIIndex, int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setTransform(toRType(transform));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointX(java.lang.Double, int, int)
     */
    @Override
    public void setPointX(Double x, int ROIIndex, int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setX(toRType(x));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointY(java.lang.Double, int, int)
     */
    @Override
    public void setPointY(Double y, int ROIIndex, int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setY(toRType(y));
    }

    //////// Polyline /////////

    private Polyline getPolyline(int ROIIndex, int shapeIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        return getSourceObject(Polyline.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineID(java.lang.String, int, int)
     */
    @Override
    public void setPolylineID(String id, int ROIIndex, int shapeIndex)
    {
        checkDuplicateLSID(Polyline.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        IObjectContainer o = getIObjectContainer(Polyline.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Polyline.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineText(java.lang.String, int, int)
     */
    @Override
    public void setPolylineText(String text, int ROIIndex, int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setTextValue(toRType(text));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineFillColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setPolylineFillColor(Color fill, int ROIIndex, int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setFillColor(toRType(fill));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineFontSize(java.lang.Integer, int, int)
     */
    @Override
    public void setPolylineFontSize(Length fontSize, int ROIIndex,
            int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setFontSize(convertLength(fontSize));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylinePoints(java.lang.String, int, int)
     */
    @Override
    public void setPolylinePoints(String points, int ROIIndex, int shapeIndex)
    {
      Polyline o = getPolyline(ROIIndex, shapeIndex);
      o.setPoints(toRType(points));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineStroke(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setPolylineStrokeColor(Color stroke, int ROIIndex, int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setStrokeColor(toRType(stroke));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineStrokeDashArray(java.lang.String, int, int)
     */
    @Override
    public void setPolylineStrokeDashArray(String strokeDashArray,
            int ROIIndex, int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setStrokeDashArray(toRType(strokeDashArray));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineStrokeWidth(java.lang.Double, int, int)
     */
    @Override
    public void setPolylineStrokeWidth(Length strokeWidth, int ROIIndex,
            int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setStrokeWidth(convertLength(strokeWidth));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineTheC(java.lang.Integer, int, int)
     */
    @Override
    public void setPolylineTheC(NonNegativeInteger theC, int ROIIndex, int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setTheC(toRType(theC));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineTheT(java.lang.Integer, int, int)
     */
    @Override
    public void setPolylineTheT(NonNegativeInteger theT, int ROIIndex, int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setTheT(toRType(theT));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineTheZ(java.lang.Integer, int, int)
     */
    @Override
    public void setPolylineTheZ(NonNegativeInteger theZ, int ROIIndex, int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setTheZ(toRType(theZ));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineTransform(ome.xml.model.AffineTransform, int, int)
     */
    @Override
    public void setPolylineTransform(AffineTransform transform, int ROIIndex,
            int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setTransform(toRType(transform));
    }

    //////// Project /////////

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setProjectID(java.lang.String, int)
     */
    @Override
    public void setProjectID(String id, int projectIndex)
    {
        ignoreUnsupported("setProjectID", id, projectIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setProjectAnnotationRef(java.lang.String, int, int)
     */
    @Override
    public void setProjectAnnotationRef(String annotation, int projectIndex,
            int annotationRefIndex)
    {
        ignoreUnsupported("setProjectAnnotationRef", annotation, projectIndex,
                annotationRefIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setProjectDescription(java.lang.String, int)
     */
    @Override
    public void setProjectDescription(String description, int projectIndex)
    {
        ignoreUnsupported("setProjectDescription", description, projectIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setProjectExperimenterRef(java.lang.String, int)
     */
    @Override
    public void setProjectExperimenterRef(String experimenter, int projectIndex)
    {
        ignoreInsecure("setProjectExperimenterRef", experimenter, projectIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setProjectExperimenterGroupRef(java.lang.String, int)
     */
    @Override
    public void setProjectExperimenterGroupRef(String group, int projectIndex)
    {
        ignoreInsecure("setProjectExperimenterGroupRef", group, projectIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setProjectName(java.lang.String, int)
     */
    @Override
    public void setProjectName(String name, int projectIndex)
    {
        ignoreInsecure("setProjectName", name, projectIndex);
    }

    //////// ROI /////////

    private Roi getROI(int ROIIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        return getSourceObject(Roi.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setROIID(java.lang.String, int)
     */
    @Override
    public void setROIID(String id, int ROIIndex)
    {
        checkDuplicateLSID(Roi.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        IObjectContainer o = getIObjectContainer(Roi.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Roi.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setROIAnnotationRef(java.lang.String, int, int)
     */
    @Override
    public void setROIAnnotationRef(String annotation, int ROIIndex,
            int annotationRefIndex)
    {
        LSID key = new LSID(Roi.class, ROIIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setROIDescription(java.lang.String, int)
     */
    @Override
    public void setROIDescription(String description, int ROIIndex)
    {
        Roi o = getROI(ROIIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setROIName(java.lang.String, int)
     */
    @Override
    public void setROIName(String name, int ROIIndex)
    {
        ignoreMissing("setROIName", name, ROIIndex);
    }

    //////// Reagent /////////

    /**
     * Retrieve Reagent
     * @param screenIndex the index of the screen
     * @param reagentIndex the index of the reagent within the screen
     * @return the reagent
     */
    private Reagent getReagent(int screenIndex, int reagentIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.SCREEN_INDEX, screenIndex);
        indexes.put(Index.REAGENT_INDEX, reagentIndex);
        return getSourceObject(Reagent.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setReagentID(java.lang.String, int, int)
     */
    @Override
    public void setReagentID(String id, int screenIndex, int reagentIndex)
    {
        checkDuplicateLSID(Reagent.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.SCREEN_INDEX, screenIndex);
        indexes.put(Index.REAGENT_INDEX, reagentIndex);
        IObjectContainer o = getIObjectContainer(Reagent.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Reagent.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setReagentAnnotationRef(java.lang.String, int, int, int)
     */
    @Override
    public void setReagentAnnotationRef(String annotation, int screenIndex,
            int reagentIndex, int annotationRefIndex)
    {
        LSID key = new LSID(Reagent.class, screenIndex, reagentIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setReagentDescription(java.lang.String, int, int)
     */
    @Override
    public void setReagentDescription(String description, int screenIndex,
            int reagentIndex)
    {
        Reagent o = getReagent(screenIndex, reagentIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setReagentName(java.lang.String, int, int)
     */
    @Override
    public void setReagentName(String name, int screenIndex, int reagentIndex)
    {
        Reagent o = getReagent(screenIndex, reagentIndex);
        o.setName(toRType(name));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setReagentReagentIdentifier(java.lang.String, int, int)
     */
    @Override
    public void setReagentReagentIdentifier(String reagentIdentifier,
            int screenIndex, int reagentIndex)
    {
        Reagent o = getReagent(screenIndex, reagentIndex);
        o.setReagentIdentifier(toRType(reagentIdentifier));
    }


    //////// Rectangle /////////

    /**
     * Retrieve the Rectangle object.
     * @param ROIIndex the index of the ROI
     * @param shapeIndex the index of the shape within the ROI
     * @return the rectangle
     */
    private Rectangle getRectangle(int ROIIndex, int shapeIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        return getSourceObject(Rectangle.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleID(java.lang.String, int, int)
     */
    @Override
    public void setRectangleID(String id, int ROIIndex, int shapeIndex)
    {
        checkDuplicateLSID(Rectangle.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        IObjectContainer o = getIObjectContainer(Rectangle.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Rectangle.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleText(java.lang.String, int, int)
     */
    @Override
    public void setRectangleText(String description, int ROIIndex,
            int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setTextValue(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleFillColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setRectangleFillColor(Color fill, int ROIIndex, int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setFillColor(toRType(fill));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleFontSize(java.lang.Integer, int, int)
     */
    @Override
    public void setRectangleFontSize(Length fontSize, int ROIIndex,
            int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setFontSize(convertLength(fontSize));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleHeight(java.lang.Double, int, int)
     */
    @Override
    public void setRectangleHeight(Double height, int ROIIndex, int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setHeight(toRType(height));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleStroke(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setRectangleStrokeColor(Color stroke, int ROIIndex, int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setStrokeColor(toRType(stroke));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleStrokeDashArray(java.lang.String, int, int)
     */
    @Override
    public void setRectangleStrokeDashArray(String strokeDashArray,
            int ROIIndex, int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setStrokeDashArray(toRType(strokeDashArray));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleStrokeWidth(java.lang.Double, int, int)
     */
    @Override
    public void setRectangleStrokeWidth(Length strokeWidth, int ROIIndex,
            int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setStrokeWidth(convertLength(strokeWidth));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleTheC(java.lang.Integer, int, int)
     */
    @Override
    public void setRectangleTheC(NonNegativeInteger theC, int ROIIndex, int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setTheC(toRType(theC));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleTheT(java.lang.Integer, int, int)
     */
    @Override
    public void setRectangleTheT(NonNegativeInteger theT, int ROIIndex, int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setTheT(toRType(theT));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleTheZ(java.lang.Integer, int, int)
     */
    @Override
    public void setRectangleTheZ(NonNegativeInteger theZ, int ROIIndex, int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setTheZ(toRType(theZ));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleTransform(ome.xml.model.AffineTransform, int, int)
     */
    @Override
    public void setRectangleTransform(AffineTransform transform, int ROIIndex,
            int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setTransform(toRType(transform));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleWidth(java.lang.Double, int, int)
     */
    @Override
    public void setRectangleWidth(Double width, int ROIIndex, int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setWidth(toRType(width));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleX(java.lang.Double, int, int)
     */
    @Override
    public void setRectangleX(Double x, int ROIIndex, int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setX(toRType(x));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleY(java.lang.Double, int, int)
     */
    @Override
    public void setRectangleY(Double y, int ROIIndex, int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setY(toRType(y));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRoot(MetadataRoot)
     */
    @Override
    public void setRoot(MetadataRoot root)
    {
        ignoreUnneeded("setRoot", root);
    }

    //////// Screen /////////

    /**
     * Retrieve Screen
     * @param screenIndex the index of the screen
     * @return the screen
     */
    private Screen getScreen(int screenIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.SCREEN_INDEX, screenIndex);
        return getSourceObject(Screen.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setScreenID(java.lang.String, int)
     */
    @Override
    public void setScreenID(String id, int screenIndex)
    {
        checkDuplicateLSID(Screen.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.SCREEN_INDEX, screenIndex);
        IObjectContainer o = getIObjectContainer(Screen.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Screen.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setScreenAnnotationRef(java.lang.String, int, int)
     */
    @Override
    public void setScreenAnnotationRef(String annotation, int screenIndex,
            int annotationRefIndex)
    {
        LSID key = new LSID(Screen.class, screenIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setScreenDescription(java.lang.String, int)
     */
    @Override
    public void setScreenDescription(String description, int screenIndex)
    {
        Screen o = getScreen(screenIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setScreenName(java.lang.String, int)
     */
    @Override
    public void setScreenName(String name, int screenIndex)
    {
        Screen o = getScreen(screenIndex);
        o.setName(toRType(name));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setScreenPlateRef(java.lang.String, int, int)
     */
    @Override
    public void setScreenPlateRef(String plate, int screenIndex,
            int plateRefIndex)
    {
        screenKey = new LSID(Screen.class, screenIndex);
        addReference(screenKey, new LSID(plate));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setScreenProtocolDescription(java.lang.String, int)
     */
    @Override
    public void setScreenProtocolDescription(String protocolDescription,
            int screenIndex)
    {
        Screen o = getScreen(screenIndex);
        o.setProtocolDescription(toRType(protocolDescription));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setScreenProtocolIdentifier(java.lang.String, int)
     */
    @Override
    public void setScreenProtocolIdentifier(String protocolIdentifier,
            int screenIndex)
    {
        Screen o = getScreen(screenIndex);
        o.setProtocolIdentifier(toRType(protocolIdentifier));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setScreenReagentSetDescription(java.lang.String, int)
     */
    @Override
    public void setScreenReagentSetDescription(String reagentSetDescription,
            int screenIndex)
    {
        Screen o = getScreen(screenIndex);
        o.setReagentSetDescription(toRType(reagentSetDescription));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setScreenReagentSetIdentifier(java.lang.String, int)
     */
    @Override
    public void setScreenReagentSetIdentifier(String reagentSetIdentifier,
            int screenIndex)
    {
        Screen o = getScreen(screenIndex);
        o.setReagentSetIdentifier(toRType(reagentSetIdentifier));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setScreenType(java.lang.String, int)
     */
    @Override
    public void setScreenType(String type, int screenIndex)
    {
        Screen o = getScreen(screenIndex);
        o.setType(toRType(type));
    }

    //////// StageLabel /////////

    /**
     * Retrieve StageLabel
     * @param imageIndex the index of the image
     * @return the image's stage label
     */
    private StageLabel getStageLabel(int imageIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.IMAGE_INDEX, imageIndex);
        return getSourceObject(StageLabel.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setStageLabelName(java.lang.String, int)
     */
    @Override
    public void setStageLabelName(String name, int imageIndex)
    {
        StageLabel o = getStageLabel(imageIndex);
        o.setName(toRType(name));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setStageLabelX(java.lang.Double, int)
     */
    @Override
    public void setStageLabelX(Length x, int imageIndex)
    {
        StageLabel o = getStageLabel(imageIndex);
        o.setPositionX(convertLength(x));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setStageLabelY(java.lang.Double, int)
     */
    @Override
    public void setStageLabelY(Length y, int imageIndex)
    {
        StageLabel o = getStageLabel(imageIndex);
        o.setPositionY(convertLength(y));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setStageLabelZ(java.lang.Double, int)
     */
    @Override
    public void setStageLabelZ(Length z, int imageIndex)
    {
        StageLabel o = getStageLabel(imageIndex);
        o.setPositionZ(convertLength(z));
    }

    //////// String Annotation /////////

    /**
     * Retrieve CommentAnnotation object
     * @param commentAnnotationIndex the index of the comment annotation
     * @return the comment annotation
     */
    private CommentAnnotation getCommentAnnotation(int commentAnnotationIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.COMMENT_ANNOTATION_INDEX, commentAnnotationIndex);
        return getSourceObject(CommentAnnotation.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setCommentAnnotationID(java.lang.String, int)
     */
    @Override
    public void setCommentAnnotationID(String id, int commentAnnotationIndex)
    {
        checkDuplicateLSID(CommentAnnotation.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.COMMENT_ANNOTATION_INDEX, commentAnnotationIndex);
        IObjectContainer o = getIObjectContainer(CommentAnnotation.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(CommentAnnotation.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setCommentAnnotationNamespace(java.lang.String, int)
     */
    @Override
    public void setCommentAnnotationNamespace(String namespace,
            int commentAnnotationIndex)
    {
        CommentAnnotation o = getCommentAnnotation(commentAnnotationIndex);
        o.setNs(toRType(namespace));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setCommentAnnotationAnnotator(java.lang.String,int)
     */
    @Override
    public void  setCommentAnnotationAnnotator(String value, int index)
    {
        ignoreAnnotator("setCommentAnnotationAnnotator", value, index);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setCommentAnnotationValue(java.lang.String, int)
     */
    @Override
    public void setCommentAnnotationValue(String value, int commentAnnotationIndex)
    {
        CommentAnnotation o = getCommentAnnotation(commentAnnotationIndex);
        o.setTextValue(toRType(value));
    }

    //////// Label /////////

    /**
     * Retrieve the Label object
     * @param ROIIndex the index of the ROI
     * @param shapeIndex the index of the shape within the ROI
     * @return the label
     */
    private Label getLabel(int ROIIndex, int shapeIndex)
    {

        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        return getSourceObject(Label.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelID(java.lang.String, int, int)
     */
    @Override
    public void setLabelID(String id, int ROIIndex, int shapeIndex)
    {
        checkDuplicateLSID(Label.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        IObjectContainer o = getIObjectContainer(Label.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Label.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelText(java.lang.String, int, int)
     */
    @Override
    public void setLabelText(String text, int ROIIndex, int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setTextValue(toRType(text));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelFillColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setLabelFillColor(Color fill, int ROIIndex, int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setFillColor(toRType(fill));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelFontSize(ome.xml.model.primitives.NonNegativeInteger, int, int)
     */
    @Override
    public void setLabelFontSize(Length fontSize, int ROIIndex, int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setFontSize(convertLength(fontSize));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelStrokeColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setLabelStrokeColor(Color stroke, int ROIIndex, int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setStrokeColor(toRType(stroke));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelStrokeDashArray(java.lang.String, int, int)
     */
    @Override
    public void setLabelStrokeDashArray(String strokeDashArray, int ROIIndex,
            int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setStrokeDashArray(toRType(strokeDashArray));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelStrokeWidth(java.lang.Double, int, int)
     */
    @Override
    public void setLabelStrokeWidth(Length strokeWidth, int ROIIndex,
            int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setStrokeWidth(convertLength (strokeWidth));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelTheC(ome.xml.model.primitives.NonNegativeInteger, int, int)
     */
    @Override
    public void setLabelTheC(NonNegativeInteger theC, int ROIIndex, int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setTheC(toRType(theC));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelTheT(ome.xml.model.primitives.NonNegativeInteger, int, int)
     */
    @Override
    public void setLabelTheT(NonNegativeInteger theT, int ROIIndex, int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setTheT(toRType(theT));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelTheZ(ome.xml.model.primitives.NonNegativeInteger, int, int)
     */
    @Override
    public void setLabelTheZ(NonNegativeInteger theZ, int ROIIndex, int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setTheZ(toRType(theZ));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelTransform(ome.xml.model.AffineTransform, int, int)
     */
    @Override
    public void setLabelTransform(AffineTransform transform, int ROIIndex, int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setTransform(toRType(transform));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelX(java.lang.Double, int, int)
     */
    @Override
    public void setLabelX(Double x, int ROIIndex, int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setX(toRType(x));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelY(java.lang.Double, int, int)
     */
    @Override
    public void setLabelY(Double y, int ROIIndex, int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setY(toRType(y));
    }

    //////// TiffData /////////

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTiffDataFirstC(java.lang.Integer, int, int)
     */
    @Override
    public void setTiffDataFirstC(NonNegativeInteger firstC, int imageIndex,
            int tiffDataIndex)
    {
        ignoreUnneeded("setTiffDataFirstC", firstC, imageIndex, tiffDataIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTiffDataFirstT(java.lang.Integer, int, int)
     */
    @Override
    public void setTiffDataFirstT(NonNegativeInteger firstT, int imageIndex,
            int tiffDataIndex)
    {
        ignoreUnneeded("setTiffDataFirstT", firstT, imageIndex, tiffDataIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTiffDataFirstZ(java.lang.Integer, int, int)
     */
    @Override
    public void setTiffDataFirstZ(NonNegativeInteger firstZ, int imageIndex,
            int tiffDataIndex)
    {
        ignoreUnneeded("setTiffDataFirstZ", firstZ, imageIndex, tiffDataIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTiffDataIFD(java.lang.Integer, int, int)
     */
    @Override
    public void setTiffDataIFD(NonNegativeInteger ifd, int imageIndex, int tiffDataIndex)
    {
        ignoreUnneeded("setTiffDataIFD", ifd, imageIndex, tiffDataIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTiffDataPlaneCount(java.lang.Integer, int, int)
     */
    @Override
    public void setTiffDataPlaneCount(NonNegativeInteger planeCount, int imageIndex,
            int tiffDataIndex)
    {
        ignoreUnneeded("setTiffDataPlaneCount", planeCount, imageIndex, tiffDataIndex);
    }

    //////// Timestamp /////////

    /**
     * Retrieve TimestampAnnotation
     * @param timestampAnnotationIndex the index of the timestamp annotation
     * @return the timestamp annotation
     */
    private TimestampAnnotation getTimestampAnnotation(int timestampAnnotationIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.TIMESTAMP_ANNOTATION_INDEX, timestampAnnotationIndex);
        return getSourceObject(TimestampAnnotation.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTimestampAnnotationID(java.lang.String, int)
     */
    @Override
    public void setTimestampAnnotationID(String id, int timestampAnnotationIndex)
    {
        checkDuplicateLSID(TimestampAnnotation.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.TIMESTAMP_ANNOTATION_INDEX, timestampAnnotationIndex);
        IObjectContainer o = getIObjectContainer(TimestampAnnotation.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(TimestampAnnotation.class, id, o);       }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTimestampAnnotationNamespace(java.lang.String, int)
     */
    @Override
    public void setTimestampAnnotationNamespace(String namespace,
            int timestampAnnotationIndex)
    {
        TimestampAnnotation o = getTimestampAnnotation(timestampAnnotationIndex);
        o.setNs(toRType(namespace));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTimestampAnnotationValue(ome.xml.model.primitives.Timestamp, int)
     */
    @Override
    public void setTimestampAnnotationValue(Timestamp value,
            int timestampAnnotationIndex)
    {
        TimestampAnnotation o = getTimestampAnnotation(timestampAnnotationIndex);
        o.setTimeValue(toRType(value));
    }

    //////// TransmittanceRange /////////

    private TransmittanceRange getTransmittanceRange(int instrumentIndex, int filterIndex)
    {
        Filter filter = getFilter(instrumentIndex, filterIndex);
        TransmittanceRange tm = filter.getTransmittanceRange();
        if (tm == null)
        {
            tm = new TransmittanceRangeI();
            filter.setTransmittanceRange(tm);
        }
        return tm;
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTransmittanceRangeCutIn(java.lang.Integer, int, int)
     */
    @Override
    public void setTransmittanceRangeCutIn(Length cutIn, int instrumentIndex,
            int filterIndex)
    {
        TransmittanceRange o = getTransmittanceRange(instrumentIndex, filterIndex);
        o.setCutIn(convertLength(cutIn));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTransmittanceRangeCutInTolerance(java.lang.Integer, int, int)
     */
    @Override
    public void setTransmittanceRangeCutInTolerance(Length cutInTolerance,
            int instrumentIndex, int filterIndex)
    {
        TransmittanceRange o = getTransmittanceRange(instrumentIndex, filterIndex);
        o.setCutInTolerance(convertLength(cutInTolerance));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTransmittanceRangeCutOut(java.lang.Integer, int, int)
     */
    @Override
    public void setTransmittanceRangeCutOut(Length cutOut,
            int instrumentIndex, int filterIndex)
    {
        TransmittanceRange o = getTransmittanceRange(instrumentIndex, filterIndex);
        o.setCutOut(convertLength(cutOut));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTransmittanceRangeCutOutTolerance(java.lang.Integer, int, int)
     */
    @Override
    public void setTransmittanceRangeCutOutTolerance(Length cutOutTolerance,
            int instrumentIndex, int filterIndex)
    {
        TransmittanceRange o = getTransmittanceRange(instrumentIndex, filterIndex);
        o.setCutOutTolerance(convertLength(cutOutTolerance));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTransmittanceRangeTransmittance(ome.xml.model.primitives.PercentFraction, int, int)
     */
    @Override
    public void setTransmittanceRangeTransmittance(
            PercentFraction transmittance, int instrumentIndex, int filterIndex)
    {
        TransmittanceRange o = getTransmittanceRange(instrumentIndex, filterIndex);
        o.setTransmittance(toRType(transmittance));
    }

    //////// UUID /////////

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setUUID(java.lang.String)
     */
    @Override
    public void setUUID(String uuid)
    {
        ignoreUnneeded("setUUID", uuid);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setUUIDFileName(java.lang.String, int, int)
     */
    @Override
    public void setUUIDFileName(String fileName, int imageIndex,
            int tiffDataIndex)
    {
        ignoreUnneeded("setUUIDFileName", fileName, imageIndex, tiffDataIndex);
    }

    @Override
    public void setUUIDValue(String fileName, int imageIndex,
            int tiffDataIndex)
    {
        ignoreUnneeded("setUUIDValue", fileName, imageIndex, tiffDataIndex);
    }

    //////// Well /////////

    /**
     * Retrieve Well
     * @param plateIndex the index of the plate
     * @param wellIndex the index of the well within the plate
     * @return the well
     */
    private Well getWell(int plateIndex, int wellIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.PLATE_INDEX, plateIndex);
        indexes.put(Index.WELL_INDEX, wellIndex);
        return getSourceObject(Well.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellID(java.lang.String, int, int)
     */
    @Override
    public void setWellID(String id, int plateIndex, int wellIndex)
    {
        checkDuplicateLSID(Well.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.PLATE_INDEX, plateIndex);
        indexes.put(Index.WELL_INDEX, wellIndex);
        IObjectContainer o = getIObjectContainer(Well.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Well.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellAnnotationRef(java.lang.String, int, int, int)
     */
    @Override
    public void setWellAnnotationRef(String annotation, int plateIndex,
            int wellIndex, int annotationRefIndex)
    {
        LSID key = new LSID(Well.class, plateIndex, wellIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setWellColor(Color color, int plateIndex, int wellIndex)
    {
        Well o = getWell(plateIndex, wellIndex);
        o.setRed(toRType(color.getRed()));
        o.setGreen(toRType(color.getGreen()));
        o.setBlue(toRType(color.getBlue()));
        o.setAlpha(toRType(color.getAlpha()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellColumn(ome.xml.model.primitives.NonNegativeInteger, int, int)
     */
    @Override
    public void setWellColumn(NonNegativeInteger column, int plateIndex,
            int wellIndex)
    {
        Well o = getWell(plateIndex, wellIndex);
        o.setColumn(toRType(column));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellExternalDescription(java.lang.String, int, int)
     */
    @Override
    public void setWellExternalDescription(String externalDescription,
            int plateIndex, int wellIndex)
    {
        Well o = getWell(plateIndex, wellIndex);
        o.setExternalDescription(toRType(externalDescription));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellExternalIdentifier(java.lang.String, int, int)
     */
    @Override
    public void setWellExternalIdentifier(String externalIdentifier,
            int plateIndex, int wellIndex)
    {
        Well o = getWell(plateIndex, wellIndex);
        o.setExternalIdentifier(toRType(externalIdentifier));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellReagentRef(java.lang.String, int, int)
     */
    @Override
    public void setWellReagentRef(String reagent, int plateIndex, int wellIndex)
    {
        LSID key = new LSID(Well.class, plateIndex, wellIndex);
        addReference(key, new LSID(reagent));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellRow(ome.xml.model.primitives.NonNegativeInteger, int, int)
     */
    @Override
    public void setWellRow(NonNegativeInteger row, int plateIndex, int wellIndex)
    {
        Well o = getWell(plateIndex, wellIndex);
        o.setRow(toRType(row));
    }

    //////// WellSample /////////

    /**
     * Retrieve WellSample
     * @param plateIndex the index of the plate
     * @param wellIndex the index of the well within the plate
     * @param wellSampleIndex the index of the field within the well
     * @return the well sample
     */
    private WellSample getWellSample(int plateIndex, int wellIndex, int wellSampleIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.PLATE_INDEX, plateIndex);
        indexes.put(Index.WELL_INDEX, wellIndex);
        indexes.put(Index.WELL_SAMPLE_INDEX, wellSampleIndex);

        WellSample ws = getSourceObject(WellSample.class, indexes);
        return ws;
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellSampleID(java.lang.String, int, int, int)
     */
    @Override
    public void setWellSampleID(String id, int plateIndex, int wellIndex,
            int wellSampleIndex)
    {
        checkDuplicateLSID(WellSample.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.PLATE_INDEX, plateIndex);
        indexes.put(Index.WELL_INDEX, wellIndex);
        indexes.put(Index.WELL_SAMPLE_INDEX, wellSampleIndex);
        IObjectContainer o = getIObjectContainer(WellSample.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(WellSample.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellSampleImageRef(java.lang.String, int, int, int)
     */
    @Override
    public void setWellSampleImageRef(String image, int plateIndex,
            int wellIndex, int wellSampleIndex)
    {
        LSID key = new LSID(WellSample.class, plateIndex, wellIndex, wellSampleIndex);
        addReference(key, new LSID(image));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellSampleIndex(ome.xml.model.primitives.NonNegativeInteger, int, int, int)
     */
    @Override
    public void setWellSampleIndex(NonNegativeInteger index, int plateIndex,
            int wellIndex, int wellSampleIndex)
    {
        ignoreMissing("setWellSampleIndex", index, plateIndex, wellIndex,
                wellSampleIndex);
        // Perhaps "unneeded"?
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellSamplePositionX(java.lang.Double, int, int, int)
     */
    @Override
    public void setWellSamplePositionX(Length positionX, int plateIndex,
            int wellIndex, int wellSampleIndex)
    {
        WellSample o = getWellSample(plateIndex, wellIndex, wellSampleIndex);
        o.setPosX(convertLength(positionX));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellSamplePositionY(java.lang.Double, int, int, int)
     */
    @Override
    public void setWellSamplePositionY(Length positionY, int plateIndex,
            int wellIndex, int wellSampleIndex)
    {
        WellSample o = getWellSample(plateIndex, wellIndex, wellSampleIndex);
        o.setPosY(convertLength(positionY));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellSampleTimepoint(ome.xml.model.primitives.Timestamp, int, int, int)
     */
    @Override
    public void setWellSampleTimepoint(Timestamp timepoint, int plateIndex,
            int wellIndex, int wellSampleIndex)
    {
        if (timepoint == null)
        {
            return;
        }
        WellSample o =
            getWellSample(plateIndex, wellIndex, wellSampleIndex);
        o.setTimepoint(toRType(timepoint));
    }

    //////// XMLAnnotation /////////

    /**
     * Retrieve XMLAnnotation
     * @param XMLAnnotationIndex the index of the XML annotation
     * @return the XML annotation
     */

    private XmlAnnotation getXMLAnnotation(int XMLAnnotationIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.XML_ANNOTATION_INDEX, XMLAnnotationIndex);
        return getSourceObject(XmlAnnotation.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setXMLAnnotationID(java.lang.String, int)
     */
    @Override
    public void setXMLAnnotationID(String id, int XMLAnnotationIndex)
    {
        checkDuplicateLSID(XmlAnnotation.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.XML_ANNOTATION_INDEX, XMLAnnotationIndex);
        IObjectContainer o = getIObjectContainer(XmlAnnotation.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(XmlAnnotation.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setXMLAnnotationNamespace(java.lang.String, int)
     */
    @Override
    public void setXMLAnnotationNamespace(String namespace,
            int XMLAnnotationIndex)
    {
        XmlAnnotation o = getXMLAnnotation(XMLAnnotationIndex);
        o.setNs(toRType(namespace));
   }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setXMLAnnotationValue(java.lang.String, int)
     */
   @Override
    public void setXMLAnnotationValue(String value, int XMLAnnotationIndex)
    {
        XmlAnnotation o = getXMLAnnotation(XMLAnnotationIndex);
        o.setTextValue(toRType(value));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setXMLAnnotationAnnotator(java.lang.String,int)
     */
   @Override
    public void  setXMLAnnotationAnnotator(String value, int index)
    {
        ignoreAnnotator("setXMLAnnotationAnnotator", value, index);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setXMLAnnotationAnnotationRef(java.lang.String, int, int)
     */
   @Override
    public void setXMLAnnotationAnnotationRef(String annotation,
            int XMLAnnotationIndex, int annotationRefIndex)
    {
        LSID key = new LSID(XmlAnnotation.class, XMLAnnotationIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setXMLAnnotationDescription(java.lang.String, int)
     */
   @Override
    public void setXMLAnnotationDescription(String description,
            int XMLAnnotationIndex)
    {
        XmlAnnotation o = getXMLAnnotation(XMLAnnotationIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setBooleanAnnotationAnnotationRef(java.lang.String, int, int)
     */
   @Override
    public void setBooleanAnnotationAnnotationRef(String annotation,
            int booleanAnnotationIndex, int annotationRefIndex)
    {
        LSID key = new LSID(BooleanAnnotation.class, booleanAnnotationIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setBooleanAnnotationDescription(java.lang.String, int)
     */
   @Override
    public void setBooleanAnnotationDescription(String description,
            int booleanAnnotationIndex)
    {
        BooleanAnnotation o = getBooleanAnnotation(booleanAnnotationIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setBooleanAnnotationAnnotator(java.lang.String,int)
     */
   @Override
    public void  setBooleanAnnotationAnnotator(String value, int index)
    {
        ignoreAnnotator("setBooleanAnnotationAnnotator", value, index);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setCommentAnnotationAnnotationRef(java.lang.String, int, int)
     */
   @Override
    public void setCommentAnnotationAnnotationRef(String annotation,
            int commentAnnotationIndex, int annotationRefIndex)
    {
        LSID key = new LSID(CommentAnnotation.class, commentAnnotationIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setCommentAnnotationDescription(java.lang.String, int)
     */
   @Override
    public void setCommentAnnotationDescription(String description,
            int commentAnnotationIndex)
    {
        CommentAnnotation o = getCommentAnnotation(commentAnnotationIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDoubleAnnotationAnnotationRef(java.lang.String, int, int)
     */
   @Override
    public void setDoubleAnnotationAnnotationRef(String annotation,
            int doubleAnnotationIndex, int annotationRefIndex)
    {
        LSID key = new LSID(DoubleAnnotation.class, doubleAnnotationIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDoubleAnnotationDescription(java.lang.String, int)
     */
   @Override
    public void setDoubleAnnotationDescription(String description,
            int doubleAnnotationIndex)
    {
        DoubleAnnotation o = getDoubleAnnotation(doubleAnnotationIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDoubleAnnotationAnnotator(java.lang.String,int)
     */
   @Override
    public void  setDoubleAnnotationAnnotator(String value, int index)
    {
        ignoreAnnotator("setDoubleAnnotationAnnotator", value, index);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFileAnnotationAnnotationRef(java.lang.String, int, int)
     */
   @Override
    public void setFileAnnotationAnnotationRef(String annotation,
            int fileAnnotationIndex, int annotationRefIndex)
    {
        LSID key = new LSID(FileAnnotation.class, fileAnnotationIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFileAnnotationDescription(java.lang.String, int)
     */
   @Override
    public void setFileAnnotationDescription(String description,
            int fileAnnotationIndex)
    {
        FileAnnotation o = getFileAnnotation(fileAnnotationIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFileAnnotationAnnotator(java.lang.String,int)
     */
   @Override
    public void  setFileAnnotationAnnotator(String value, int index)
    {
        ignoreAnnotator("setFileAnnotationAnnotator", value, index);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setListAnnotationDescription(java.lang.String, int)
     */
   @Override
    public void setListAnnotationDescription(String description,
            int listAnnotationIndex)
    {
        ListAnnotation o = getListAnnotation(listAnnotationIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setListAnnotationAnnotator(java.lang.String,int)
     */
   @Override
    public void  setListAnnotationAnnotator(String value, int index)
    {
        ignoreAnnotator("setListAnnotationAnnotator", value, index);
    }


    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLongAnnotationAnnotationRef(java.lang.String, int, int)
     */
   @Override
    public void setLongAnnotationAnnotationRef(String annotation,
            int longAnnotationIndex, int annotationRefIndex)
    {
        LSID key = new LSID(LongAnnotation.class, longAnnotationIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLongAnnotationDescription(java.lang.String, int)
     */
   @Override
    public void setLongAnnotationDescription(String description,
            int longAnnotationIndex)
    {
        LongAnnotation o = getLongAnnotation(longAnnotationIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLongAnnotationAnnotator(java.lang.String,int)
     */
   @Override
    public void  setLongAnnotationAnnotator(String value, int XMLAnnotationIndex)
    {
        ignoreAnnotator("setLongAnnotationAnnotator", value, XMLAnnotationIndex);
    }

    private MapAnnotation getMapAnnotation(int mapAnnotationIndex)
    {
        final LinkedHashMap<Index, Integer> indexes = new LinkedHashMap<Index, Integer>(1);
        indexes.put(Index.MAP_ANNOTATION_INDEX, mapAnnotationIndex);
        return getSourceObject(MapAnnotation.class, indexes);
    }

    @Override
    public void setMapAnnotationAnnotationRef(String annotation, int mapAnnotationIndex, int annotationRefIndex) {
        final LSID key = new LSID(MapAnnotation.class, mapAnnotationIndex);
        addReference(key, new LSID(annotation));
    }

    @Override
    public void setMapAnnotationAnnotator(String annotator, int mapAnnotationIndex) {
        ignoreAnnotator("setMapAnnotationAnnotator", annotator, mapAnnotationIndex);
    }

    @Override
    public void setMapAnnotationDescription(String description, int mapAnnotationIndex) {
        final MapAnnotation o = getMapAnnotation(mapAnnotationIndex);
        o.setDescription(toRType(description));
    }

    @Override
    public void setMapAnnotationID(String id, int mapAnnotationIndex) {
        checkDuplicateLSID(MapAnnotation.class, id);
        final LinkedHashMap<Index, Integer> indexes = new LinkedHashMap<Index, Integer>(1);
        indexes.put(Index.MAP_ANNOTATION_INDEX, mapAnnotationIndex);
        final IObjectContainer o = getIObjectContainer(MapAnnotation.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(MapAnnotation.class, id, o);
    }

    @Override
    public void setMapAnnotationNamespace(String namespace, int mapAnnotationIndex) {
        final MapAnnotation o = getMapAnnotation(mapAnnotationIndex);
        o.setNs(toRType(namespace));
    }

    @Override
    public void setMapAnnotationValue(List<MapPair> value, int mapAnnotationIndex) {
        final MapAnnotation o = getMapAnnotation(mapAnnotationIndex);
        o.setMapValue(IceMapper.convertMapPairs(value));
    }

    /**
     * Retrieve TagAnnotation object
     * @param tagAnnotationIndex the index of the tag annotation
     * @return the tag annotation
     */
    private TagAnnotation getTagAnnotation(int tagAnnotationIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.TAG_ANNOTATION_INDEX, tagAnnotationIndex);
        return getSourceObject(TagAnnotation.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTagAnnotationAnnotationRef(java.lang.String, int, int)
     */
    @Override
    public void setTagAnnotationAnnotationRef(String annotation,
            int tagAnnotationIndex, int annotationRefIndex)
    {
        LSID key = new LSID(TagAnnotation.class, tagAnnotationIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTagAnnotationDescription(java.lang.String, int)
     */
    @Override
    public void setTagAnnotationDescription(String description,
            int tagAnnotationIndex)
    {
        TagAnnotation o = getTagAnnotation(tagAnnotationIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTagAnnotationID(java.lang.String, int)
     */
    @Override
    public void setTagAnnotationID(String id, int tagAnnotationIndex)
    {
        checkDuplicateLSID(TagAnnotation.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.TAG_ANNOTATION_INDEX, tagAnnotationIndex);
        IObjectContainer o = getIObjectContainer(TagAnnotation.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(TagAnnotation.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTagAnnotationNamespace(java.lang.String, int)
     */
    @Override
    public void setTagAnnotationNamespace(String namespace,
            int tagAnnotationIndex)
    {
        TagAnnotation o = getTagAnnotation(tagAnnotationIndex);
        o.setNs(toRType(namespace));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTagAnnotationAnnotator(java.lang.String,int)
     */
    @Override
    public void  setTagAnnotationAnnotator(String value, int index)
    {
        ignoreAnnotator("setTagAnnotationAnnotator", value, index);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTagAnnotationValue(java.lang.String, int)
     */
    @Override
    public void setTagAnnotationValue(String value, int tagAnnotationIndex)
    {
        TagAnnotation o = getTagAnnotation(tagAnnotationIndex);
        o.setTextValue(toRType(value));
    }

    /**
     * Retrieve TermAnnotation object
     * @param termAnnotationIndex the index of the term annotation
     * @return the term annotation
     */
    private TermAnnotation getTermAnnotation(int termAnnotationIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.TERM_ANNOTATION_INDEX, termAnnotationIndex);
        return getSourceObject(TermAnnotation.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTermAnnotationAnnotationRef(java.lang.String, int, int)
     */
    @Override
    public void setTermAnnotationAnnotationRef(String annotation,
            int termAnnotationIndex, int annotationRefIndex)
    {
        LSID key = new LSID(TermAnnotation.class, termAnnotationIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTermAnnotationDescription(java.lang.String, int)
     */
    @Override
    public void setTermAnnotationDescription(String description,
            int termAnnotationIndex)
    {
        TermAnnotation o = getTermAnnotation(termAnnotationIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTermAnnotationID(java.lang.String, int)
     */
    @Override
    public void setTermAnnotationID(String id, int termAnnotationIndex)
    {
        checkDuplicateLSID(TermAnnotation.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.TERM_ANNOTATION_INDEX, termAnnotationIndex);
        IObjectContainer o = getIObjectContainer(TermAnnotation.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(TermAnnotation.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTermAnnotationNamespace(java.lang.String, int)
     */
    @Override
    public void setTermAnnotationNamespace(String namespace,
            int termAnnotationIndex)
    {
        TermAnnotation o = getTermAnnotation(termAnnotationIndex);
        o.setNs(toRType(namespace));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTermAnnotationAnnotator(java.lang.String,int)
     */
    @Override
    public void  setTermAnnotationAnnotator(String value, int index)
    {
        ignoreAnnotator("setTermAnnotationAnnotator", value, index);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTermAnnotationValue(java.lang.String, int)
     */
    @Override
    public void setTermAnnotationValue(String value, int termAnnotationIndex)
    {
        TermAnnotation o = getTermAnnotation(termAnnotationIndex);
        o.setTermValue(toRType(value));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTimestampAnnotationAnnotationRef(java.lang.String, int, int)
     */
    @Override
    public void setTimestampAnnotationAnnotationRef(String annotation,
            int timestampAnnotationIndex, int annotationRefIndex)
    {
        LSID key = new LSID(TimestampAnnotation.class, timestampAnnotationIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTimestampAnnotationDescription(java.lang.String, int)
     */
    @Override
    public void setTimestampAnnotationDescription(String description,
            int timestampAnnotationIndex)
    {
        TimestampAnnotation o = getTimestampAnnotation(timestampAnnotationIndex);
        o.setDescription(toRType(description));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setTimestampAnnotationAnnotator(java.lang.String,int)
     */
    @Override
    public void  setTimestampAnnotationAnnotator(String value, int index)
    {
        ignoreAnnotator("setTimestampAnnotationAnnotator", value, index);
    }

    //
    // 4.4.0 additions
    //

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPlateFieldIndex(ome.xml.model.primitives.NonNegativeInteger, int)
     */
    @Override
    public void setPlateFieldIndex(NonNegativeInteger fieldIndex, int plateIndex)
    {
        ignoreMissing("setPlateFieldIndex", fieldIndex, plateIndex);
    }

    @Override
    public void setBinaryFileBinData(byte[] binData, int fileAnnotationIndex) {
        ignoreMissing("setBinaryFileBinData", fileAnnotationIndex);
    }

    @Override
    public void setBinaryFileBinDataBigEndian(Boolean isBigEndian, int fileAnnotationIndex) {
        ignoreMissing("setBinaryFileBinDataBigEndian", isBigEndian, fileAnnotationIndex);
    }

    @Override
    public void setBinaryFileBinDataCompression(Compression compression, int fileAnnotationIndex) {
        ignoreMissing("setBinaryFileBinDataCompression", compression, fileAnnotationIndex);
    }

    @Override
    public void setBinaryFileBinDataLength(NonNegativeLong length, int fileAnnotationIndex) {
        ignoreMissing("setBinaryFileBinDataLength", length, fileAnnotationIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setBinaryFileFileName(java.lang.String, int)
     */
    @Override
    public void setBinaryFileFileName(String fileName, int fileAnnotationIndex)
    {
        ignoreUnneeded("setBinaryFileFileName", fileName,
                fileAnnotationIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setBinaryFileMIMEType(java.lang.String, int)
     */
    @Override
    public void setBinaryFileMIMEType(String mimeType, int fileAnnotationIndex)
    {
        ignoreUnneeded("setBinaryFileMIMEType", mimeType, fileAnnotationIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setBinaryFileSize(ome.xml.model.primitives.NonNegativeLong, int)
     */
    @Override
    public void setBinaryFileSize(NonNegativeLong size, int fileAnnotationIndex)
    {
        ignoreUnneeded("setBinaryFileSize", size, fileAnnotationIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDatasetImageRef(java.lang.String, int, int)
     */
    @Override
    public void setDatasetImageRef(String image, int datasetIndex,
            int imageRefIndex)
    {
        ignoreUnsupported("setDatasetImageRef", image, datasetIndex, imageRefIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseFillRule(ome.xml.model.enums.FillRule, int, int)
     */
    @Override
    public void setEllipseFillRule(FillRule fillRule, int ROIIndex,
            int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setFillRule(toRType(fillRule.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseFontFamily(ome.xml.model.enums.FontFamily, int, int)
     */
    @Override
    public void setEllipseFontFamily(FontFamily fontFamily, int ROIIndex,
            int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setFontFamily(toRType(fontFamily.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseFontStyle(ome.xml.model.enums.FontStyle, int, int)
     */
    @Override
    public void setEllipseFontStyle(FontStyle fontStyle, int ROIIndex,
            int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setFontFamily(toRType(fontStyle.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseLocked(java.lang.Boolean, int, int)
     */
    @Override
    public void setEllipseLocked(Boolean locked, int ROIIndex, int shapeIndex)
    {
        Ellipse o = getEllipse(ROIIndex, shapeIndex);
        o.setLocked(toRType(locked));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterGroupAnnotationRef(java.lang.String, int, int)
     */
    @Override
    public void setExperimenterGroupAnnotationRef(String annotation,
            int experimenterGroupIndex, int annotationRefIndex)
    {
        ignoreInsecure("setExperimenterGroupAnnotationRef", annotation,
                experimenterGroupIndex, annotationRefIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setExperimenterGroupExperimenterRef(java.lang.String, int, int)
     */
    @Override
    public void setExperimenterGroupExperimenterRef(String experimenter,
            int experimenterGroupIndex, int experimenterRefIndex)
    {
        ignoreInsecure("setExperimenterGroupExperimenterRef", experimenter,
                experimenterGroupIndex, experimenterRefIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelFillRule(ome.xml.model.enums.FillRule, int, int)
     */
    @Override
    public void setLabelFillRule(FillRule fillRule, int ROIIndex, int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setFillRule(toRType(fillRule.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelFontFamily(ome.xml.model.enums.FontFamily, int, int)
     */
    @Override
    public void setLabelFontFamily(FontFamily fontFamily, int ROIIndex,
            int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setFontFamily(toRType(fontFamily.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelFontStyle(ome.xml.model.enums.FontStyle, int, int)
     */
    @Override
    public void setLabelFontStyle(FontStyle fontStyle, int ROIIndex,
            int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setFontStyle(toRType(fontStyle.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelLocked(java.lang.Boolean, int, int)
     */
    @Override
    public void setLabelLocked(Boolean locked, int ROIIndex, int shapeIndex)
    {
        Label o = getLabel(ROIIndex, shapeIndex);
        o.setLocked(toRType(locked));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineFillRule(ome.xml.model.enums.FillRule, int, int)
     */
    @Override
    public void setLineFillRule(FillRule fillRule, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setFillRule(toRType(fillRule.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineFontFamily(ome.xml.model.enums.FontFamily, int, int)
     */
    @Override
    public void setLineFontFamily(FontFamily fontFamily, int ROIIndex,
            int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setFontFamily(toRType(fontFamily.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineFontStyle(ome.xml.model.enums.FontStyle, int, int)
     */
    @Override
    public void setLineFontStyle(FontStyle fontStyle, int ROIIndex,
            int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setFontFamily(toRType(fontStyle.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineLocked(java.lang.Boolean, int, int)
     */
    @Override
    public void setLineLocked(Boolean locked, int ROIIndex, int shapeIndex)
    {
        Line o = getLine(ROIIndex, shapeIndex);
        o.setLocked(toRType(locked));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineMarkerEnd(ome.xml.model.enums.Marker, int, int)
     */
    @Override
    public void setLineMarkerEnd(Marker markerEnd, int ROIIndex, int shapeIndex)
    {
        final Line line = getLine(ROIIndex, shapeIndex);
        line.setMarkerEnd(toRType(markerEnd.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineMarkerStart(ome.xml.model.enums.Marker, int, int)
     */
    @Override
    public void setLineMarkerStart(Marker markerStart, int ROIIndex,
            int shapeIndex)
    {
        final Line line = getLine(ROIIndex, shapeIndex);
        line.setMarkerStart(toRType(markerStart.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskFillRule(ome.xml.model.enums.FillRule, int, int)
     */
    @Override
    public void setMaskFillRule(FillRule fillRule, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setFillRule(toRType(fillRule.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskFontFamily(ome.xml.model.enums.FontFamily, int, int)
     */
    @Override
    public void setMaskFontFamily(FontFamily fontFamily, int ROIIndex,
            int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setFontFamily(toRType(fontFamily.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskFontStyle(ome.xml.model.enums.FontStyle, int, int)
     */
    @Override
    public void setMaskFontStyle(FontStyle fontStyle, int ROIIndex,
            int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setFontStyle(toRType(fontStyle.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskLocked(java.lang.Boolean, int, int)
     */
    @Override
    public void setMaskLocked(Boolean locked, int ROIIndex, int shapeIndex)
    {
        Mask o = getMask(ROIIndex, shapeIndex);
        o.setLocked(toRType(locked));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointFillRule(ome.xml.model.enums.FillRule, int, int)
     */
    @Override
    public void setPointFillRule(FillRule fillRule, int ROIIndex, int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setFillRule(toRType(fillRule.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointFontFamily(ome.xml.model.enums.FontFamily, int, int)
     */
    @Override
    public void setPointFontFamily(FontFamily fontFamily, int ROIIndex,
            int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setFontFamily(toRType(fontFamily.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointFontStyle(ome.xml.model.enums.FontStyle, int, int)
     */
    @Override
    public void setPointFontStyle(FontStyle fontStyle, int ROIIndex,
            int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setFontStyle(toRType(fontStyle.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointLocked(java.lang.Boolean, int, int)
     */
    @Override
    public void setPointLocked(Boolean locked, int ROIIndex, int shapeIndex)
    {
        Point o = getPoint(ROIIndex, shapeIndex);
        o.setLocked(toRType(locked));
    }

    //////// Polygon /////////

    private Polygon getPolygon(int ROIIndex, int shapeIndex)
    {
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        return getSourceObject(Polygon.class, indexes);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonFillColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setPolygonFillColor(Color fillColor, int ROIIndex,
            int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setFillColor(toRType(fillColor));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonFillRule(ome.xml.model.enums.FillRule, int, int)
     */
    @Override
    public void setPolygonFillRule(FillRule fillRule, int ROIIndex,
            int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setFillRule(toRType(fillRule.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonFontFamily(ome.xml.model.enums.FontFamily, int, int)
     */
    @Override
    public void setPolygonFontFamily(FontFamily fontFamily, int ROIIndex,
            int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setFontFamily(toRType(fontFamily.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonFontSize(ome.xml.model.primitives.NonNegativeInteger, int, int)
     */
    @Override
    public void setPolygonFontSize(Length fontSize, int ROIIndex,
            int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setFontSize(convertLength(fontSize));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonFontStyle(ome.xml.model.enums.FontStyle, int, int)
     */
    @Override
    public void setPolygonFontStyle(FontStyle fontStyle, int ROIIndex,
            int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setFontStyle(toRType(fontStyle.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonID(java.lang.String, int, int)
     */
    @Override
    public void setPolygonID(String id, int ROIIndex, int shapeIndex)
    {
        checkDuplicateLSID(Polygon.class, id);
        LinkedHashMap<Index, Integer> indexes =
            new LinkedHashMap<Index, Integer>();
        indexes.put(Index.ROI_INDEX, ROIIndex);
        indexes.put(Index.SHAPE_INDEX, shapeIndex);
        IObjectContainer o = getIObjectContainer(Polygon.class, indexes);
        o.LSID = id;
        addAuthoritativeContainer(Polygon.class, id, o);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonLocked(java.lang.Boolean, int, int)
     */
    @Override
    public void setPolygonLocked(Boolean locked, int ROIIndex, int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setLocked(toRType(locked));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonStrokeColor(ome.xml.model.primitives.Color, int, int)
     */
    @Override
    public void setPolygonStrokeColor(Color strokeColor, int ROIIndex,
            int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setStrokeColor(toRType(strokeColor));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonStrokeDashArray(java.lang.String, int, int)
     */
    @Override
    public void setPolygonStrokeDashArray(String strokeDashArray, int ROIIndex,
            int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setStrokeDashArray(toRType(strokeDashArray));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonStrokeWidth(java.lang.Double, int, int)
     */
    @Override
    public void setPolygonStrokeWidth(Length strokeWidth, int ROIIndex,
            int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setStrokeWidth(convertLength(strokeWidth));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonText(java.lang.String, int, int)
     */
    @Override
    public void setPolygonText(String text, int ROIIndex, int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setTextValue(toRType(text));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonTheC(ome.xml.model.primitives.NonNegativeInteger, int, int)
     */
    @Override
    public void setPolygonTheC(NonNegativeInteger theC, int ROIIndex,
            int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setTheC(toRType(theC));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonTheT(ome.xml.model.primitives.NonNegativeInteger, int, int)
     */
    @Override
    public void setPolygonTheT(NonNegativeInteger theT, int ROIIndex,
            int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setTheT(toRType(theT.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonTheZ(ome.xml.model.primitives.NonNegativeInteger, int, int)
     */
    @Override
    public void setPolygonTheZ(NonNegativeInteger theZ, int ROIIndex,
            int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setTheZ(toRType(theZ.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonTransform(ome.xml.model.AffineTransform, int, int)
     */
    @Override
    public void setPolygonTransform(AffineTransform transform, int ROIIndex,
            int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setTransform(toRType(transform));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonPoints(java.lang.String, int, int)
     */
    @Override
    public void setPolygonPoints(String points, int ROIIndex, int shapeIndex)
    {
        Polygon o = getPolygon(ROIIndex, shapeIndex);
        o.setPoints(toRType(points));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineFillRule(ome.xml.model.enums.FillRule, int, int)
     */
    @Override
    public void setPolylineFillRule(FillRule fillRule, int ROIIndex,
            int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setFillRule(toRType(fillRule.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineFontFamily(ome.xml.model.enums.FontFamily, int, int)
     */
    @Override
    public void setPolylineFontFamily(FontFamily fontFamily, int ROIIndex,
            int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setFontFamily(toRType(fontFamily.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineFontStyle(ome.xml.model.enums.FontStyle, int, int)
     */
    @Override
    public void setPolylineFontStyle(FontStyle fontStyle, int ROIIndex,
            int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setFontStyle(toRType(fontStyle.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineLocked(java.lang.Boolean, int, int)
     */
    @Override
    public void setPolylineLocked(Boolean locked, int ROIIndex, int shapeIndex)
    {
        Polyline o = getPolyline(ROIIndex, shapeIndex);
        o.setLocked(toRType(locked));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineMarkerEnd(ome.xml.model.enums.Marker, int, int)
     */
    @Override
    public void setPolylineMarkerEnd(Marker markerEnd, int ROIIndex,
            int shapeIndex)
    {
        final Polyline polyline = getPolyline(ROIIndex, shapeIndex);
        polyline.setMarkerEnd(toRType(markerEnd.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineMarkerStart(ome.xml.model.enums.Marker, int, int)
     */
    @Override
    public void setPolylineMarkerStart(Marker markerStart, int ROIIndex,
            int shapeIndex)
    {
        final Polyline polyline = getPolyline(ROIIndex, shapeIndex);
        polyline.setMarkerStart(toRType(markerStart.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setProjectDatasetRef(java.lang.String, int, int)
     */
    @Override
    public void setProjectDatasetRef(String dataset, int projectIndex,
            int datasetRefIndex)
    {
        ignoreUnsupported("setProjectDatasetRef", dataset, projectIndex,
                datasetRefIndex);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleFillRule(ome.xml.model.enums.FillRule, int, int)
     */
    @Override
    public void setRectangleFillRule(FillRule fillRule, int ROIIndex,
            int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setFillRule(toRType(fillRule.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleFontFamily(ome.xml.model.enums.FontFamily, int, int)
     */
    @Override
    public void setRectangleFontFamily(FontFamily fontFamily, int ROIIndex,
            int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setFontFamily(toRType(fontFamily.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleFontStyle(ome.xml.model.enums.FontStyle, int, int)
     */
    @Override
    public void setRectangleFontStyle(FontStyle fontStyle, int ROIIndex,
            int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setFontStyle(toRType(fontStyle.getValue()));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleLocked(java.lang.Boolean, int, int)
     */
    @Override
    public void setRectangleLocked(Boolean locked, int ROIIndex, int shapeIndex)
    {
        Rectangle o = getRectangle(ROIIndex, shapeIndex);
        o.setLocked(toRType(locked));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setWellType(java.lang.String, int, int)
     */
    @Override
    public void setWellType(String type, int plateIndex, int wellIndex)
    {
        Well o = getWell(plateIndex, wellIndex);
        o.setType(toRType(type));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRightsRightsHeld(java.lang.String)
     */
    @Override
    public void  setRightsRightsHeld(String value)
    {
        ignoreMissing("setRightsRightsHeld", value);
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRightsRightsHolder(java.lang.String)
     */
    @Override
    public void  setRightsRightsHolder(String value)
    {
        ignoreMissing("setRightsRightsHolder", value);
        // TODO: Now with FS, shouldn't we attach to this file/fileset?
    }


    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDetectorAnnotationRef(String, int, int, int)
     */
    @Override
    public void setDetectorAnnotationRef(String annotation, int instrumentIndex, int detectorIndex, int annotationRefIndex) {
        LSID key = new LSID(Detector.class, instrumentIndex, detectorIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setDichroicAnnotationRef(String, int, int, int)
     */
    @Override
    public void setDichroicAnnotationRef(String annotation, int instrumentIndex, int dichroicIndex, int annotationRefIndex) {
        LSID key = new LSID(Dichroic.class, instrumentIndex, dichroicIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setEllipseAnnotationRef(String, int, int, int)
     */
    @Override
    public void setEllipseAnnotationRef(String annotation, int ROIIndex, int shapeIndex, int annotationRefIndex) {
        LSID key = new LSID(Ellipse.class, ROIIndex, shapeIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilamentAnnotationRef(String, int, int, int)
     */
    @Override
    public void setFilamentAnnotationRef(String annotation, int instrumentIndex, int lightSourceIndex, int annotationRefIndex) {
        LSID key = new LSID(Filament.class, instrumentIndex, lightSourceIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setFilterAnnotationRef(String, int, int, int)
     */
    @Override
    public void setFilterAnnotationRef(String annotation, int instrumentIndex, int filterIndex, int annotationRefIndex) {
        LSID key = new LSID(Filter.class, instrumentIndex, filterIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setGenericExcitationSourceAnnotationRef(String, int, int, int)
     */
    @Override
    public void setGenericExcitationSourceAnnotationRef(String annotation, int instrumentIndex, int lightSourceIndex, int annotationRefIndex) {
        LSID key = new LSID(GenericExcitationSource.class, instrumentIndex, lightSourceIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setInstrumentAnnotationRef(String, int, int)
     */
    @Override
    public void setInstrumentAnnotationRef(String annotation, int instrumentIndex, int annotationRefIndex) {
        LSID key = new LSID(Instrument.class, instrumentIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLabelAnnotationRef(String, int, int, int)
     */
    @Override
    public void setLabelAnnotationRef(String annotation, int ROIIndex, int shapeIndex, int annotationRefIndex) {
        LSID key = new LSID(Label.class, ROIIndex, shapeIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLaserAnnotationRef(String, int, int, int)
     */
    @Override
    public void setLaserAnnotationRef(String annotation, int instrumentIndex, int lightSourceIndex, int annotationRefIndex) {
        LSID key = new LSID(Laser.class, instrumentIndex, lightSourceIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLightEmittingDiodeAnnotationRef(String, int, int, int)
     */
    @Override
    public void setLightEmittingDiodeAnnotationRef(String annotation, int instrumentIndex, int lightSourceIndex, int annotationRefIndex) {
        LSID key = new LSID(LightEmittingDiode.class, instrumentIndex, lightSourceIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLightPathAnnotationRef(String, int, int, int)
     */
    @Override
    public void setLightPathAnnotationRef(String annotation, int imageIndex, int channelIndex, int annotationRefIndex) {
        LSID key = new LSID(LightPath.class, imageIndex, channelIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setLineAnnotationRef(String, int, int, int)
     */
    @Override
    public void setLineAnnotationRef(String annotation, int ROIIndex, int shapeIndex, int annotationRefIndex) {
        LSID key = new LSID(Line.class, ROIIndex, shapeIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setMaskAnnotationRef(String, int, int, int)
     */
    @Override
    public void setMaskAnnotationRef(String annotation, int ROIIndex, int shapeIndex, int annotationRefIndex) {
        LSID key = new LSID(Mask.class, ROIIndex, shapeIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setObjectiveAnnotationRef(String, int, int, int)
     */
    @Override
    public void setObjectiveAnnotationRef(String annotation, int instrumentIndex, int objectiveIndex, int annotationRefIndex) {
        LSID key = new LSID(Objective.class, instrumentIndex, objectiveIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPointAnnotationRef(String, int, int, int)
     */
    @Override
    public void setPointAnnotationRef(String annotation, int ROIIndex, int shapeIndex, int annotationRefIndex) {
        LSID key = new LSID(Point.class, ROIIndex, shapeIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolygonAnnotationRef(String, int, int, int)
     */
    @Override
    public void setPolygonAnnotationRef(String annotation, int ROIIndex, int shapeIndex, int annotationRefIndex) {
        LSID key = new LSID(Polygon.class, ROIIndex, shapeIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setPolylineAnnotationRef(String, int, int, int)
     */
    @Override
    public void setPolylineAnnotationRef(String annotation, int ROIIndex, int shapeIndex, int annotationRefIndex) {
        LSID key = new LSID(Polyline.class, ROIIndex, shapeIndex);
        addReference(key, new LSID(annotation));
    }

    /* (non-Javadoc)
     * @see loci.formats.meta.MetadataStore#setRectangleAnnotationRef(String, int, int, int)
     */
    @Override
    public void setRectangleAnnotationRef(String annotation, int ROIIndex, int shapeIndex, int annotationRefIndex) {
        LSID key = new LSID(Rectangle.class, ROIIndex, shapeIndex);
        addReference(key, new LSID(annotation));
    }

    //
    // LOGGING OF UNIMPLEMENTED METHODS
    //

    private String ignoreMessage(String reason, String method, Object...args) {
        StringBuilder sb = new StringBuilder();
        sb.append(reason);
        sb.append("Ignoring ");
        sb.append(method);
        sb.append("(");
        boolean added = false;
        for (int i = 0; i < args.length; i++) {
            if (added) {
                sb.append(", ");
            } else {
                added = true;
            }
            sb.append("{}");
        }
        sb.append("(");
        return sb.toString();
    }

    /**
     * Called when a property is missing from the OMERO model (WARN).
     */
    protected void ignoreMissing(String method, Object...args) {
        String msg = ignoreMessage("Unneeded in OMERO. ", method, args);
        log.warn(msg, args);
    }

    /**
     * Called when a property is not needed in OMERO since the data can
     * be gotten elsewhere, as in directly from the file itself (DEBUG).
     */
    protected void ignoreUnneeded(String method, Object...args) {
        String msg = ignoreMessage("Unneeded in OMERO. ", method, args);
        log.debug(msg, args);
    }

    /**
     * Called when a property is not expected in a file to be imported.
     * log.warn is used to signal to the user that something is being missed
     * (WARN).
     */
    protected void ignoreUnsupported(String method, Object...args) {
        String msg = ignoreMessage("Unsupported in OMERO. ", method, args);
        log.warn(msg, args);
    }

    /**
     * Called when saving a property to OMERO would result in a SecurityViolation
     * (DEBUG). These are logged at debug since there's nothing the user need
     * worry about.
     */
    protected void ignoreInsecure(String method, Object...args) {
        String msg = ignoreMessage("Disallowed in OMERO. ", method, args);
        log.debug(msg, args);
    }

    /**
     * For all cases of an annotator being ignore (WARN).
     */
    protected void ignoreAnnotator(String method, Object...args) {
        String msg = ignoreMessage("No annotators linked. ", method, args);
        log.warn(msg, args);
    }
}