X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=synfig-core%2Ftrunk%2Fsrc%2Fsynfig%2Fvalue.h;h=2bf39bbe9b8dcdd6c741ae3716497180f6cc2f2b;hb=c3e45b84cbe115d9a8d216f1ce99d06fdd49ccca;hp=c5cd89b2f17b4dbd4b21525ee07ae7c32ce3d711;hpb=e8a065f2385c219c511b57dac52786120bfa097d;p=synfig.git

diff --git a/synfig-core/trunk/src/synfig/value.h b/synfig-core/trunk/src/synfig/value.h
index c5cd89b..2bf39bb 100644
--- a/synfig-core/trunk/src/synfig/value.h
+++ b/synfig-core/trunk/src/synfig/value.h
@@ -2,10 +2,11 @@
 /*!	\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
@@ -41,6 +42,10 @@
 #include "blinepoint.h"
 #include "exception.h"
 
+#ifdef USE_HALF_TYPE
+#include <OpenEXR/half.h>
+#endif
+
 #ifndef SYNFIG_NO_ANGLE
 #include "angle.h"
 #endif
@@ -62,7 +67,7 @@ class Segment;
 class Gradient;
 class BLinePoint;
 class Color;
-	
+
 /*!	\class ValueBase
 **	\todo writeme
 */
@@ -78,25 +83,25 @@ public:
 	enum Type
 	{
 		TYPE_NIL=0,			//!< Represents an empty value
-		
+
 		TYPE_BOOL,
 		TYPE_INTEGER,
 		TYPE_ANGLE,			//!< Angle
 
 		// All types after this point are larger than 32 bits
-		
+
 		TYPE_TIME,			//!< Time
 		TYPE_REAL,			//!< Real
 
 		// All types after this point are larger than 64 bits
-		
+
 		TYPE_VECTOR,		//!< Vector
 		TYPE_COLOR,			//!< Color
 		TYPE_SEGMENT,		//!< Segment
 		TYPE_BLINEPOINT,	//!< BLinePoint
 
 		// All types after this point require construction/destruction
-		
+
 		TYPE_LIST,			//!< List
 		TYPE_CANVAS,		//!< Canvas
 		TYPE_STRING,		//!< String
@@ -104,7 +109,7 @@ public:
 
 		TYPE_END			//!< Not a valid type, used for sanity checks
 	};
-	
+
 private:
 
 	typedef std::vector<ValueBase> list_type;
@@ -114,16 +119,16 @@ private:
 	*/
 
 protected:
-	
+
 	Type type;
 	void *data;
 	etl::reference_counter ref_count;
-	bool loop_;	
+	bool loop_;
 
 	/*
  --	** -- C O N S T R U C T O R S -----------------------------------
 	*/
-	
+
 public:
 
 	//! \writeme
@@ -140,7 +145,7 @@ public:
 
 	//! \writeme
 	~ValueBase();
-		
+
 	/*
  --	** -- O P E R A T O R S ---------------------------------------------------
 	*/
@@ -152,7 +157,7 @@ public:
 		{ set(x); return *this; }
 
 	//! \writeme
-	ValueBase& operator=(const ValueBase& x);	
+	ValueBase& operator=(const ValueBase& x);
 
 	//! \writeme
 	bool operator==(const ValueBase& rhs)const;
@@ -177,14 +182,14 @@ public:
 	bool get_loop()const { return loop_; }
 
 	//! \writeme
-	void set_loop(bool x) { loop_=x; }	
-		
+	void set_loop(bool x) { loop_=x; }
+
 	//! \writeme
 	bool empty()const;
 
 	//! \writeme
 	Type get_contained_type()const;
-	
+
 	//! Returns true if the contained value is defined and valid.
 	bool is_valid()const;
 
@@ -193,26 +198,31 @@ public:
 
 	//! Returns the type of the contained value
 	const Type & get_type()const { return type; }
-	
+
 	//! 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) )
 			return true;
 		return false;
 	}
-	
-	
-	// === GET MEMBERS ========================================================	
+
+
+	// === GET MEMBERS ========================================================
 	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()); }
@@ -223,37 +233,37 @@ public:
 	const char* get(const char*)const;
 	const list_type& get_list()const { return get(list_type()); }
 	// ========================================================================
