X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=synfig-core%2Ftrunk%2Fsrc%2Fsynfig%2Fvalue.h;h=53dc12aa2e5b6ed124fecb41708b94078f75b569;hb=c74ce4738eff208de3bef4b63929b6975a896e93;hp=6c9ab9cb620877268396c0a898c68fe594ad8409;hpb=e3acc0b267b14fda5db3c7bbb2f218b993ef84b3;p=synfig.git diff --git a/synfig-core/trunk/src/synfig/value.h b/synfig-core/trunk/src/synfig/value.h index 6c9ab9c..53dc12a 100644 --- a/synfig-core/trunk/src/synfig/value.h +++ b/synfig-core/trunk/src/synfig/value.h @@ -1,28 +1,29 @@ -/* === S I N F G =========================================================== */ +/* === S Y N F I G ========================================================= */ /*! \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 Robert B. Quattlebaum Jr. +** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley ** -** This software and associated documentation -** are CONFIDENTIAL and PROPRIETARY property of -** the above-mentioned copyright holder. +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. ** -** You may not copy, print, publish, or in any -** other way distribute this software without -** a prior written agreement with -** the copyright holder. +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. ** \endlegal */ /* ========================================================================= */ /* === S T A R T =========================================================== */ -#ifndef __SINFG_VALUE_H -#define __SINFG_VALUE_H +#ifndef __SYNFIG_VALUE_H +#define __SYNFIG_VALUE_H /* === H E A D E R S ======================================================= */ @@ -40,7 +41,11 @@ #include "blinepoint.h" #include "exception.h" -#ifndef SINFG_NO_ANGLE +#ifdef USE_HALF_TYPE +#include +#endif + +#ifndef SYNFIG_NO_ANGLE #include "angle.h" #endif @@ -52,7 +57,7 @@ /* === C L A S S E S & S T R U C T S ======================================= */ -namespace sinfg { +namespace synfig { class Canvas; class Vector; @@ -61,7 +66,7 @@ class Segment; class Gradient; class BLinePoint; class Color; - + /*! \class ValueBase ** \todo writeme */ @@ -77,25 +82,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 @@ -103,7 +108,7 @@ public: TYPE_END //!< Not a valid type, used for sanity checks }; - + private: typedef std::vector list_type; @@ -113,16 +118,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 @@ -139,7 +144,7 @@ public: //! \writeme ~ValueBase(); - + /* -- ** -- O P E R A T O R S --------------------------------------------------- */ @@ -151,7 +156,7 @@ public: { set(x); return *this; } //! \writeme - ValueBase& operator=(const ValueBase& x); + ValueBase& operator=(const ValueBase& x); //! \writeme bool operator==(const ValueBase& rhs)const; @@ -176,14 +181,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; @@ -192,26 +197,26 @@ 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 bool - same_as(const T &x)const + same_type_as(const T &x)const { const Type testtype(get_type(x)); - + 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 const T &get(const T& x)const { - assert(is_valid() && same_as(x)); + assert(is_valid() && same_type_as(x)); return *static_cast(data); } float get(const float &)const { return get(Real()); } @@ -222,37 +227,37 @@ public: const char* get(const char*)const; const list_type& get_list()const { return get(list_type()); } // ======================================================================== - - - - // === PUT MEMBERS ======================================================== + + + + // === PUT MEMBERS ======================================================== template void put(T* x)const { - assert(same_as(*x)); + assert(same_type_as(*x)); *x=*static_cast(data); } void put(float* x)const { *x=get(Real()); } void put(char** x)const; // ======================================================================== - - - // === SET MEMBERS ======================================================== + + + // === SET MEMBERS ======================================================== template 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 x); void set(etl::handle x); template void set(const std::vector &x) { _set(list_type(x.begin(),x.end())); } template void set(const std::list &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 ------------------------------------- */ @@ -266,7 +271,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; } @@ -282,7 +287,7 @@ public: static const Type get_type(const etl::handle&) { return TYPE_CANVAS; } static const Type get_type(const etl::loose_handle&) - { return TYPE_CANVAS; } + { return TYPE_CANVAS; } static const Type get_type(const list_type&) { return TYPE_LIST; } template static const Type get_type(const std::vector &x) { return TYPE_LIST; } @@ -290,32 +295,18 @@ public: { return TYPE_LIST; } // ======================================================================== - + /* -- ** -- C A S T O P E R A T O R S ----------------------------------------- */ public: - template - operator std::list()const - { - assert(type==TYPE_LIST); - std::list ret(get_list().begin(),get_list().end()); - return ret; - } - template - operator std::vector()const - { - assert(type==TYPE_LIST); - std::vector ret(get_list().begin(),get_list().end()); - return ret; - } operator const list_type&()const { return get_list(); } //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()); } @@ -323,6 +314,7 @@ public: //operator const char *()const { return get(String()).c_str(); } operator const Segment&()const { return get(Segment()); } + /* -- ** -- O T H E R ----------------------------------------------------------- */ @@ -336,22 +328,37 @@ public: static const Type get_type(const half&) { return TYPE_REAL; } operator half()const { return get(Real()); } #endif - -#ifndef SINFG_NO_ANGLE + +#ifndef SYNFIG_NO_ANGLE operator const Angle&()const { return get(Angle()); } static const Type get_type(const Angle&) { return TYPE_ANGLE; } #endif - + template + operator std::list()const + { + assert(type==TYPE_LIST); + std::list ret(get_list().begin(),get_list().end()); + return ret; + } + template + operator std::vector()const + { + assert(type==TYPE_LIST); + std::vector ret(get_list().begin(),get_list().end()); + return ret; + } + + private: - + template void _set(const T& x) { const Type newtype(get_type(x)); - + assert(newtype!=TYPE_NIL); - + if(newtype==type) { if(ref_count.unique()) @@ -366,7 +373,7 @@ private: type=newtype; ref_count.reset(); data=new T(x); - } + } }; // END of class ValueBase @@ -380,21 +387,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(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& operator=(const T& x) { set(x); return *this; } @@ -403,11 +410,11 @@ public: Value& operator=(const ValueBase& x) { - if(!x.same_as(T())) + if(!x.same_type_as(T())) throw Exception::BadType("Value(ValueBase): Type Mismatch"); return ValueBase::operator=(x); } - + }; // END of class Value /* @@ -420,17 +427,17 @@ public: } Value(const ValueBase &x):ValueBase(x) { - if(!x.same_as(T())) + if(!x.same_type_as(T())) throw Exception::BadType("Value(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& operator=(const T& x) { set(x); return *this; } @@ -439,15 +446,15 @@ public: Value& operator=(const ValueBase& x) { - if(!x.same_as(T())) + if(!x.same_type_as(T())) throw Exception::BadType("Value(ValueBase): Type Mismatch"); return ValueBase::operator=(x); } - + }; // END of class Value */ -}; // END of namespace sinfg +}; // END of namespace synfig /* === E N D =============================================================== */