Ticket #3741: ImagingEnvironment.java

/*
 * #%L
 * OME-XML Java library for working with OME-XML metadata structures.
 * %%
 * Copyright (C) 2006 - 2014 Open Microscopy Environment:
 *   - Massachusetts Institute of Technology
 *   - National Institutes of Health
 *   - University of Dundee
 *   - Board of Regents of the University of Wisconsin-Madison
 *   - Glencoe Software, Inc.
 * %%
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are
 * those of the authors and should not be interpreted as representing official
 * policies, either expressed or implied, of any organization.
 * #L%
 */

/*-----------------------------------------------------------------------------
 *
 * THIS IS AUTOMATICALLY GENERATED CODE.  DO NOT MODIFY.
 *
 *-----------------------------------------------------------------------------
 */

package ome.xml.model;

import java.util.ArrayList;
import java.util.List;

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

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import ome.xml.model.enums.*;
import ome.xml.model.primitives.*;

import org.unitsofmeasurement.quantity.Pressure;
import org.unitsofmeasurement.quantity.Temperature;
import org.unitsofmeasurement.unit.Unit;

public class ImagingEnvironment extends AbstractOMEModelObject
{
        // Base:  -- Name: ImagingEnvironment -- Type: ImagingEnvironment -- modelBaseType: AbstractOMEModelObject -- langBaseType: Object

        // -- Constants --

        public static final String NAMESPACE = "http://www.openmicroscopy.org/Schemas/OME/2013-10-dev-2";

        /** Logger for this class. */
        private static final Logger LOGGER =
                LoggerFactory.getLogger(ImagingEnvironment.class);

        // -- Instance variables --

        // CO2Percent property
        private PercentFraction co2Percent;

        // Temperature property
        private Unit<Temperature> temperature;

        // AirPressure property
        private Unit<Pressure> airPressure;

        // Humidity property
        private PercentFraction humidity;

        // Map property
        private Map map;

        // -- Constructors --

        /** Default constructor. */
        public ImagingEnvironment()
        {
        }

        /**
         * Constructs ImagingEnvironment recursively from an XML DOM tree.
         * @param element Root of the XML DOM tree to construct a model object
         * graph from.
         * @param model Handler for the OME model which keeps track of instances
         * and references seen during object population.
         * @throws EnumerationException If there is an error instantiating an
         * enumeration during model object creation.
         */
        public ImagingEnvironment(Element element, OMEModel model)
            throws EnumerationException
        {
                update(element, model);
        }

        /** Copy constructor. */
        public ImagingEnvironment(ImagingEnvironment orig)
        {
                co2Percent = orig.co2Percent;
                temperature = orig.temperature;
                airPressure = orig.airPressure;
                humidity = orig.humidity;
                map = orig.map;
        }

        // -- Custom content from ImagingEnvironment specific template --


        // -- OMEModelObject API methods --

        /**
         * Updates ImagingEnvironment recursively from an XML DOM tree. <b>NOTE:</b> No
         * properties are removed, only added or updated.
         * @param element Root of the XML DOM tree to construct a model object
         * graph from.
         * @param model Handler for the OME model which keeps track of instances
         * and references seen during object population.
         * @throws EnumerationException If there is an error instantiating an
         * enumeration during model object creation.
         */
        public void update(Element element, OMEModel model)
            throws EnumerationException
        {
                super.update(element, model);
                String tagName = element.getTagName();
                if (!"ImagingEnvironment".equals(tagName))
                {
                        LOGGER.debug("Expecting node name of ImagingEnvironment got {}", tagName);
                }
                if (element.hasAttribute("CO2Percent"))
                {
                        // Attribute property CO2Percent
                        setCO2Percent(PercentFraction.valueOf(
                                        element.getAttribute("CO2Percent")));
                }
                if (element.hasAttribute("Temperature"))
                {
                        // Attribute property Temperature
                        TemperatureUnit u = TemperatureUnit.fromString(
                                        element.getAttribute("TemperatureUnit"));
                        Unit<Temperature> base = u.unit();
                        Double value = Double.valueOf(
                                        element.getAttribute("Temperature"));
                        setTemperature(base.multiply(value.doubleValue()));
                }
                if (element.hasAttribute("AirPressure"))
                {
                        // Attribute property AirPressure
                        AirPressureUnit u = PressureUnit.fromString(
                                        element.getAttribute("AirPressureUnit"));
                        Unit<Pressure> base = u.unit();
                        Double value = Double.valueOf(
                                        element.getAttribute("AirPressure"));
                        setAirPressure(base.multiply(value.doubleValue()));
                }
                if (element.hasAttribute("Humidity"))
                {
                        // Attribute property Humidity
                        setHumidity(PercentFraction.valueOf(
                                        element.getAttribute("Humidity")));
                }
                List<Element> Map_nodeList =
                                getChildrenByTagName(element, "Map");
                if (Map_nodeList.size() > 1)
                {
                        // TODO: Should be its own Exception
                        throw new RuntimeException(String.format(
                                        "Map node list size %d != 1",
                                        Map_nodeList.size()));
                }
                else if (Map_nodeList.size() != 0)
                {
                        // Element property Map which is complex (has
                        // sub-elements)
                        setMap(new Map(
                                        (Element) Map_nodeList.get(0), model));
                }
        }

