MANum.hpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ 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 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#pragma once

#include "MASignal.hpp"

#include <MCDefs.hpp>

#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>

#include <limits>
#include <vector>

#include <limits.h>
#include <stdint.h>

template <typename T>
struct MANum
{
  typedef MASignal<MANum<T>&> ValueChangeSignalType;
  typedef MASignal<MANum<T>&, int> NewHighResValuesSignalType;

  MANum(T value = (T)0, T min_value = (T)0, T max_value = (T)1) :
    Value(value), MinValue(min_value), MaxValue(max_value), Changed(false),
    ValueChange((T)0), Magnitude(1.0), BlockNotifications(false)
  {
    // We need to initialize the member variables in this way to have a proper
    // minimal and maximal values if needed.
    SetMinMax(min_value, max_value);
    MANum<T>::Value = MCBound(MANum<T>::MinValue, value, MANum<T>::MaxValue);
    MANum<T>::Changed = false;
  }

  virtual ~MANum()
  {
  }

  boost::shared_ptr<ValueChangeSignalType>& GetValueChangeSignal()
  {
    // Note: Must be created on demand otherwise the shared pointers have
    // a high performance impact on this core class
    if (ValueChangeSignal.get() == nullptr)
    {
      ValueChangeSignal = boost::make_shared<ValueChangeSignalType>();
    }
    return ValueChangeSignal;
  }

  boost::shared_ptr<NewHighResValuesSignalType>& GetNewHighResValuesSignal()
  {
    // Note: Must be created on demand otherwise the shared pointers have
    // a high performance impact on this core class
    if (NewHighResValuesSignal.get() == nullptr)
    {
      NewHighResValuesSignal = boost::make_shared<NewHighResValuesSignalType>();
    }
    return NewHighResValuesSignal;
  }

  void SetBlockedNotifications(bool new_state)
  {
    BlockNotifications = new_state;
  }

  bool IsBlockedNotifications() const
  {
    return BlockNotifications;
  }

  void SetHighResolutionValues(const std::vector<T>& new_highres_values)
  {
    int OldHighResValueNumber = HighResolutionValues.size();

    HighResolutionValues.clear();
    HighResolutionValues = new_highres_values;
    if (!BlockNotifications && NewHighResValuesSignal.get() != nullptr)
      (*NewHighResValuesSignal).Emit(*this, OldHighResValueNumber);
  }

  template <typename U>
  void SetHighResolutionValues(const std::vector<U>& new_highres_values)
  {
    int OldHighResValueNumber = HighResolutionValues.size();

    HighResolutionValues.clear();
    for (typename std::vector<U>::const_iterator Iter = new_highres_values.begin();
         Iter != new_highres_values.end(); ++Iter)
    {
      HighResolutionValues.push_back((T)(*Iter));
    }
    if (!BlockNotifications && NewHighResValuesSignal.get() != nullptr)
      (*NewHighResValuesSignal).Emit(*this, OldHighResValueNumber);
  }

  const std::vector<T>& GetHighResolutionValues() const
  {
    return HighResolutionValues;
  }


  int IsUchar() const
  {
    return MinValue >= (T)0 && MaxValue <= (T)255;
  }

  bool IsInt16() const
  {
    return MinValue >= (T)std::numeric_limits<int16_t>::min() &&
           MaxValue <= (T)std::numeric_limits<int16_t>::max();
  }

  bool IsInt32() const
  {
    return MinValue >= (T)std::numeric_limits<int32_t>::min() &&
           MaxValue <= (T)std::numeric_limits<int32_t>::max();
  }

  virtual void SetMinMax(T min_value, T max_value)
  {
    MinValue = min_value;
    MaxValue = max_value;
    // Normalize the current hold value to the new value range and
    // emit the changed event if needed.
    *this = Value;
  }

  T GetMin() const
  {
    return MinValue;
  }

  T GetMax() const
  {
    return MaxValue;
  }

  bool IsChanged() const
  {
    return Changed;
  }

  T GetValueChange() const
  {
    return ValueChange;
  }

  void SetMagnitude(float value)
  {
    Magnitude = value;
  }

  float GetMagnitude() const
  {
    return Magnitude;
  }

  float GetNormalizedValue() const
  {
    if (Magnitude == 0.0 || Magnitude == 1.0)
      return Value;

    return (float)Value / Magnitude;
  }

  MANum<T>& operator=(const MANum<T>& other)
  {
    if (this == &other)
      return *this;

    MinValue = other.MinValue;
    MaxValue = other.MaxValue;
    if (Value != other.Value)
    {
      Changed = true;
      ValueChange = other.Value-Value;
    } else {
      Changed = false;
      ValueChange = (T)0;
    }
    Value = other.Value;
    Magnitude = other.Magnitude;
    if (Changed && !BlockNotifications && ValueChangeSignal.get() != nullptr)
      (*ValueChangeSignal).Emit(*this);

    HighResolutionValues = other.HighResolutionValues;
    // Note: At this point BlockNotifications state can be copied.
    BlockNotifications = other.BlockNotifications;
    return *this;
  }

