Homepage

Demos

Overview

Downloads

Tutorials

Reference

Credits

ShapeFuns.h Go to the documentation of this file. //-*-c++-*- #ifndef INCLUDED_ShapeFuns_h_ #define INCLUDED_ShapeFuns_h_ #include <vector> #include "Shared/ProjectInterface.h" #include "ShapeTypes.h" #include "ShapeRoot.h" namespace DualCoding { // Note: the double parens in _name((_value)) are needed to keep the // compiler from confusing a copy constructor call with a function // description in certain cases, such as this one: // // NEW_SHAPE(foo, LineData, Shape<LineData>(newline)) //! Create a new shape and make it visible in the SketchGUI #define NEW_SHAPE(_name, _type, _value) \ Shape<_type> _name((_value)); \ if ( _name.isValid() ) _name->V(#_name); //! Create a new shape but hide it from the SketchGUI #define NEW_SHAPE_N(_name, _type, _value) \ NEW_SHAPE(_name, _type, _value); \ if ( _name.isValid() ) _name->N(#_name); //! Retrieve a shape based on its name #define GET_SHAPE(_name, _type, _shapevec) \ Shape<_type> _name(find_shape<_type>(_shapevec,#_name)); //! Create a new vector of shapes of the specified type #define NEW_SHAPEVEC(_name, _type, _value) \ vector<Shape<_type> > _name((_value)); //! Create a new vector of shapes of mixed type #define NEW_SHAPEROOTVEC(_name, _value) \ vector<ShapeRoot> _name((_value)); //! Iterate over the shapes in a vector; _var is the iterator #define SHAPEVEC_ITERATE(_shapesvec,_type,_var) \ for ( std::vector<Shape<_type> >::iterator _var##_it = _shapesvec.begin(); \ _var##_it != _shapesvec.end(); _var##_it++ ) { \ Shape<_type> &_var = *_var##_it; //! Nested iteration over the shapes in a vector; _var2 begins one past _var1 #define SHAPENEXT_ITERATE(_shapesvec,_type,_var1,_var2) \ for ( std::vector<Shape<_type> >::iterator _var2##_it = ++std::vector<Shape<_type> >::iterator(_var1##_it); \ _var2##_it != _shapesvec.end(); _var2##_it++ ) { \ Shape<_type> &_var2 = *_var2##_it; //! Iterate over a vector for shapes of mixed type #define SHAPEROOTVEC_ITERATE(_shapesvec,_var) \ for ( std::vector<ShapeRoot>::iterator _var##_it = _shapesvec.begin(); \ _var##_it != _shapesvec.end(); _var##_it++ ) { \ ShapeRoot &_var = *_var##_it; #define END_ITERATE } //! Obsolete: Iterate over the shapes in a vector; _var is the iterator #define DO_SHAPEVEC(_shapesvec,_type,_var,_body) \ for ( std::vector<Shape<_type> >::iterator _var##_it = _shapesvec.begin(); \ _var##_it != _shapesvec.end(); _var##_it++ ) { \ Shape<_type> &_var = *_var##_it; \ _body } \ //! Obsolete: nested iteration over the shapes in a vector; _var2 begins one past _var1 #define DO_SHAPENEXT(_shapesvec,_type,_var1,_var2,_body) \ for ( std::vector<Shape<_type> >::iterator _var2##_it = ++std::vector<Shape<_type> >::iterator(_var1##_it); \ _var2##_it != _shapesvec.end(); _var2##_it++ ) { \ Shape<_type> &_var2 = *_var2##_it; \ _body } //! Obsolete: Iterate over a vector for shapes of mixed type #define DO_SHAPEROOTVEC(_shapesvec,_var,_body) \ for ( std::vector<ShapeRoot>::iterator _var##_it = _shapesvec.begin(); \ _var##_it != _shapesvec.end(); _var##_it++ ) { \ ShapeRoot &_var = *_var##_it; \ _body } // ================================================================ //! Unary predicates over ShapeRoot objects class UnaryShapeRootPred : public unary_function<ShapeRoot, bool> { public: virtual ~UnaryShapeRootPred() {} //!< virtual destructor to satisfy warning }; //! Binary predicates over ShapeRoot objects class BinaryShapeRootPred : public binary_function<ShapeRoot, ShapeRoot, bool> { public: virtual ~BinaryShapeRootPred() {} //!< virtual destructor to satisfy warning }; //! Unary predicates over Shape<T> objects template <class T> class UnaryShapePred : public unary_function<Shape<T>, bool> { public: virtual ~UnaryShapePred() {} //!< virtual destructor to satisfy warning }; //! Binary predicates over Shape<T> objects template <class T> class BinaryShapePred : public binary_function<Shape<T>, Shape<T>, bool> { public: virtual ~BinaryShapePred() {} //!< virtual destructor to satisfy warning }; // ================ Short-Circuit AND and OR //! Classes for implementing shortcircuit And and Or predicates. Don't call directly; use andPred and orPred; use not1 for negation. //@{ template<typename PredType1, typename PredType2> class shortcircuit_and : public unary_function<typename PredType1::argument_type,bool> { public: PredType1 p1; PredType2 p2; shortcircuit_and(PredType1 _p1, PredType2 _p2) : unary_function<typename PredType1::argument_type,bool>(), p1(_p1), p2(_p2) {} bool operator() (const typename PredType1::argument_type &shape) const { if ( p1(shape) ) return p2(shape); else return false; } }; template<typename PredType1, typename PredType2> class shortcircuit_or : public unary_function<typename PredType1::argument_type,bool> { public: PredType1 p1; PredType2 p2; shortcircuit_or(PredType1 _p1, PredType2 _p2) : unary_function<typename PredType1::argument_type,bool>(), p1(_p1), p2(_p2) {} bool operator() (const typename PredType1::argument_type &shape) const { if ( p1(shape) ) return true; else return p2(shape); } }; /*! Templated functions can pick up type information from their arguments, but templated class constructors cannot; they expect type info to be supplied explicitly as template arguments in <>. So we define andPred() and orPred() templated functions to pick up the type info and pass it on to the shortcircuit_and and shortcircuit_or constructors as explicit template arguments. The built-in function adaptors not1 and not2 already use this trick for negation. */ //@{ //! Conjunction of two predicates; p2 is called only if p1 returns true template<typename PredType1, typename PredType2> shortcircuit_and<PredType1,PredType2> andPred(PredType1 p1, PredType2 p2) { return shortcircuit_and<PredType1,PredType2>(p1,p2); } //! Disjunction of two predicates; p2 is called only if p1 returns false template<typename PredType1, typename PredType2> shortcircuit_or<PredType1,PredType2> orPred(PredType1 p1, PredType2 p2) { return shortcircuit_or<PredType1,PredType2>(p1,p2); } //@} // ================ Unary ShapeRoot predicates class isType : public UnaryShapeRootPred { public: ShapeType_t type; explicit isType(ShapeType_t _type) : UnaryShapeRootPred(), type(_type) {} bool operator()(const ShapeRoot &shape) const { return shape->getType() == type; } }; class isColor : public UnaryShapeRootPred { public: rgb color; explicit isColor(int colorIndex) : UnaryShapeRootPred(), color(ProjectInterface::getColorRGB(colorIndex)) {} explicit isColor(rgb _color) : UnaryShapeRootPred(), color(_color) {} explicit isColor(std::string const &_colorname) : UnaryShapeRootPred(), color(ProjectInterface::getColorRGB(_colorname)) {} bool operator()(const ShapeRoot &shape) const { return shape->getColor() == color; } }; class isName : public UnaryShapeRootPred { public: std::string name; explicit isName(std::string _name) : UnaryShapeRootPred(), name(_name) {} bool operator()(const ShapeRoot &shape) const { // return strcmp(shape->getName().c_str(),name.c_str()) == 0; } return shape->getName() == name; } }; // ================ find_if, find_shape, subset, max_element, stable_sort, etc. template<class T, typename PredType> Shape<T> find_if(const vector<Shape<T> > &vec, PredType pred) { typename vector<Shape<T> >::const_iterator result = find_if(vec.begin(),vec.end(),pred); if ( result != vec.end() ) return *result; else return Shape<T>(); } //! Return the first ShapeRoot with the specified name, else return an invalid ShapeRoot template<class T> Shape<T> find_shape(const vector<ShapeRoot> &vec, const std::string &name) { for ( vector<ShapeRoot>::const_iterator it = vec.begin(); it != vec.end(); it++ ) if ( (*it)->getType() == T::getStaticType() && (*it)->getName() == name ) return ShapeRootTypeConst(*it,T); return Shape<T>(); } //! Select the Shape<T> elements from a vector of ShapeRoots template<class T> std::vector<Shape<T> > select_type(std::vector<ShapeRoot> &vec) { std::vector<Shape<T> > result(vec.size()); result.clear(); isType tpred(T::getStaticType()); DO_SHAPEROOTVEC(vec, element, { if ( tpred(element) ) result.push_back(reinterpret_cast<const Shape<T>&>(element)); }); return result; } template<class T, typename PredType> std::vector<Shape<T> > subset(const std::vector<Shape<T> > &vec, PredType pred) { std::vector<Shape<T> > result; remove_copy_if(vec.begin(), vec.end(), std::back_insert_iterator<std::vector<Shape<T> > >(result), not1(pred)); return result; } template<class T, typename ComparisonType> Shape<T> max_element(const vector<Shape<T> > &vec, ComparisonType comp) { typename vector<Shape<T> >::const_iterator result = max_element(vec.begin(),vec.end(),comp); if ( result != vec.end() ) return *result; else return Shape<T>(); } template<class T, typename ComparisonType> Shape<T> min_element(const vector<Shape<T> > &vec, ComparisonType comp) { return max_element(vec, not2(comp)); } template<class T, typename PredType> std::vector<Shape<T> > stable_sort(const std::vector<Shape<T> > &vec, PredType pred) { std::vector<Shape<T> > result(vec); stable_sort(result.begin(), result.end(), pred); return result; } // ================ IsLeftOf / IsRightOf / IsAbove / IsBelow // ================ IsLeftOfThis / IsRightOfThis / IsAboveThis / IsBelowThis // // To enforce consistency, predicates are defined in pairs: isRightOf(x,y) // is defined as isLeftOf(y,x). #define DIRECTION_PAIR(dir, oppdir) \ class Is##dir : public BinaryShapeRootPred { \ public: \ Is##dir(float distance=0) : dist(distance) {} \ bool operator() (const ShapeRoot&, const ShapeRoot&) const; \ private: \ float dist; \ }; \ \ class Is##dir##This : public UnaryShapeRootPred { \ public: \ Is##dir##This(const ShapeRoot &_s2, float distance=0) : \ UnaryShapeRootPred(), s2(_s2), dist(distance) {} \ bool operator() (const ShapeRoot &s1) const { \ return Is##dir(dist)(s1,s2); } \ private: \ ShapeRoot s2; \ float dist; \ }; \ \ class Is##oppdir : public BinaryShapeRootPred { \ public: \ Is##oppdir(float distance=0) : dist(distance) {} \ bool operator() (const ShapeRoot &s1, const ShapeRoot &s2) const { \ return Is##dir(dist) (s2, s1); } \ private: \ float dist; \ }; \ \ class Is##oppdir##This : public UnaryShapeRootPred { \ public: \ Is##oppdir##This(const ShapeRoot &_s2, float distance=0) : \ UnaryShapeRootPred(), s2(_s2), dist(distance) {} \ bool operator() (const ShapeRoot &s1) const { \ return Is##dir(dist) (s2,s1); } \ private: \ ShapeRoot s2; \ float dist; \ }; DIRECTION_PAIR(LeftOf, RightOf) DIRECTION_PAIR(Above, Below) #undef DIRECTION_PAIR } // namespace #endif

DualCoding 3.0beta

Generated Wed Oct 4 00:01:54 2006 by Doxygen 1.4.7