        // -- ImagingEnvironment API methods --

        public boolean link(Reference reference, OMEModelObject o)
        {
                boolean wasHandledBySuperClass = super.link(reference, o);
                if (wasHandledBySuperClass)
                {
                        return true;
                }
                LOGGER.debug("Unable to handle reference of type: {}", reference.getClass());
                return false;
        }


        // Property
        public PercentFraction getCO2Percent()
        {
                return co2Percent;
        }

        public void setCO2Percent(PercentFraction co2Percent)
        {
                this.co2Percent = co2Percent;
        }

        // Property
        public Unit<Temperature> getTemperature()
        {
                return temperature;
        }

        public void setTemperature(Unit<Temperature> temperature)
        {
                this.temperature = temperature;
        }

        // Property
        public Unit<Pressure> getAirPressure()
        {
                return airPressure;
        }

        public void setAirPressure(Unit<Pressure> airPressure)
        {
                this.airPressure = airPressure;
        }

        // Property
        public PercentFraction getHumidity()
        {
                return humidity;
        }

        public void setHumidity(PercentFraction humidity)
        {
                this.humidity = humidity;
        }

        // Property
        public Map getMap()
        {
                return map;
        }

        public void setMap(Map map)
        {
                this.map = map;
        }

        public Element asXMLElement(Document document)
        {
                return asXMLElement(document, null);
        }

        protected Element asXMLElement(Document document, Element ImagingEnvironment_element)
        {
                // Creating XML block for ImagingEnvironment

                if (ImagingEnvironment_element == null)
                {
                        ImagingEnvironment_element =
                                        document.createElementNS(NAMESPACE, "ImagingEnvironment");
                }


                if (co2Percent != null)
                {
                        // Attribute property CO2Percent
                        ImagingEnvironment_element.setAttribute("CO2Percent", co2Percent.toString());
                }
                if (temperature != null)
                {
                        // Attribute property Temperature
                    ImagingEnvironment_element.setAttribute("Temperature", temperature.value().toString());
                    ImagingEnvironment_element.setAttribute("TemperatureUnit", TemperatureUnit.fromUnit(temperature.unit()).toString());
                }
                if (airPressure != null)
                {
                        // Attribute property AirPressure
                    ImagingEnvironment_element.setAttribute("AirPressure", airPressure.value().toString());
                    ImagingEnvironment_element.setAttribute("AirPressureUnit", AirPressureUnit.fromUnit(airPressure.unit()).toString());
                }
                if (humidity != null)
                {
                        // Attribute property Humidity
                        ImagingEnvironment_element.setAttribute("Humidity", humidity.toString());
                }
                if (map != null)
                {
                        // Element property Map which is complex (has
                        // sub-elements)
                        ImagingEnvironment_element.appendChild(map.asXMLElement(document));
                }

                return super.asXMLElement(document, ImagingEnvironment_element);
        }
}