  template <typename U>
  MANum<T>& operator=(const U& new_value)
  {
    T OldValue = Value;

    Value = MCBound(MinValue, (T)new_value, MaxValue);
    if (Value != OldValue)
    {
      Changed = true;
      ValueChange = Value-OldValue;
      if (!BlockNotifications && ValueChangeSignal.get() != nullptr)
        (*ValueChangeSignal).Emit(*this);
    } else {
      Changed = false;
      ValueChange = (T)0;
    }
    return *this;
  }

  bool operator==(const T value) const
  {
    return Value == value;
  }

  bool operator!=(const T value) const
  {
    return Value != value;
  }

  const MANum<T> operator-(const T value) const
  {
    return MANum<T>(*this) -= value;
  }

  MANum<T>& operator--()
  {
    return operator-=((T)1);
  }

  void operator--(int)
  {
    --(*this);
  }

  MANum<T>& operator-=(const T value)
  {
    operator=(MCBound(MinValue, (T)(Value-value), MaxValue));
    return *this;
  }

  const MANum<T> operator+(const T value) const
  {
    return MANum<T>(*this) += value;
  }

  MANum<T>& operator++()
  {
    return operator+=((T)1);
  }

  void operator++(int)
  {
    ++(*this);
  }

  MANum<T>& operator+=(const T value)
  {
    operator=(MCBound(MinValue, (T)(Value+value), MaxValue));
    return *this;
  }

  const MANum<T> operator*(const T value) const
  {
    return MANum<T>(*this) *= value;
  }

  MANum<T>& operator*=(const T value)
  {
    operator=(MCBound(MinValue, (T)(Value*value), MaxValue));
    return *this;
  }

  const MANum<T> operator/(const T value) const
  {
    return MANum<T>(*this) /= value;
  }

  MANum<T>& operator/=(const T value)
  {
    operator=(MCBound(MinValue, (T)(Value / value), MaxValue));
    return *this;
  }


  operator T() const
  {
    return Value;
  };

protected:
  T Value;
  T MinValue;
  T MaxValue;
  bool Changed;
  T ValueChange;
  float Magnitude;
  boost::shared_ptr<ValueChangeSignalType> ValueChangeSignal;
  boost::shared_ptr<NewHighResValuesSignalType> NewHighResValuesSignal;
  bool BlockNotifications;
  std::vector<T> HighResolutionValues;
};

template <typename T>
struct MAIntervalNum : public MANum<T>
{
public:

  MAIntervalNum(T value = (T)0, T min_value = (T)-100, T max_value = (T)100) :
    MANum<T>(value, min_value, max_value)
  {
  }

  explicit MAIntervalNum(MANum<T>& other)
  {
    *static_cast<MANum<T>*>(this) = other;
  }

  virtual void SetMinMax(T min_value, T max_value) override
  {
    MANum<T>::SetMinMax(min_value > (T)0 ? (T)0 : min_value,
                        max_value > (T)0 ? max_value : (T)0);
  }

  T GetScaledValue() const
  {
    if (MANum<T>::Value == (T)0)
      return (T)0;

    return MANum<T>::Value > 0 ?
           MANum<T>::Value*100 / MANum<T>::MaxValue :
           -MANum<T>::Value*100 / MANum<T>::MinValue;
  }

  MAIntervalNum<T>& operator=(T new_value)
  {
    MANum<T>::operator=(new_value);
    return *this;
  }

  bool operator==(const T value) const
  {
    return MANum<T>::operator==(value);
  }

  bool operator!=(const T value) const
  {
    return MANum<T>::operator!=(value);
  }

  const MAIntervalNum<T> operator-(const T value) const
  {
    MAIntervalNum<T> TempVar;

    *static_cast<MANum<T>*>(&TempVar) =  MANum<T>::operator-(value);
    return TempVar;
  }

  MAIntervalNum<T>& operator-=(const T value)
  {
    MANum<T>::operator-=(value);
    return *this;
  }

  const MAIntervalNum<T> operator+(const T value) const
  {
    MAIntervalNum<T> TempVar;

    *static_cast<MANum<T>*>(&TempVar) =  MANum<T>::operator+(value);
    return TempVar;
  }

  MAIntervalNum<T>& operator+=(const T value)
  {
    MANum<T>::operator+=(value);
    return *this;
  }

  const MAIntervalNum<T> operator*(const T value) const
  {
    MAIntervalNum<T> TempVar;

    *static_cast<MANum<T>*>(&TempVar) =  MANum<T>::operator*(value);
    return TempVar;
  }

  MAIntervalNum<T>& operator*=(const T value)
  {
    MANum<T>::operator*=(value);
    return *this;
  }

  const MAIntervalNum<T> operator/(const T value) const
  {
    MAIntervalNum<T> TempVar;

    *static_cast<MANum<T>*>(&TempVar) =  MANum<T>::operator/(value);
    return TempVar;
  }

  MAIntervalNum<T>& operator/=(const T value)
  {
    MANum<T>::operator/=(value);
    return *this;
  }
};