type_selector.h

#pragma once
 
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(); }
}