Arg_impl.hpp

#ifndef Rice__Arg_Impl_hpp_
#define Rice__Arg_Impl_hpp_
 
namespace Rice {
 
 
  class Arg
  {
    public:
 
      Arg(const char* name)
        : name_(name)
        , defaultValue(0)
      {}
 
      Arg(const Arg& other)
        : name_(other.name()),
          defaultValue(other.defaultValue ? other.defaultValue->clone() : 0)
      {}
 
      virtual ~Arg()
      {
        if(defaultValue) {
          delete defaultValue;
        }
      }
 
 
      template<typename Arg_Type>
      Arg& operator=(Arg_Type val)
      {
        defaultValue = new type<Arg_Type>(val);
        return *this;
      }
 
      bool hasDefaultValue() const {
        return defaultValue != 0;
      }
 
 
      template<typename Arg_Type>
      Arg_Type getDefaultValue()
      {
        return static_cast< type<Arg_Type>* >(defaultValue)->held;
      }
 
      const char* name() const
      {
        return name_;
      }
 
    private:
 
      const char* name_;
 
      class type_base
      {
        public:
          virtual ~type_base() {}
          virtual type_base* clone() const = 0;
      };
 
      template<typename Type>
      class type : public type_base
      {
        public:
          type(Type value)
            :held(value)
          {}
 
          virtual ~type() { }
 
          virtual type_base* clone() const
          {
            return new type(held);
          }
 
          Type held;
      };
 
    public:
 
      type_base* defaultValue;
  };
 
}
 
#endif // Rice__Arg_Impl_hpp_