type_selector.h

#pragma once
 
#include "basememory.h"
 
namespace itasca
{
  template<bool condition, typename if_true, typename if_false>
  struct type_selector
  {
    static const bool result;
  };
 
  template<typename if_true, typename if_false>
  struct type_selector<true, if_true, if_false>
  {
    typedef if_true type;
    static const bool result = true;
  };
 
  template<typename if_true, typename if_false>
  class type_selector<false, if_true, if_false>
  {
    typedef if_false type;
    static const bool result = false;
  };
 
  template<bool condition, typename T>
  class conditional_container: public type_selector<condition, T, T *> {};
 
  template<typename T>
  class conditional_container<true, T>
  {
  public:
    conditional_container() { }
    conditional_container(const T &t) : value_(t) {}
 
    conditional_container(const conditional_container<true, T> & other) : value_(other.value_) {}
    conditional_container(const conditional_container<false, T> & other); // needs to be defined after false
 
    void operator= (const T & t) { value_ = t; }
    void operator= (T && t) { value_ = std::move(t); }
 
    void operator= (const conditional_container<true, T> & other) { value_ = other.value(); }
    void operator= (const conditional_container<false, T> & other); // see above
 
    T & value () { return value_; }
    const T & value () const { return value_; }
 
    static inline bool isValue () { return true; }
  private:
    T value_;
  };
 
  template<typename T>
  class conditional_container<false, T>
  {
  public:
    conditional_container() { value_ = NEW T(); }
    conditional_container(const T & t) : value_(nullptr) { value_ = NEW T(t); }
    conditional_container(T && t) : value_(nullptr) { value_ = NEW T(std::move(t)); }
 
    conditional_container(const conditional_container<true, T> & other) { value_ = NEW T(other.value()); }
    conditional_container(const conditional_container<false, T> & other)  { value_ = NEW T(other.value()); }
    conditional_container(conditional_container<false, T> && other)
    {
      value_ = other.value_;
      other.value_ = nullptr;
    }
 
    ~conditional_container() { if ( value_ != nullptr ) { delete value_; } }
 
    void operator= (const T & t) { *value_ = t; }
    void operator= (T && t) { *value_ = std::move(t); }
 
    void operator= (const conditional_container<true, T> & other) { *value_ = other.value(); }
    void operator= (const conditional_container<false, T> & other) { *value_ = other.value(); }
    void operator= (conditional_container<false, T> && other)
    {
      T * temp = value_;
      value_ = other.value_;
      other.value_ = temp;
    }
 
    T & value () { return *value_; }
    const T & value () const { return *value_; }
 
    static inline bool isValue () { return false; }
  private:
    T * value_;
  };
 
  template<typename T>
  conditional_container<true, T>::conditional_container (const conditional_container<false, T> & other) { value_ = other.conditional_container<false, T>::value(); }
 
  template<typename T>
  void conditional_container<true, T>::operator= (const conditional_container<false, T> & other) { value_ = other.conditional_container<false, T>::value(); }
}