xmmAttribute.hpp

Go to the documentation of this file.

/*
 * xmmAttribute.hpp
 *
 * Generic Attributes
 *
 * Contact:
 * - Jules Francoise <jules.francoise@ircam.fr>
 *
 * This code has been initially authored by Jules Francoise
 * <http://julesfrancoise.com> during his PhD thesis, supervised by Frederic
 * Bevilacqua <href="http://frederic-bevilacqua.net>, in the Sound Music
 * Movement Interaction team <http://ismm.ircam.fr> of the
 * STMS Lab - IRCAM, CNRS, UPMC (2011-2015).
 *
 * Copyright (C) 2015 UPMC, Ircam-Centre Pompidou.
 *
 * This File is part of XMM.
 *
 * XMM 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.
 *
 * XMM 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 XMM.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef xmmAttribute_h
#define xmmAttribute_h

#include <functional>
#include <limits>
#include <stdexcept>
#include <string>
#include <vector>

namespace xmm {

#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<bool>(bool const& value, bool const& limit_min,
                       bool 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);

template <>
void checkLimits<std::string>(std::string const& value,
                              std::string const& limit_min,
                              std::string const& limit_max);

#pragma mark -
#pragma mark === Class AttributeBase ===

class AttributeBase {
  public:
    virtual ~AttributeBase() {}

    AttributeBase() : changed(false) {}

    bool changed;
};

#pragma mark -
#pragma mark === Class Attribute ===

template <typename T>
class Attribute : public AttributeBase {
  public:
    typedef std::function<void(AttributeBase*)> AttributeChangeCallback;

    template <typename U, typename args, class ListenerClass>
    void onAttributeChange(U* owner,
                           void (ListenerClass::*listenerMethod)(args)) {
        using namespace std::placeholders;
        if (owner)
            callback_ = std::bind(listenerMethod, owner, _1);
        else
            callback_ = nullptr;
    }

    Attribute(T const& value = T(), T const& limit_min = defaultLimitMin(),
              T const& limit_max = defaultLimitMax())
        : limit_min_(limit_min), limit_max_(limit_max) {
        set(value, true);
        changed = false;
    }

    Attribute(Attribute const& src)
        : value_(src.value_),
          limit_min_(src.limit_min_),
          limit_max_(src.limit_max_) {
        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_;
            changed = false;
        }
        return *this;
    }

    void set(T const& value, bool silently = false) {
        checkLimits(value, limit_min_, limit_max_);
        value_ = value;
        changed = true;
        if (!silently && callback_) callback_(this);
    }

    T get() const { return value_; }

    void setLimitMin(T const& limit_min = defaultLimitMin()) {
        limit_min_ = limit_min;
    }

    void setLimitMax(T const& limit_max = defaultLimitMax()) {
        limit_max_ = limit_max;
    }

    void setLimits(T const& limit_min = defaultLimitMin(),
                   T const& limit_max = defaultLimitMax()) {
        setLimitMin(limit_min);
        setLimitMax(limit_max);
    }

  protected:
    static T defaultLimitMin() { return std::numeric_limits<T>::lowest(); }

    static T defaultLimitMax() { return std::numeric_limits<T>::max(); }

    T value_;

    T limit_min_;

    T limit_max_;

    AttributeChangeCallback callback_;
};

#pragma mark -
#pragma mark === Class Attribute: vector specialization ===

template <typename T>
class Attribute<std::vector<T>> : public AttributeBase {
  public:
    typedef std::function<void(AttributeBase*)> AttributeChangeCallback;

    template <typename U, typename args, class ListenerClass>
    void onAttributeChange(U* owner,
                           void (ListenerClass::*listenerMethod)(args)) {
        using namespace std::placeholders;
        if (owner)
            callback_ = std::bind(listenerMethod, owner, _1);
        else
            callback_ = nullptr;
    }

    Attribute(std::vector<T> const& value = std::vector<T>(),
              T const& limit_min = defaultLimitMin(),
              T const& limit_max = defaultLimitMax(), unsigned int size = 0)
        : limit_min_(limit_min), limit_max_(limit_max), size_(size) {
        set(value, true);
        changed = false;
    }

    Attribute(Attribute const& src)
        : value_(src.value_),
          limit_min_(src.limit_min_),
          limit_max_(src.limit_max_),
          size_(src.size_) {
        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_;
            size_ = src.size_;
            changed = false;
        }
        return *this;
    }

    void set(std::vector<T> const& value, bool silently = false) {
        if (size_ > 0 && value.size() != size_) {
            throw std::domain_error("Attribute value has the wrong size");
        }
        for (auto& val : value) {
            checkLimits(val, limit_min_, limit_max_);
        }
        value_ = value;
        changed = true;
        if (!silently && callback_) callback_(this);
    }

    std::vector<T> get() const { return value_; }

    T at(unsigned int index) const {
        if (index < size_) {
            return value_[index];
        } else {
            throw std::out_of_range("Index out of range");
        }
    }

    void setLimitMin(T const& limit_min = defaultLimitMin()) {
        limit_min_ = limit_min;
    }

    void setLimitMax(T const& limit_max = defaultLimitMax()) {
        limit_max_ = limit_max;
    }

    void setLimits(T const& limit_min = defaultLimitMin(),
                   T const& limit_max = defaultLimitMax()) {
        setLimitMin(limit_min);
        setLimitMax(limit_max);
    }

    void resize(unsigned int size) {
        value_.resize(size, T());
        size_ = size;
    }

    unsigned int size() const { return value_.size(); }

  protected:
    static T defaultLimitMin() { return std::numeric_limits<T>::lowest(); }

    static T defaultLimitMax() { return std::numeric_limits<T>::max(); }

    std::vector<T> value_;

    T limit_min_;

    T limit_max_;

    unsigned int size_;

    AttributeChangeCallback callback_;
};

#pragma mark -
#pragma mark === Class Attribute: vector<string> specialization ===

template <>
class Attribute<std::vector<std::string>> : public AttributeBase {
  public:
    typedef std::function<void(AttributeBase*)> AttributeChangeCallback;

    template <typename U, typename args, class ListenerClass>
    void onAttributeChange(U* owner,
                           void (ListenerClass::*listenerMethod)(args)) {
        using namespace std::placeholders;
        if (owner)
            callback_ = std::bind(listenerMethod, owner, _1);
        else
            callback_ = nullptr;
    }

    Attribute(std::vector<std::string> const& value = {},
              std::string const& limit_min = "",
              std::string const& limit_max = "", unsigned int size = 0)
        : limit_min_(limit_min), limit_max_(limit_max), size_(size) {
        set(value, true);
        changed = false;
    }

    Attribute(Attribute const& src)
        : value_(src.value_),
          limit_min_(src.limit_min_),
          limit_max_(src.limit_max_),
          size_(src.size_) {
        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_;
            size_ = src.size_;
            changed = false;
        }
        return *this;
    }

    void set(std::vector<std::string> const& value, bool silently = false) {
        if (size_ > 0 && value.size() != size_) {
            throw std::domain_error("Attribute value has the wrong size");
        }
        for (auto& val : value) {
            checkLimits(val, limit_min_, limit_max_);
        }
        value_ = value;
        changed = true;
        if (!silently && callback_) callback_(this);
    }

    std::vector<std::string> get() const { return value_; }

    std::string at(unsigned int index) const {
        if (index < size_) {
            return value_[index];
        } else {
            throw std::out_of_range("Index out of range");
        }
    }

    void setLimitMin(std::string const& limit_min = defaultLimitMin()) {
        limit_min_ = limit_min;
    }

    void setLimitMax(std::string const& limit_max = defaultLimitMax()) {
        limit_max_ = limit_max;
    }

    void setLimits(std::string const& limit_min = defaultLimitMin(),
                   std::string const& limit_max = defaultLimitMax()) {
        setLimitMin(limit_min);
        setLimitMax(limit_max);
    }

    void resize(unsigned int size) {
        value_.resize(size, "");
        size_ = size;
    }

    unsigned int size() const {
        return static_cast<unsigned int>(value_.size());
    }

  protected:
    static std::string defaultLimitMin() { return ""; }

    static std::string defaultLimitMax() { return ""; }

    std::vector<std::string> value_;

    std::string limit_min_;

    std::string limit_max_;

    unsigned int size_;

    AttributeChangeCallback callback_;
};
}

#endif