prim_element.h

Go to the documentation of this file.

/* Tide
 *
 * Header file for the primitive data element object.
 *
 * Copyright 2011 Geoffrey Biggs geoffrey.biggs@aist.go.jp
 *     RT-Synthesis Research Group
 *     Intelligent Systems Research Institute,
 *     National Institute of Advanced Industrial Science and Technology (AIST),
 *     Japan
 *     All rights reserved.
 *
 * This file is part of Tide.
 *
 * Tide is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * Tide 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with Tide. If not, see <http://www.gnu.org/licenses/>.
 */

#if !defined(TIDE_PRIM_ELEMENT_H_)
#define TIDE_PRIM_ELEMENT_H_


#include <boost/operators.hpp>
#include <stdint.h>
#include <string>
#include <tide/element.h>
#include <tide/exceptions.h>
#include <tide/win_dll.h>


namespace tide
{
    template<typename T>
    class TIDE_EXPORT PrimitiveElement : public Element,
        public boost::equality_comparable<PrimitiveElement<T> >
    {
        public:
            PrimitiveElement(uint32_t id, T value)
                : Element(id),
                value_(value), has_default_(false)
            {
            }

            PrimitiveElement(uint32_t id, T value, T default_value)
                : Element(id),
                value_(value), default_(default_value), has_default_(true)
            {
            }

            virtual PrimitiveElement& operator=(T const& rhs)
            {
                value_ = rhs;
                return *this;
            }

            virtual uint32_t id() const { return Element::id(); }

            virtual void id(uint32_t id)
            {
                if (id == 0 ||
                        id == 0xFF ||
                        id == 0xFFFF ||
                        id == 0xFFFFFF ||
                        id == 0xFFFFFFFF)
                {
                    throw InvalidElementID() << err_id(id);
                }
                id_ = id;
            }

            virtual T value() const { return value_; }
            virtual void value(T value) { value_ = value; }
            operator T() const { return value_; }

            virtual bool has_default() const { return has_default_; }
            virtual T get_default() const { return default_; }
            virtual void set_default(T default_value)
            {
                default_ = default_value;
                has_default_ = true;
            }
            virtual T remove_default()
            {
                has_default_ = false;
                return default_;
            }
            virtual bool is_default() const
                { return value_ == default_ && has_default_; }

            friend bool operator==(PrimitiveElement<T> const& lhs,
                    PrimitiveElement<T> const& rhs)
            {
                return lhs.value_ == rhs.value_;
            }

        protected:
            T value_;
            T default_;
            bool has_default_;

            virtual bool equal_(PrimitiveElement<T> const& rhs)
            {
                return value_ == rhs.value_;
            }
    }; // class Element
}; // namespace tide


#endif // TIDE_PRIM_ELEMENT_H_