/*
 * #%L
 * OME-XML C++ library for working with OME-XML metadata structures.
 * %%
 * Copyright © 2006 - 2016 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.
 *
 *─────────────────────────────────────────────────────────────────────────────
 */

#ifndef OME_XML_MODEL_ENUMS_IMMERSION_H
#define OME_XML_MODEL_ENUMS_IMMERSION_H

#include <ostream>
#include <map>
#include <string>

#include <ome/common/log.h>

#include <ome/xml/model/enums/EnumerationException.h>

// All values in the Immersion enumeration.
#define OME_XML_MODEL_ENUMS_IMMERSION_VALUES (OIL)(WATER)(WATERDIPPING)(AIR)(MULTI)(GLYCEROL)(OTHER)

namespace ome
{
  namespace xml
  {
    namespace model
    {
      namespace enums
      {

        /**
         * Immersion enumeration.
         */
        class Immersion
        {
        public:
          /// Enumeration values.
          enum enum_value
            {
              /// Oil
              OIL,
              /// Water
              WATER,
              /// WaterDipping
              WATERDIPPING,
              /// Air
              AIR,
              /// Multi
              MULTI,
              /// Glycerol
              GLYCEROL,
              /// Other
              OTHER
            };

          /**
           * Construct a Immersion enumeration by an enumeration value.
           *
           * @param value the value of the enumeration.
           */
          Immersion (enum_value value);

          /**
           * Construct a Immersion enumeration by an enumeration name.
           *
           * Exact matching of the name will require the name to match
           * one of the valid enumeration names.  Inexact matching will
           * strip leading and trailing whitespace and perform a
           * case-insensitive match.  Exact matching is recommended for
           * use in program code which does not process user input;
           * inexact matching is recommended when processing
           * potentially malformed user input.
           *
           * @param name the name of the enumeration.
           * @param strict true to require an exact name, false to allow an inexact match.
           */
          Immersion (const std::string& name, bool strict = true);

          /**
           * Copy constructor.
           *
           * @param original the instance to copy.
           */
          Immersion (const Immersion& original);

          /**
           * Assignment operator.
           *
           */
          inline Immersion&
          operator=  (const Immersion& rhs)
          {
            this->value = rhs.value;
            this->name = rhs.name;
            return *this;
          }

          /**
           * Cast the enumeration to its value.
           *
           * @returns the enumeration value.
           */
          inline
          operator enum_value () const
          {
            return this->value;
          }

          /**
           * Cast the enumeration to its name.
           *
           * @returns the enumeration value.
           */
          inline
          operator const std::string& () const
          {
            return *this->name;
          }

          /// String map type.
          typedef std::map<std::string, Immersion::enum_value> string_map_type;
          /// Value map type.
          typedef std::map<Immersion::enum_value, std::string> value_map_type;

          /**
           * Get a map of valid string names and enum values.
           *
           * @returns a map of string names to enum values.
           */
          static const string_map_type&
          strings();

          /**
           * Get a map of valid enum values and string names.
           *
           * @returns a map of enum values to string names.
           */
          static const value_map_type&
          values();

        private:
          /**
           * Get a map of valid lowercased string names and enum values.
           *
           * @returns a map of lowercased string names to enum values.
           */
          static const string_map_type&
          lowercase_strings();

          /// Enumeration value.
          enum_value         value;
          /// Enumeration name.
          const std::string *name;
        };

        /**
         * Compare two Immersion objects for equality.
         *
         * @param lhs a Immersion object.
         * @param rhs a Immersion object.
         * @returns true if the enum values are the same, otherwise false.
         */
        inline bool
        operator== (const Immersion& lhs,
                    const Immersion& rhs)
        {
          return static_cast<Immersion::enum_value>(lhs) == static_cast<Immersion::enum_value>(rhs);
        }

        /**
         * Compare Immersion object and enum value for equality.
         *
         * @param lhs a Immersion object.
         * @param rhs a Immersion enum value.
         * @returns true if the enum values are the same, otherwise false.
         */
        inline bool
        operator== (const Immersion& lhs,
                    const Immersion::enum_value& rhs)
        {
          return static_cast<Immersion::enum_value>(lhs) == rhs;
        }

