attribute.hpp

/*
 * attribute.h
 *
 * Generic Attributes
 *
 * Contact:
 * - Jules Françoise <jules.francoise@ircam.fr>
 *
 * This code has been authored by <a href="http://julesfrancoise.com">Jules Françoise</a>
 * in the framework of the <a href="http://skatvg.iuav.it/">SkAT-VG</a> European project,
 * with <a href="frederic-bevilacqua.net">Frederic Bevilacqua</a>, in the
 * <a href="http://ismm.ircam.fr">Sound Music Movement Interaction</a> team of the
 * <a href="http://www.ircam.fr/stms.html?&L=1">STMS Lab</a> - IRCAM - CNRS - UPMC (2011-2015).
 *
 * Copyright (C) 2015 Ircam-Centre Pompidou.
 *
 * This File is part of Wavelet.
 *
 * Wavelet 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 3 of the License, or
 * (at your option) any later version.
 *
 * Wavelet 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 Wavelet.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef __xmm_lib__attribute__
#define __xmm_lib__attribute__

#include <exception>
#include <stdexcept>
#include <limits>
#include <vector>
#include <boost/any.hpp>

namespace wavelet {
    
#pragma mark -
#pragma mark === Functions checkLimits ===
    
    template <typename T>
    void checkLimits(T const& value,
                     T const& limit_min,
                     T const& limit_max)
    {
        throw std::runtime_error("Attribute limits are not implemented for the current type.");
    }
    
    template <>
    void checkLimits<std::size_t>(std::size_t const& value,
                                  std::size_t const& limit_min,
                                  std::size_t const& limit_max);
    
    template <>
    void checkLimits<unsigned char>(unsigned char const& value,
                                    unsigned char const& limit_min,
                                    unsigned char const& limit_max);
    
    template <>
    void checkLimits<char>(char const& value,
                           char const& limit_min,
                           char const& limit_max);
    
    template <>
    void checkLimits<unsigned int>(unsigned int const& value,
                                   unsigned int const& limit_min,
                                   unsigned int const& limit_max);
    
    template <>
    void checkLimits<int>(int const& value,
                          int const& limit_min,
                          int const& limit_max);
    
    template <>
    void checkLimits<long>(long const& value,
                           long const& limit_min,
                           long const& limit_max);
    
    template <>
    void checkLimits<float>(float const& value,
                            float const& limit_min,
                            float const& limit_max);
    
    template <>
    void checkLimits<double>(double const& value,
                             double const& limit_min,
                             double const& limit_max);
    
#pragma mark -
#pragma mark === Class AttributeBase ===

    class AttributeBase {
    public:
        AttributeBase() : changed(false)
        {}
        
        bool changed;
    };
    
#pragma mark -
#pragma mark === Class AttributeHandler ===

    class AttributeHandler {
        template <typename T> friend class Attribute;
        
    public:
        virtual ~AttributeHandler() {}
        
    protected:
        virtual void onAttributeChange(AttributeBase* attr_pointer) = 0;
    };
    
#pragma mark -
#pragma mark === Class Attribute ===

    template <typename T>
    class Attribute : public AttributeBase {
    public:
        Attribute(AttributeHandler *parent=nullptr,
                  T const& value=T(),
                  T const& limit_min=default_limit_min(),
                  T const& limit_max=default_limit_max()) :
        limit_min_(limit_min),
        limit_max_(limit_max),
        parent_(parent)
        {
            set(value, true);
            changed = false;
        }
        
        Attribute(Attribute const& src) :
        value_(src.value_),
        limit_min_(src.limit_min_),
        limit_max_(src.limit_max_),
        parent_(src.parent_)
        {
            changed = false;
        }
        
        template<typename U>
        Attribute& operator=(Attribute<U> const& src)
        {
            if (this != &src) {
                value_ = src.value_;
                limit_min_ = src.limit_min_;
                limit_max_ = src.limit_max_;
                parent_ = src.parent_;
                changed = false;
            }
            return *this;
        }
        
        virtual ~Attribute()
        {}
        
        void set(T const& value, bool silently = false)
        {
            checkLimits(value, limit_min_, limit_max_);
            value_ = value;
            changed = true;
            if (!silently && parent_)
                parent_->onAttributeChange(this);
        }
        
        T get() const
        {
            return value_;
        }
        
        T getCopy() const
        {
            return T(value_);
        }
        
        void set_limit_min(T const& limit_min=default_limit_min())
        {
            limit_min_ = limit_min;
        }
        
        void set_limit_max(T const& limit_max=default_limit_max())
        {
            limit_max_ = limit_max;
        }
        
        void set_limits(T const& limit_min=default_limit_min(),
                       T const& limit_max=default_limit_max())
        {
            set_limit_min(limit_min);
            set_limit_max(limit_max);
        }
        
        void set_parent(AttributeHandler* parent)
        {
            parent_ = parent;
        }
        
        AttributeHandler* get_parent() const
        {
            return parent_;
        }
        
    protected:
        
        static T default_limit_min() { return std::numeric_limits<T>::lowest(); }
        
        static T default_limit_max() { return std::numeric_limits<T>::max(); }
        
        T limit_min_;
        
        T limit_max_;
        
        T value_;
        
        AttributeHandler *parent_;
        
    };
}

#endif