/*! \file value.h
** \brief Template Header
**
-** $Id: value.h,v 1.1.1.1 2005/01/04 01:23:15 darco Exp $
+** $Id$
**
** \legal
** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
+** Copyright (c) 2007 Chris Moore
**
** This package is free software; you can redistribute it and/or
** modify it under the terms of the GNU General Public License as
//! Checks the type of the parameter against itself. Returns true if they are of the same type.
template <class T> bool
- same_as(const T &x)const
+ same_type_as(const T &x)const
{
const Type testtype(get_type(x));
+ return same_type_as(testtype);
+ }
+
+ bool same_type_as(const Type testtype)const
+ {
if(testtype==type)return true;
if( (type==TYPE_REAL || type==TYPE_TIME) &&
(testtype==TYPE_REAL || testtype==TYPE_TIME) )
template <typename T>
const T &get(const T& x)const
{
- assert(is_valid() && same_as(x));
+ assert(is_valid() && same_type_as(x));
return *static_cast<const T*>(data);
}
float get(const float &)const { return get(Real()); }
template <typename T>
void put(T* x)const
{
- assert(same_as(*x));
+ assert(same_type_as(*x));
*x=*static_cast<const T*>(data);
}
void put(float* x)const { *x=get(Real()); }
static const Type get_type(const etl::loose_handle<Canvas>&)
{ return TYPE_CANVAS; }
static const Type get_type(const list_type&) { return TYPE_LIST; }
- template <class T> static const Type get_type(const std::vector<T> &x)
+ template <class T> static const Type get_type(const std::vector<T> &/*x*/)
{ return TYPE_LIST; }
- template <class T> static const Type get_type(const std::list<T> &x)
+ template <class T> static const Type get_type(const std::list<T> &/*x*/)
{ return TYPE_LIST; }
// ========================================================================
Value(const ValueBase &x):ValueBase(x)
{
- if(!x.same_as(T()))
+ if(!x.same_type_as(T()))
throw Exception::BadType("Value<T>(ValueBase): Type Mismatch");
}
Value<T>& operator=(const ValueBase& x)
{
- if(!x.same_as(T()))
+ if(!x.same_type_as(T()))
throw Exception::BadType("Value<T>(ValueBase): Type Mismatch");
return ValueBase::operator=(x);
}
}
Value(const ValueBase &x):ValueBase(x)
{
- if(!x.same_as(T()))
+ if(!x.same_type_as(T()))
throw Exception::BadType("Value<T>(ValueBase): Type Mismatch");
}
Value()
Value<T>& operator=(const ValueBase& x)
{
- if(!x.same_as(T()))
+ if(!x.same_type_as(T()))
throw Exception::BadType("Value<T>(ValueBase): Type Mismatch");
return ValueBase::operator=(x);
}