IMP: container_macros.h Source File

00001 /**
00002  *  \file container_macros.h
00003  *  \brief Macros to define containers of objects
00004  *
00005  *  Copyright 2007-2010 IMP Inventors. All rights reserved.
00006  *
00007  */
00008 #ifndef IMP_CONTAINER_MACROS_H
00009 #define IMP_CONTAINER_MACROS_H
00010 
00011 #include "RefCounted.h"
00012 #include "VectorOfRefCounted.h"
00013 #include "internal/Vector.h"
00014 #include "macros.h"
00015 
00016 
00017 
00018 
00019 // Swig doesn't do protection right with protected members
00020 #ifdef IMP_SWIG_WRAPPER
00021 #define IMP_PROTECTION(protection) public:
00022 #else
00023 #define IMP_PROTECTION(protection) protection:
00024 #endif
00025 
00026 #ifndef SWIG
00027 /** Internal use only. */
00028 #define IMP_EXPOSE_ITERATORS(ContainerType, container_name, Ucname, lcname) \
00029   IMP_NO_DOXYGEN(typedef ContainerType::iterator Ucname##Iterator;)     \
00030   IMP_NO_DOXYGEN(typedef ContainerType::const_iterator                  \
00031                  Ucname##ConstIterator;)                                \
00032   IMP_ONLY_DOXYGEN(class Ucname##Iterator; class Ucname##ConstIterator;) \
00033   Ucname##Iterator lcname##s_begin() {return container_name.begin();}   \
00034   Ucname##Iterator lcname##s_end() {return container_name.end();}       \
00035   Ucname##ConstIterator lcname##s_begin() const {                       \
00036     return container_name.begin();                                      \
00037   }                                                                     \
00038   Ucname##ConstIterator lcname##s_end() const {                         \
00039     return container_name.end();}                                       \
00040 
00041 #else
00042 #define IMP_EXPOSE_ITERATORS(ContainerType, container_name, Ucname, lcname) \
00043   IMP_NO_DOXYGEN(typedef ContainerType::iterator Ucname##Iterator;)     \
00044   Ucname##Iterator lcname##s_begin() {return container_name.begin();}   \
00045   Ucname##Iterator lcname##s_end() {return container_name.end();}
00046 #endif // SWIG
00047 
00048 /**  \brief  A macro to provide a uniform interface for storing lists of
00049      objects.
00050 
00051      This macro is designed to be used in the body of an object to add
00052      a set of methods for manipulating a list of contained objects. It adds
00053      methods
00054      - get_foo
00055      - set_foo
00056      - set_foos
00057      - foos_begin, foos_end
00058      - remove_foo
00059      - remove_foos
00060      etc. where foo is the lcname provided.
00061 
00062      \param[in] protection The level of protection for the container
00063      (public, private).
00064      \param[in] Ucname The name of the type of container in uppercase.
00065      \param[in] lcname The name of the type of container in lower case.
00066      \param[in] Data The type of the data to store.
00067      \param[in] PluralData The plural of the data name. This should be a
00068      container type.
00069 
00070      An accompanying IMP_LIST_IMPL must go in a \c .cpp file.
00071 
00072      \note This macro should be given an appropriate name and wrapped in a
00073      doxygen comment block such as by starting with a C++ comment like
00074      \verbatim
00075      @name short description
00076      longer description
00077      @{
00078      \endverbatim
00079      and ending with one like
00080      \verbatim
00081      @}
00082      \endverbatim
00083  */
00084 #define IMP_LIST(protection, Ucname, lcname, Data, PluralData)          \
00085   IMP_PROTECTION(protection)                                            \
00086   /** \brief Remove any occurences of d from the container. */          \
00087   void remove_##lcname(Data d);                                         \
00088   /** \brief Remove any occurrences for which f is true */              \
00089   template <class F>                                                    \
00090   void remove_##lcname##s_if(const F &f) {                              \
00091     for (Ucname##Iterator it= lcname##s_begin(); it != lcname##s_end(); \
00092          ++it) {                                                        \
00093       if (f(*it)) handle_remove(*it);                                   \
00094     }                                                                   \
00095     IMP::internal::remove_if(lcname##_vector_, f);                      \
00096   }                                                                     \
00097   /** \brief Remove any occurences of each item in d. */                \
00098   void remove_##lcname##s(const PluralData& d);                         \
00099   /** Set the contents of the container to ps removing all its current
00100       contents. */                                                      \
00101 void set_##lcname##s(const PluralData &ps) {                            \
00102   /* Bad things can happen if we use a Temp, as things get unreffed
00103      before being reffed if they are in both lists */                   \
00104     clear_##lcname##s();                                                \
00105     add_##lcname##s(ps);                                                \
00106   }                                                                     \
00107 /** \return index of object within the object
00108 */                                                                      \
00109 unsigned int add_##lcname(Data obj);                                    \
00110 /** Add several objects to the container. They are not necessarily
00111     added at the end.
00112 */                                                                      \
00113 void add_##lcname##s(const PluralData& obj);                            \
00114 void clear_##lcname##s();                                               \
00115 unsigned int get_number_of_##lcname##s() const {                        \
00116   return lcname##_vector_.size();}                                      \
00117 /** \brief return true if there are any objects in the container*/      \
00118 bool get_has_##lcname##s() const {                                      \
00119   return !lcname##_vector_.empty();}                                    \
00120 /** Get the object refered to by the index
00121     \throws IndexException in Python if the index is out of range
00122 */                                                                     \
00123 Data get_##lcname(unsigned int i) const {                              \
00124   return lcname##_vector_[i];                                          \
00125 }                                                                      \
00126 void reserve_##lcname##s(unsigned int sz) {                             \
00127   lcname##_vector_.reserve(sz);                                         \
00128 }                                                                       \
00129 IMP_EXPOSE_ITERATORS(IMP::VectorOfRefCounted<Data>,                     \
00130                      lcname##_vector_, Ucname, lcname);                 \
00131 private:                                                                \
00132 const PluralData &access_##lcname##s() const {return lcname##_vector_;} \
00133 void handle_remove(Data d);                                             \
00134 IMP_NO_DOXYGEN(PluralData lcname##_vector_;)                            \
00135 IMP_PROTECTION(protection)                                              \
00136 
00137 
00138 
00139 
00140 //! This should go in a .cpp file for the respective class.
00141 /**
00142  This code should go in a .cpp file. One macro for each IMP_CONTAINER.
00143  \param[in] Class The name of the class containing this container.
00144  \param[in] Ucname The name of the type of container in uppercase.
00145  \param[in] lcname The name of the type of container in lower case.
00146  \param[in] Data The type of the data to store.
00147  \param[in] PluralData The plural of the data name. This should be a
00148  container type.
00149  \param[in] OnAdd Code to modify the passed in object. The object is obj
00150  and its index index.
00151  \param[in] OnChanged Code to get executed when the container changes.
00152  \param[in] OnRemoved Code to get executed when the an object is removed.
00153 
00154  For all of these the current object is called obj.
00155 */
00156 #define IMP_LIST_IMPL(Class, Ucname, lcname, Data, PluralData, OnAdd,   \
00157                       OnChanged, OnRemoved)                             \
00158   void Class::handle_remove( Data obj){                                 \
00159     if (0) std::cout << obj;                                            \
00160     OnRemoved;                                                          \
00161   }                                                                     \
00162   unsigned int Class::add_##lcname(Data obj) {                          \
00163     unsigned int index= lcname##_vector_.size();                        \
00164     lcname##_vector_.push_back(obj);                                    \
00165     OnAdd;                                                              \
00166     OnChanged;                                                          \
00167     if (false) {index=index; obj=obj;};                                 \
00168     return index;                                                       \
00169   }                                                                     \
00170   void Class::add_##lcname##s(const PluralData &objs) {                 \
00171     unsigned int osz= lcname##_vector_.size();                          \
00172     lcname##_vector_.insert(lcname##_vector_.end(), objs.begin(),       \
00173                             objs.end());                                \
00174     for (unsigned int i=0; i< objs.size(); ++i) {                       \
00175       Data obj= lcname##_vector_[osz+i];                                \
00176       unsigned int index(osz+i);                                        \
00177       OnAdd;                                                            \
00178       if (false) {obj=obj; index=index;}                                \
00179     }                                                                   \
00180     OnChanged;                                                          \
00181   }                                                                     \
00182   void Class::remove_##lcname##s(const PluralData& d) {                 \
00183     std::vector<Data> ds(d.begin(), d.end());                           \
00184     std::sort(ds.begin(), ds.end());                                    \
00185     for (unsigned int i=0; i< ds.size(); ++i) {                         \
00186       handle_remove(ds[i]);                                             \
00187     }                                                                   \
00188     IMP::internal::remove_if(lcname##_vector_,                          \
00189                              ::IMP::internal::list_contains(ds));       \
00190   }                                                                     \
00191   void Class::clear_##lcname##s(){                                      \
00192     lcname##_vector_.clear();                                           \
00193     OnChanged;                                                          \
00194   }                                                                     \
00195   void Class::remove_##lcname(Data d) {                                 \
00196     for (Ucname##Iterator it= lcname##s_begin();                        \
00197          it != lcname##s_end(); ++it) {                                 \
00198       if (*it == d) {                                                   \
00199         handle_remove(*it);                                             \
00200         lcname##_vector_.erase(it); break;                              \
00201       }                                                                 \
00202     }                                                                   \
00203     OnChanged;                                                          \
00204   }                                                                     \
00205 
00206 #endif  /* IMP_CONTAINER_MACROS_H */