-	
-	
-	
-	// === PUT MEMBERS ========================================================	
+
+
+
+	// === PUT MEMBERS ========================================================
 	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()); }
 	void put(char** x)const;
 	// ========================================================================
 
-	
-	
-	// === SET MEMBERS ========================================================	
+
+
+	// === SET MEMBERS ========================================================
 	template <typename T> void set(const T& x) { _set(x); }
 	void set(const float &x) { _set(Real(x)); }
 	void set(const list_type &x);
-	void set(const char* x);	
+	void set(const char* x);
 	void set(Canvas*x);
 	void set(etl::loose_handle<Canvas> x);
 	void set(etl::handle<Canvas> x);
 	template <class T> void set(const std::vector<T> &x)
 		{ _set(list_type(x.begin(),x.end())); }
 	template <class T> void set(const std::list<T> &x)
-		{ _set(list_type(x.begin(),x.end())); }	
+		{ _set(list_type(x.begin(),x.end())); }
 	// ========================================================================
 
-		
+
 	/*
  --	** -- S T A T I C   F U N C T I O N S -------------------------------------
 	*/
@@ -267,7 +277,7 @@ public:
 	static Type ident_type(const String &str);
 
 
-	// === GET TYPE MEMBERS ===================================================	
+	// === GET TYPE MEMBERS ===================================================
 	static const Type get_type(bool) { return TYPE_BOOL; }
 	static const Type get_type(int) { return TYPE_INTEGER; }
 	static const Type get_type(const Time&) { return TYPE_TIME; }
@@ -283,15 +293,15 @@ public:
 	static const Type get_type(const etl::handle<Canvas>&)
 		{ return TYPE_CANVAS; }
 	static const Type get_type(const etl::loose_handle<Canvas>&)
-		{ return TYPE_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; }
 	// ========================================================================
 
-		
+
 	/*
  --	** -- C A S T   O P E R A T O R S -----------------------------------------
 	*/
@@ -302,7 +312,7 @@ public:
 	//operator const Color&()const { return get(Color()); }
 	//operator const Real&()const { return get(Real()); }
 	//operator const Time&()const { return get(Time()); }
-	
+
 	operator const Vector&()const {  return get(Vector()); }
 	operator const BLinePoint&()const {  return get(BLinePoint()); }
 	//operator const int&()const {  return get(int()); }
@@ -324,7 +334,7 @@ public:
 	static const Type get_type(const half&) { return TYPE_REAL; }
 	operator half()const { return get(Real()); }
 #endif
-	
+
 #ifndef SYNFIG_NO_ANGLE
 	operator const Angle&()const { return get(Angle()); }
 	static const Type get_type(const Angle&) { return TYPE_ANGLE; }
@@ -345,16 +355,16 @@ public:
 		return ret;
 	}
 
-	
+
 private:
-	
+
 	template <typename T> void
 	_set(const T& x)
 	{
 		const Type newtype(get_type(x));
-		
+
 		assert(newtype!=TYPE_NIL);
-		
+
 		if(newtype==type)
 		{
 			if(ref_count.unique())
@@ -369,7 +379,7 @@ private:
 		type=newtype;
 		ref_count.reset();
 		data=new T(x);
-	}	
+	}
 }; // END of class ValueBase
 
 
@@ -383,21 +393,21 @@ public:
 	Value(const T &x):ValueBase(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()
 	{
 	}
-	
+
 	T get()const { return ValueBase::get(T()); }
 
 	void put(T* x)const	{ ValueBase::put(x); }
-	
+
 	void set(const T& x) { ValueBase::operator=(x); }
 
 	Value<T>& operator=(const T& x) { set(x); return *this; }
@@ -406,11 +416,11 @@ public:
 
 	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);
 	}
-	
+
 }; // END of class Value
 
 /*
@@ -423,17 +433,17 @@ public:
 	}
 	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 get()const { return ValueBase::get(T()); }
 
 	void put(T* x)const	{ ValueBase::put(x); }
-	
+
 	void set(const T& x) { ValueBase::operator=(x); }
 
 	Value<T>& operator=(const T& x) { set(x); return *this; }
@@ -442,11 +452,11 @@ public:
 
 	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);
 	}
-	
+
 }; // END of class Value
 */