From 395a4bceaac30588963dacb8e006e9ebbe2ca6dd Mon Sep 17 00:00:00 2001 From: cathook Date: Thu, 1 May 2014 21:58:06 +0800 Subject: add OO --- meowpp/colors/RGB.h | 6 ++ meowpp/colors/RGB.hpp | 32 ++++++++- meowpp/oo/ObjBase.h | 32 +++++++++ meowpp/oo/Properties.h | 61 +++++++++++++++++ meowpp/oo/Properties.hpp | 173 +++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 303 insertions(+), 1 deletion(-) create mode 100644 meowpp/oo/ObjBase.h create mode 100644 meowpp/oo/Properties.h create mode 100644 meowpp/oo/Properties.hpp (limited to 'meowpp') diff --git a/meowpp/colors/RGB.h b/meowpp/colors/RGB.h index c7c03c1..803cdd9 100644 --- a/meowpp/colors/RGB.h +++ b/meowpp/colors/RGB.h @@ -2,6 +2,8 @@ #define colors_RGB_H_ #include +#include "../math.h" +#include "../geo/Vector3D.h" namespace meow{ template @@ -32,6 +34,10 @@ namespace meow{ T b(T const& val); T rgb(size_t i, T const& val); T bgr(size_t i, T const& val); + T rgb(T const& __r, T const& __g, T const& __b); + T bgr(T const& __r, T const& __g, T const& __b); + Matrix matrix() const; + Vector3D vector() const; }; class RGBf: public RGB{ diff --git a/meowpp/colors/RGB.hpp b/meowpp/colors/RGB.hpp index 1364814..0e0381d 100644 --- a/meowpp/colors/RGB.hpp +++ b/meowpp/colors/RGB.hpp @@ -6,6 +6,9 @@ #include "../math/utility.h" +#include "../geo/Vector3D.h" +#include "../math/Matrix.h" + namespace meow{ template inline RGB::RGB(){ } @@ -47,7 +50,34 @@ namespace meow{ inline T RGB::bgr(size_t i, T const& val){ return rgb(2 - i, val); } - + template + inline T RGB::rgb(T const& __r, T const& __g, T const& __b){ + r(__r); + g(__g); + b(__b); + } + template + inline T RGB::bgr(T const& __b, T const& __g, T const& __r){ + r(__r); + g(__g); + b(__b); + } + template + inline Matrix RGB::matrix() const{ + static Matrix ret(3, 1, T(0)); + ret(0, 0) = r(); + ret(1, 0) = g(); + ret(2, 0) = b(); + return ret; + } + template + inline Vector3D RGB::vector() const{ + static Vector3D ret; + ret(0) = r(); + ret(1) = g(); + ret(2) = b(); + return ret; + } inline RGBf::RGBf(): RGB(0.0, 0.0, 0.0){ } diff --git a/meowpp/oo/ObjBase.h b/meowpp/oo/ObjBase.h new file mode 100644 index 0000000..8bd0f1c --- /dev/null +++ b/meowpp/oo/ObjBase.h @@ -0,0 +1,32 @@ +#ifndef oo_ObjBase_H__ +#define oo_ObjBase_H__ + +#include +#include + +namespace meow{ + class ObjBase{ + protected: + ObjBase(){ } + public: + virtual ~ObjBase(){ } + // + virtual char const* ctype() const{ + static char const* ptr = typeid(*this).name(); + return ptr; + } + virtual std::string type() const{ + return std::string(ctype()); + } + // + static char const* ctypeBase(){ + static char const* ptr = typeid(ObjBase).name(); + return ptr; + } + static std::string typeBase(){ + return std::string(ctypeBase()); + } + }; +} + +#endif // oo_ObjBase_H__ diff --git a/meowpp/oo/Properties.h b/meowpp/oo/Properties.h new file mode 100644 index 0000000..f19e300 --- /dev/null +++ b/meowpp/oo/Properties.h @@ -0,0 +1,61 @@ +#ifndef oo_Properties_H__ +#define oo_Properties_H__ + +#include "ObjBase.h" + +#include +#include + +#include + +namespace meow{ + class Properties: public ObjBase{ + private: + struct Property{ + ObjBase* _pointer; + ssize_t _counter; + // + Property(ObjBase* __pointer, bool __autoRemove); + Property(Property const& __property); + ~Property(); + // + bool attach(); + bool detach(); + }; + // + std::map _properties; + std::map _index; + std::queue _freeIndex; + // + size_t newIndex(std::string const& __name); + void delIndex(size_t __index); + void detach(size_t __index); + public: + Properties(); + Properties(Properties const& __p); + ~Properties(); + // + void clear(); + Properties& copy (Properties const& __p); + // + size_t size () const; + bool empty() const; + // + bool chg(size_t __index, ObjBase* __pointer, bool __autoRemove); + bool add(std::string __name , ObjBase* __pointer, bool __autoRemove); + bool del(size_t __index); + bool del(std::string __name ); + ObjBase* get(size_t __index) const; + ObjBase* get(std::string __name ) const; + ssize_t getIndex(ObjBase* __pointer) const; + std::string getName (ObjBase* __pointer) const; + // + Properties& operator=(Properties const& __p); + ObjBase* operator()(size_t __index) const; + ObjBase* operator()(std::string __name ) const; + }; +} + +#include "Properties.hpp" + +#endif // oo_Properties_H__ diff --git a/meowpp/oo/Properties.hpp b/meowpp/oo/Properties.hpp new file mode 100644 index 0000000..90d9805 --- /dev/null +++ b/meowpp/oo/Properties.hpp @@ -0,0 +1,173 @@ +#include "Properties.h" + +#include +#include + + +namespace meow{ + inline Properties::Property::Property(ObjBase* __pointer, bool __autoRemove): + _pointer(__pointer), + _counter(__autoRemove ? -1 : 1){ + } + inline Properties::Property::Property(Property const& __property): + _pointer(__property._pointer), + _counter(__property._counter){ + } + inline Properties::Property::~Property(){ + } + inline bool Properties::Property::attach(){ + if(_pointer == NULL || _counter <= 0) return false; + _counter++; + return true; + } + inline bool Properties::Property::detach(){ + if(_pointer == NULL || _counter <= 0) return false; + _counter--; + if(_counter <= 0){ + delete _pointer; + _pointer = NULL; + } + return true; + } + //////////////////////////////////////////////////////////////////// + inline size_t Properties::newIndex(std::string const& __name){ + size_t i; + if(_freeIndex.size() > 0){ + i = _freeIndex.front(); + _freeIndex.pop(); + }else{ + i = size(); + } + _index[__name] = i; + return i; + } + inline void Properties::delIndex(size_t __index){ + _properties.erase(__index); + for(std::map::iterator it = _index.begin(); + it != _index.end(); + it++){ + if(it->second == __index){ + _index.erase(it); + break; + } + } + _freeIndex.push(__index); + } + inline void Properties::detach(size_t __index){ + _properties[__index]->detach(); + if(_properties[__index]->_counter == 0){ + delete _properties[__index]; + } + _properties[__index] = NULL; + } + inline Properties::Properties(){ + } + inline Properties::Properties(Properties const& __p){ + copy(__p); + } + inline Properties::~Properties(){ + clear(); + } + inline void Properties::clear(){ + for(std::map::iterator it = _properties.begin(); + it != _properties.end(); + it++){ + it->second->detach(); + } + _properties.clear(); + _index .clear(); + while(!_freeIndex.empty()) + _freeIndex.pop(); + } + inline Properties& Properties::copy(Properties const& __p){ + clear(); + _properties = ((Properties&)__p)._properties; + _index = ((Properties&)__p)._index; + _freeIndex = ((Properties&)__p)._freeIndex; + for(std::map::iterator it = _properties.begin(); + it != _properties.end(); + it++){ + it->second->attach(); + } + return *this; + } + inline size_t Properties::size() const{ + return (_properties.size()); + } + inline bool Properties::empty() const{ + return (size() == 0u); + } + inline bool Properties::chg(size_t __index, + ObjBase* __pointer, + bool __autoRemove){ + if(get(__index) == NULL) + return false; + detach(__index); + _properties[__index] = new Property(__pointer, __autoRemove); + return true; + } + inline bool Properties::add(std::string __name , + ObjBase* __pointer, + bool __autoRemove){ + if(get(__name) != NULL) + del(__name); + _properties[newIndex(__name)] = new Property(__pointer, __autoRemove); + return true; + } + inline bool Properties::del(size_t __index){ + if(get(__index) == NULL){ + return false; + } + detach(__index); + delIndex(__index); + return true; + } + inline bool Properties::del(std::string __name){ + if(get(__name) == NULL){ + return false; + } + return del(_index[__name]); + } + inline ObjBase* Properties::get(size_t __index) const{ + std::map::const_iterator i = _properties.find(__index); + if(i == _properties.end()) return NULL; + return (ObjBase*)(i->second->_pointer); + } + inline ObjBase* Properties::get(std::string __name) const{ + std::map::const_iterator i = _index.find(__name); + if(i == _index.end()) return NULL; + return get(i->second); + } + inline ssize_t Properties::getIndex(ObjBase* __pointer) const{ + for(std::map::const_iterator it = _properties.begin(); + it != _properties.end(); + it++){ + if(it->second->_pointer == __pointer){ + return it->first; + } + } + return -1; + } + inline std::string Properties::getName(ObjBase* __pointer) const{ + ssize_t t = getIndex(__pointer); + if(t < 0) return std::string(); + for(std::map::const_iterator it = _index.begin(); + it != _index.end(); + it++){ + if(it->second == (size_t)t){ + if(it == _index.end()) return std::string(); + return it->first; + } + } + return std::string(); + } + inline Properties& Properties::operator=(Properties const& __p){ + return copy(__p); + } + inline ObjBase* Properties::operator()(size_t __index) const{ + return get(__index); + } + inline ObjBase* Properties::operator()(std::string __name) const{ + return get(__name); + } +}; -- cgit v1.2.3