        /**
         * Compare enum value and Immersion for equality.
         *
         * @param lhs a Immersion enum value.
         * @param rhs a Immersion object.
         * @returns true if the enum values are the same, otherwise false.
         */
        inline bool
        operator== (const Immersion::enum_value& lhs,
                    const Immersion& rhs)
        {
          return lhs == static_cast<Immersion::enum_value>(rhs);
        }

        /**
         * Compare Immersion object and enum string value for equality.
         *
         * @param lhs a Immersion object.
         * @param rhs a Immersion enum string value.
         * @returns true if the enum values are the same, otherwise false.
         */
        inline bool
        operator== (const Immersion& lhs,
                    const std::string& rhs)
        {
          return static_cast<const std::string&>(lhs) == rhs;
        }

        /**
         * Compare enum string value and Immersion object for equality.
         *
         * @param lhs a Immersion enum string value.
         * @param rhs a Immersion object.
         * @returns true if the enum values are the same, otherwise false.
         */
        inline bool
        operator== (const std::string& lhs,
                    const Immersion& rhs)
        {
          return lhs == static_cast<const std::string&>(rhs);
        }

        /**
         * Compare two Immersion objects for non-equality.
         *
         * @param lhs a Immersion object.
         * @param rhs a Immersion object.
         * @returns true if the enum values are not the same, otherwise false.
         */
        inline bool
        operator!= (const Immersion& lhs,
                    const Immersion& rhs)
        {
          return static_cast<Immersion::enum_value>(lhs) != static_cast<Immersion::enum_value>(rhs);
        }

        /**
         * Compare Immersion object and enum value for non-equality.
         *
         * @param lhs a Immersion object.
         * @param rhs a Immersion enum value.
         * @returns true if the enum values are not the same, otherwise false.
         */
        inline bool
        operator!= (const Immersion& lhs,
                    const Immersion::enum_value& rhs)
        {
          return static_cast<Immersion::enum_value>(lhs) != rhs;
        }

        /**
         * Compare enum value and Immersion object for non-equality.
         *
         * @param lhs a Immersion enum value.
         * @param rhs a Immersion object.
         * @returns true if the enum values are not the same, otherwise false.
         */
        inline bool
        operator!= (const Immersion::enum_value& lhs,
                    const Immersion& rhs)
        {
          return lhs != static_cast<Immersion::enum_value>(rhs);
        }

        /**
         * Compare Immersion object and enum string value for non-equality.
         *
         * @param lhs a Immersion object.
         * @param rhs a Immersion enum string value.
         * @returns true if the enum values are not the same, otherwise false.
         */
        inline bool
        operator!= (const Immersion& lhs,
                    const std::string& rhs)
        {
          return static_cast<const std::string&>(lhs) != rhs;
        }

        /**
         * Compare enum string value and Immersion object for non-equality.
         *
         * @param lhs a Immersion enum string value.
         * @param rhs a Immersion object.
         * @returns true if the enum values are not the same, otherwise false.
         */
        inline bool
        operator!= (const std::string& lhs,
                    const Immersion& rhs)
        {
          return lhs != static_cast<const std::string&>(rhs);
        }

        /**
         * Output Immersion to output stream.
         *
         * @param os the output stream.
         * @param enumeration the Immersion to output.
         * @returns the output stream.
         */
        template<class charT, class traits>
        inline std::basic_ostream<charT,traits>&
        operator<< (std::basic_ostream<charT,traits>& os,
                    const Immersion& enumeration)
        {
          return os << static_cast<const std::string&>(enumeration);
        }

        /**
         * Set Immersion from input stream.
         *
         * @param is the input stream.
         * @param enumeration the Immersion to input.
         * @returns the input stream.
         */
        template<class charT, class traits>
        inline std::basic_istream<charT,traits>&
        operator>> (std::basic_istream<charT,traits>& is,
                    Immersion& enumeration)
        {
          std::string value;
          is >> value;
          if (is)
            {
              try
                {
                  enumeration = Immersion(value, false);
                }
              catch (const EnumerationException&)
                {
                  is.setstate(std::ios::failbit);
                }
            }

          return is;
        }

      }
    }
  }
}

#endif // OME_XML_MODEL_ENUMS_IMMERSION_H

/*
 * Local Variables:
 * mode:C++
 * End:
 */
