Changeset 795c0f for src


Ignore:
Timestamp:
Jul 24, 2015, 4:44:34 PM (10 years ago)
Author:
Frederik Heber <heber@…>
Branches:
Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, Candidate_v1.7.0, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable
Children:
63fb7a
Parents:
97445f
git-author:
Frederik Heber <heber@…> (06/01/15 08:30:56)
git-committer:
Frederik Heber <heber@…> (07/24/15 16:44:34)
Message:

World::getAtoms() now has const versions as well.

  • this in turn required to adapt all AtomDescriptors and some fixes, e.g. predicate is now const member and works on const atom ptr.
Location:
src
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • src/Atom/AtomSet.hpp

    r97445f r795c0f  
    3636template <>
    3737struct is_atom<atom*>{
     38  typedef void wrong_type;
     39};
     40
     41template <>
     42struct is_atom<const atom*>{
    3843  typedef void wrong_type;
    3944};
    … …  
    198203// allows simpler definition of AtomSets
    199204#define ATOMSET(container_type) AtomSetMixin<container_type<atom*> >
     205#define CONSTATOMSET(container_type) AtomSetMixin<container_type<const atom*> >
    200206
    201207#endif /* ATOMSET_HPP_ */

  • src/Descriptors/AtomDescriptor.cpp

    r97445f r795c0f  
    4949
    5050typedef World::AtomSet::internal_iterator atoms_iter_t;
     51typedef World::AtomSet::const_iterator atoms_const_iter_t;
    5152
    5253/************************ Forwarding object **************************************/
    … …  
    7576}
    7677
     78const atom* AtomDescriptor::find() const {
     79  return const_cast<const impl_t &>(*impl).find();
     80}
     81
    7782std::vector<atom*> AtomDescriptor::findAll(){
    7883  return impl->findAll();
    7984}
    8085
     86std::vector<const atom*> AtomDescriptor::findAll() const {
     87  return const_cast<const impl_t &>(*impl).findAll();
     88}
     89
    8190AtomDescriptor::impl_ptr AtomDescriptor::get_impl() const{
    8291  return impl;
    … …  
    98107World::AtomSet& AtomDescriptor_impl::getAtoms(){
    99108  return World::getInstance().atoms;
     109}
     110
     111const World::AtomSet& AtomDescriptor_impl::getAtoms() const {
     112  return const_cast<const World &>(World::getInstance()).atoms;
    100113}
    101114
    … …  
    104117  atoms_iter_t res = find_if(atoms.begin_internal(),atoms.end_internal(),boost::bind(&AtomDescriptor_impl::predicate,this,_1));
    105118  return (res!=atoms.end_internal())?((*res).second):0;
     119}
     120
     121const atom* AtomDescriptor_impl::find() const {
     122  const World::AtomSet &atoms = getAtoms();
     123  atoms_const_iter_t res = find_if(atoms.begin(),atoms.end(),boost::bind(&AtomDescriptor_impl::predicate,this,_1));
     124  return (res!=atoms.end())?((*res).second):0;
    106125}
    107126
    … …  
    111130  for_each(atoms.begin_internal(),
    112131           atoms.end_internal(),
    113            boost::bind(&AtomDescriptor_impl::checkAndAdd,
    114                        this,&res,_1));
     132           boost::bind(static_cast<void (AtomDescriptor_impl::*)(
     133               std::vector<atom*> *,
     134               std::pair<atomId_t,atom*>)>(&AtomDescriptor_impl::checkAndAdd),
     135                       this,boost::cref(&res),_1));
     136  return res;
     137}
     138
     139vector<const atom*> AtomDescriptor_impl::findAll() const {
     140  vector<const atom*> res;
     141  const World::AtomSet &atoms = getAtoms();
     142  for_each(atoms.begin(),
     143           atoms.end(),
     144           boost::bind(static_cast<void (AtomDescriptor_impl::*)(
     145               std::vector<const atom*> *,
     146               std::pair<atomId_t,const atom*>) const>(&AtomDescriptor_impl::checkAndAdd),
     147                       boost::cref(this),&res,_1));
    115148  return res;
    116149}
    … …  
    122155}
    123156
     157void AtomDescriptor_impl::checkAndAdd(std::vector<const atom*> *v,std::pair<atomId_t,const atom*> p) const{
     158  if(predicate(p)){
     159    v->push_back(p.second);
     160  }
     161}
     162
    124163/************************** Universe and Emptyset *****************/
    125164
    … …  
    130169{}
    131170
    132 bool AtomAllDescriptor_impl::predicate(std::pair<atomId_t,atom*>){
     171bool AtomAllDescriptor_impl::predicate(std::pair<atomId_t,const atom*>) const{
    133172  return true;
    134173}
    … …  
    144183{}
    145184
    146 bool AtomNoneDescriptor_impl::predicate(std::pair<atomId_t,atom*>){
     185bool AtomNoneDescriptor_impl::predicate(std::pair<atomId_t,const atom*>) const{
    147186  return false;
    148187}
    … …  
    162201{}
    163202
    164 bool AtomAndDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom){
     203bool AtomAndDescriptor_impl::predicate(std::pair<atomId_t,const atom*> atom) const{
    165204  return lhs->predicate(atom) && rhs->predicate(atom);
    166205}
    … …  
    178217}
    179218
    180 bool AtomOrDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom){
     219bool AtomOrDescriptor_impl::predicate(std::pair<atomId_t,const atom*> atom) const{
    181220  return lhs->predicate(atom) || rhs->predicate(atom);
    182221}
    … …  
    198237}
    199238
    200 bool AtomNotDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom){
     239bool AtomNotDescriptor_impl::predicate(std::pair<atomId_t,const atom*> atom) const{
    201240 return !(arg->predicate(atom));
    202241}

  • src/Descriptors/AtomDescriptor.hpp

    r97445f r795c0f  
    4040  // close coupling to the world to allow access
    4141  friend atom* World::getAtom(AtomDescriptor descriptor);
     42  friend const atom* World::getAtom(AtomDescriptor descriptor) const;
    4243  friend World::AtomComposite World::getAllAtoms(AtomDescriptor descriptor);
     44  friend World::ConstAtomComposite World::getAllAtoms(AtomDescriptor descriptor) const;
    4345  template <class,class,class> friend class SelectiveIterator;
    4446  template <class,class,class> friend class SelectiveConstIterator;
    … …  
    4951
    5052public:
    51   typedef boost::shared_ptr<AtomDescriptor_impl> impl_ptr; //!< Allow easy changes of the pointer-to-implementation type
     53  typedef AtomDescriptor_impl impl_t;
     54  typedef boost::shared_ptr<impl_t> impl_ptr; //!< Allow easy changes of the pointer-to-implementation type
    5255
    5356  AtomDescriptor(impl_ptr);
    … …  
    7780   * forward Method to implementation
    7881   */
     82  const atom* find() const;
     83
     84  /**
     85   * forward Method to implementation
     86   */
    7987  std::vector<atom*> findAll();
     88
     89  /**
     90   * forward Method to implementation
     91   */
     92  std::vector<const atom*> findAll() const;
    8093
    8194  /**

  • src/Descriptors/AtomDescriptor_impl.hpp

    r97445f r795c0f  
    3030   * Implement this abstract Method to make a concrete AtomDescriptor pick certain Atoms
    3131   */
    32   virtual bool predicate(std::pair<atomId_t,atom*>)=0;
     32  virtual bool predicate(std::pair<atomId_t,const atom*>) const=0;
    3333
    3434protected:
    … …  
    4343
    4444  /**
     45   * This method is called when the Descriptor is used to find the first matching
     46   * Atom. Walks through all Atoms and stops on the first match. Can be implemented
     47   * when the searched Atom can be found in a more efficient way. Calculated
     48   * Atomdescriptors will always use this method, so no improvement there.
     49   */
     50  virtual const atom* find() const;
     51
     52  /**
    4553   * This method is called when the Descriptor is used to find all matching Atoms.
    4654   * Walks through all Atoms and tests the predicate on each one. A vector of all
    … …  
    4856   */
    4957  virtual std::vector<atom*> findAll();
     58
     59  /**
     60   * This method is called when the Descriptor is used to find all matching Atoms.
     61   * Walks through all Atoms and tests the predicate on each one. A vector of all
     62   * matching Atoms is returned.
     63   */
     64  virtual std::vector<const atom*> findAll() const;
    5065
    5166  /**
    … …  
    5772  World::AtomSet& getAtoms();
    5873
     74  /**
     75   * This method is used internally to query the Set of Atoms from the world.
     76   * By using this method derived classes can also access the Internal World Datastructre.
     77   * Implemented in full in the Base Descriptor Implementation, so only this one method
     78   * needs to be friend with the World class.
     79   */
     80  const World::AtomSet& getAtoms() const;
     81
    5982  void checkAndAdd(std::vector<atom*>*,std::pair<atomId_t,atom*>);
     83
     84  void checkAndAdd(std::vector<const atom*>*,std::pair<atomId_t,const atom*>) const;
    6085};
    6186
    … …  
    7398   * Always returns true for any Atom
    7499   */
    75   virtual bool predicate(std::pair<atomId_t,atom*>);
     100  virtual bool predicate(std::pair<atomId_t, const atom*>) const;
    76101};
    77102
    … …  
    88113   * Always returns false for any Atom
    89114   */
    90   virtual bool predicate(std::pair<atomId_t,atom*>);
     115  virtual bool predicate(std::pair<atomId_t,const atom*>)const;
    91116};
    92117
    … …  
    106131   * second Descriptor to decide if an Atom should be selected.
    107132   */
    108   virtual bool predicate(std::pair<atomId_t,atom*>);
     133  virtual bool predicate(std::pair<atomId_t,const atom*>) const;
    109134
    110135private:
    … …  
    126151   * second Descriptor to decide if an Atom should be selected.
    127152   */
    128   virtual bool predicate(std::pair<atomId_t,atom*>);
     153  virtual bool predicate(std::pair<atomId_t,const atom*>) const;
    129154
    130155private:
    … …  
    145170   * Opposite of the given descriptor predicate.
    146171   */
    147   virtual bool predicate(std::pair<atomId_t,atom*>);
     172  virtual bool predicate(std::pair<atomId_t,const atom*>) const;
    148173
    149174private:

  • src/Descriptors/AtomIdDescriptor.cpp

    r97445f r795c0f  
    5151{}
    5252
    53 bool AtomIdDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom) {
     53bool AtomIdDescriptor_impl::predicate(std::pair<atomId_t,const atom*> atom) const {
    5454  return atom.first==id;
    5555}
    … …  
    6565}
    6666
     67const atom *AtomIdDescriptor_impl::find() const {
     68  const World::AtomSet &atoms = getAtoms();
     69  World::AtomSet::const_iterator res = atoms.find(id);
     70  return (res!=atoms.end())?((*res).second):0;
     71}
     72
    6773vector<atom*> AtomIdDescriptor_impl::findAll(){
    6874  atom *res = find();
    6975  return (res)?(vector<atom*>(1,res)):(vector<atom*>());
    7076}
     77
     78vector<const atom*> AtomIdDescriptor_impl::findAll() const {
     79  const atom *res = find();
     80  return (res)?(vector<const atom*>(1,res)):(vector<const atom*>());
     81}

  • src/Descriptors/AtomIdDescriptor_impl.hpp

    r97445f r795c0f  
    1616  virtual ~AtomIdDescriptor_impl();
    1717
    18   bool predicate(std::pair<atomId_t,atom*> atom);
     18  bool predicate(std::pair<atomId_t,const atom*> atom) const;
    1919
    2020protected:
    2121  virtual atom *find();
     22  virtual const atom *find() const;
    2223  virtual std::vector<atom*> findAll();
     24  virtual std::vector<const atom*> findAll() const;
    2325private:
    2426  atomId_t id;

  • src/Descriptors/AtomOfMoleculeDescriptor.cpp

    r97445f r795c0f  
    5252{}
    5353
    54 bool AtomOfMoleculeDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom)
     54bool AtomOfMoleculeDescriptor_impl::predicate(std::pair<atomId_t,const atom*> atom) const
    5555{
    5656  if (atom.second->getMolecule() == NULL)

  • src/Descriptors/AtomOfMoleculeDescriptor_impl.hpp

    r97445f r795c0f  
    1616  virtual ~AtomOfMoleculeDescriptor_impl();
    1717
    18   bool predicate(std::pair<atomId_t,atom*> atom);
     18  bool predicate(std::pair<atomId_t,const atom*> atom) const;
    1919
    2020private:

  • src/Descriptors/AtomOfMoleculeSelectionDescriptor.cpp

    r97445f r795c0f  
    4747AtomOfMoleculeSelectionDescriptor_impl::~AtomOfMoleculeSelectionDescriptor_impl(){}
    4848
    49 bool AtomOfMoleculeSelectionDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom){
     49bool AtomOfMoleculeSelectionDescriptor_impl::predicate(std::pair<atomId_t,const atom*> atom) const{
    5050  return World::getInstance().isSelected(atom.second->getMolecule());
    5151}
    … …  
    5555  for (World::MoleculeSet::internal_iterator iter = set.begin_internal();
    5656      iter != set.end_internal();
     57      ++iter) {
     58    if (iter->second->begin() != iter->second->end())
     59      return *(iter->second->begin());
     60  }
     61  return 0;
     62}
     63
     64const atom* AtomOfMoleculeSelectionDescriptor_impl::find() const {
     65  const World::MoleculeSet &set = getSelectedMolecules();
     66  for (World::MoleculeSet::const_iterator iter = set.begin();
     67      iter != set.end();
    5768      ++iter) {
    5869    if (iter->second->begin() != iter->second->end())
    … …  
    7384}
    7485
     86std::vector<const atom*> AtomOfMoleculeSelectionDescriptor_impl::findAll() const{
     87  std::vector<const atom*> res;
     88  const World::MoleculeSet &set = getSelectedMolecules();
     89  for (World::MoleculeSet::const_iterator iter = set.begin();
     90      iter != set.end();
     91      ++iter) {
     92    std::copy(iter->second->begin(), iter->second->end(), res.begin());
     93  }
     94  return res;
     95}
     96
    7597World::MoleculeSet& AtomOfMoleculeSelectionDescriptor_impl::getSelectedMolecules(){
     98  return World::getInstance().selectedMolecules;
     99}
     100
     101const World::MoleculeSet& AtomOfMoleculeSelectionDescriptor_impl::getSelectedMolecules() const{
    76102  return World::getInstance().selectedMolecules;
    77103}

  • src/Descriptors/AtomOfMoleculeSelectionDescriptor_impl.hpp

    r97445f r795c0f  
    2121  AtomOfMoleculeSelectionDescriptor_impl();
    2222  virtual ~AtomOfMoleculeSelectionDescriptor_impl();
    23   bool predicate(std::pair<atomId_t,atom*> atom);
     23  bool predicate(std::pair<atomId_t,const atom*> atom) const;
    2424protected:
    2525  // need to overide more than the standard methods to make this fast
    26   virtual atom* find();
     26  virtual atom *find();
     27  virtual const atom *find() const;
    2728  virtual std::vector<atom*> findAll();
     29  virtual std::vector<const atom*> findAll() const;
    2830
    2931  World::MoleculeSet& getSelectedMolecules();
     32  const World::MoleculeSet& getSelectedMolecules() const;
    3033};
    3134

  • src/Descriptors/AtomOrderDescriptor.cpp

    r97445f r795c0f  
    5151{}
    5252
    53 bool AtomOrderDescriptor_impl::predicate(std::pair<atomId_t,atom*> _atom)
     53bool AtomOrderDescriptor_impl::predicate(std::pair<atomId_t,const atom*> _atom) const
    5454{
    55   atom *Walker = find();
     55  const atom *Walker = find();
    5656  return (Walker == _atom.second);
    5757}
    … …  
    6666}
    6767
     68const World::AtomSet& AtomOrderDescriptor_impl::getAtoms() const
     69{
     70  return const_cast<const World &>(World::getInstance()).atoms;
     71}
    6872
    6973atom *AtomOrderDescriptor_impl::find(){
    … …  
    97101}
    98102
     103const atom *AtomOrderDescriptor_impl::find() const {
     104  const World::AtomSet &atoms = getAtoms();
     105
     106  int i=0;
     107  const atom *_atom = NULL;
     108  if (id == 0) {
     109    return NULL;
     110  } else if (id > 0) {
     111    World::AtomSet::const_iterator res = atoms.begin();
     112    for (; res != atoms.end(); ++res) { // when iterator is normal, ++ goes forward!
     113      ++i;
     114      if (id == i) {
     115        _atom = res->second;
     116        break;
     117      }
     118    }
     119  } else {
     120    World::AtomSet::const_reverse_iterator res = atoms.rbegin();
     121    for (; res != atoms.rend(); ++res) {  // when iterator is reverse, ++ goes backward!
     122      --i;
     123      if (id == i) {
     124        _atom = res->second;
     125        break;
     126      }
     127    }
     128  }
     129
     130  return _atom;
     131}
     132
    99133vector<atom*> AtomOrderDescriptor_impl::findAll(){
    100134  atom *res = find();
    101135  return (res)?(vector<atom*>(1,res)):(vector<atom*>());
    102136}
     137
     138vector<const atom*> AtomOrderDescriptor_impl::findAll() const {
     139  const atom *res = find();
     140  return (res)?(vector<const atom*>(1,res)):(vector<const atom*>());
     141}

  • src/Descriptors/AtomOrderDescriptor_impl.hpp

    r97445f r795c0f  
    1616  virtual ~AtomOrderDescriptor_impl();
    1717
    18   bool predicate(std::pair<atomId_t,atom*> atom);
     18  bool predicate(std::pair<atomId_t,const atom*> atom) const;
    1919
    2020protected:
    2121  virtual atom *find();
     22  virtual const atom *find() const;
    2223  virtual std::vector<atom*> findAll();
     24  virtual std::vector<const atom*> findAll() const;
    2325
    2426  World::AtomSet& getAtoms();
     27  const World::AtomSet& getAtoms() const;
    2528
    2629private:

  • src/Descriptors/AtomSelectionDescriptor.cpp

    r97445f r795c0f  
    4444AtomSelectionDescriptor_impl::~AtomSelectionDescriptor_impl(){}
    4545
    46 bool AtomSelectionDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom){
     46bool AtomSelectionDescriptor_impl::predicate(std::pair<atomId_t,const atom*> atom) const{
    4747  return getSelectedAtoms().count(atom.first);
    4848}
    … …  
    5252  World::AtomSet::internal_iterator begin = set.begin_internal();
    5353  return (begin!=set.end_internal())?(begin->second):0;
     54}
     55
     56const atom* AtomSelectionDescriptor_impl::find() const {
     57  const World::AtomSet &set = getSelectedAtoms();
     58  const World::AtomSet::const_iterator begin = set.begin();
     59  return (begin!=set.end())?(begin->second):0;
    5460}
    5561
    … …  
    6470}
    6571
     72std::vector<const atom*> AtomSelectionDescriptor_impl::findAll() const {
     73  std::vector<const atom*> res;
     74  const World::AtomSet &set = getSelectedAtoms();
     75  transform(set.begin(),
     76           set.end(),
     77           back_inserter(res),
     78           _take<atom*,World::AtomSet::value_type>::get);
     79  return res;
     80}
     81
    6682World::AtomSet& AtomSelectionDescriptor_impl::getSelectedAtoms(){
     83  return World::getInstance().selectedAtoms;
     84}
     85
     86const World::AtomSet& AtomSelectionDescriptor_impl::getSelectedAtoms() const{
    6787  return World::getInstance().selectedAtoms;
    6888}

  • src/Descriptors/AtomSelectionDescriptor_impl.hpp

    r97445f r795c0f  
    2121  AtomSelectionDescriptor_impl();
    2222  virtual ~AtomSelectionDescriptor_impl();
    23   bool predicate(std::pair<atomId_t,atom*> atom);
     23  bool predicate(std::pair<atomId_t,const atom*> atom) const;
    2424protected:
    2525  // need to overide more than the standard methods to make this fast
    26   virtual atom* find();
     26  virtual atom *find();
     27  virtual const atom *find() const;
    2728  virtual std::vector<atom*> findAll();
     29  virtual std::vector<const atom*> findAll() const;
    2830
    2931  World::AtomSet& getSelectedAtoms();
     32  const World::AtomSet& getSelectedAtoms() const;
    3033};
    3134

  • src/Descriptors/AtomShapeDescriptor.cpp

    r97445f r795c0f  
    4646AtomShapeDescriptor_impl::~AtomShapeDescriptor_impl(){}
    4747
    48 bool AtomShapeDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom){
     48bool AtomShapeDescriptor_impl::predicate(std::pair<atomId_t,const atom*> atom) const{
    4949  return shape.isInside(atom.second->getPosition());
    5050}
    … …  
    5555  for (LinkedCell::LinkedList::iterator iter = list.begin(); iter != list.end(); ++iter) {
    5656    atom * const _atom = static_cast<atom *>(const_cast<TesselPoint *>(*iter));
     57    if (shape.isInside(_atom->getPosition()))
     58      return _atom;
     59  }
     60  return NULL;
     61}
     62
     63const atom* AtomShapeDescriptor_impl::find() const {
     64  LinkedCell::LinkedCell_View view = World::getInstance().getLinkedCell(shape.getRadius());
     65  LinkedCell::LinkedList list = view.getPointsInsideSphere(shape.getRadius(), shape.getCenter());
     66  for (LinkedCell::LinkedList::const_iterator iter = list.begin(); iter != list.end(); ++iter) {
     67    const atom * const _atom = static_cast<const atom *>(*iter);
    5768    if (shape.isInside(_atom->getPosition()))
    5869      return _atom;
    … …  
    7384}
    7485
     86std::vector<const atom*> AtomShapeDescriptor_impl::findAll() const{
     87  LinkedCell::LinkedCell_View view = World::getInstance().getLinkedCell(shape.getRadius());
     88  LinkedCell::LinkedList list = view.getPointsInsideSphere(shape.getRadius(), shape.getCenter());
     89  std::vector<const atom*> res;
     90  for (LinkedCell::LinkedList::const_iterator iter = list.begin(); iter != list.end(); ++iter) {
     91    const atom * const _atom = static_cast<const atom *>(*iter);
     92    if (shape.isInside(_atom->getPosition()))
     93      res.push_back(_atom);
     94  }
     95  return res;
     96}
    7597
    7698AtomDescriptor AtomsByShape(const Shape &shape){

  • src/Descriptors/AtomShapeDescriptor_impl.hpp

    r97445f r795c0f  
    2525  virtual  ~AtomShapeDescriptor_impl();
    2626
    27   bool predicate(std::pair<atomId_t,atom*> atom);
     27  bool predicate(std::pair<atomId_t,const atom*> atom) const;
    2828private:
    29   virtual atom* find();
     29  virtual atom *find();
     30  virtual const atom *find() const;
    3031  virtual std::vector<atom*> findAll();
     32  virtual std::vector<const atom*> findAll() const;
    3133
    3234  Shape shape;

  • src/Descriptors/AtomTypeDescriptor.cpp

    r97445f r795c0f  
    4949{}
    5050
    51 bool AtomTypeDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom) {
     51bool AtomTypeDescriptor_impl::predicate(std::pair<atomId_t,const atom*> atom) const {
    5252  return (atom.second->getType()==type);
    5353}

  • src/Descriptors/AtomTypeDescriptor_impl.hpp

    r97445f r795c0f  
    2323  virtual ~AtomTypeDescriptor_impl();
    2424
    25   bool predicate(std::pair<atomId_t,atom*> atom);
     25  bool predicate(std::pair<atomId_t,const atom*> atom) const;
    2626private:
    2727  const element * const type;

  • src/Descriptors/AtomsWithinDistanceOfDescriptor.cpp

    r97445f r795c0f  
    5454{}
    5555
    56 bool AtomsWithinDistanceOfDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom)
     56bool AtomsWithinDistanceOfDescriptor_impl::predicate(std::pair<atomId_t,const atom*> atom) const
    5757{
    5858  return ((atom.second->getPosition().DistanceSquared(position) - distanceSquared) <= 0);
    … …  
    6363  LinkedCell::LinkedList list = view.getPointsInsideSphere(distance, position);
    6464  return (list.begin()!=list.end())? static_cast<atom *>(const_cast<TesselPoint *>(*list.begin())):0;
     65}
     66
     67const atom* AtomsWithinDistanceOfDescriptor_impl::find() const{
     68  LinkedCell::LinkedCell_View view = World::getInstance().getLinkedCell(distance);
     69  LinkedCell::LinkedList list = view.getPointsInsideSphere(distance, position);
     70  return (list.begin()!=list.end())? static_cast<const atom *>(*list.begin()):0;
    6571}
    6672
    … …  
    7480}
    7581
     82std::vector<const atom*> AtomsWithinDistanceOfDescriptor_impl::findAll() const {
     83  LinkedCell::LinkedCell_View view = World::getInstance().getLinkedCell(distance);
     84  LinkedCell::LinkedList list = view.getPointsInsideSphere(distance, position);
     85  std::vector<const atom*> res;
     86  for (LinkedCell::LinkedList::iterator iter = list.begin(); iter != list.end(); ++iter)
     87    res.push_back(static_cast<const atom *>(*iter));
     88  return res;
     89}
     90
    7691AtomDescriptor AtomsWithinDistanceOf(const double distance, const Vector &position)
    7792{

  • src/Descriptors/AtomsWithinDistanceOfDescriptor_impl.hpp

    r97445f r795c0f  
    1717  virtual ~AtomsWithinDistanceOfDescriptor_impl();
    1818
    19   bool predicate(std::pair<atomId_t,atom*> atom);
     19  bool predicate(std::pair<atomId_t,const atom*> atom) const;
    2020
    2121protected:
    2222  // need to overide more than the standard methods to make this fast
    23   virtual atom* find();
     23  virtual atom *find();
     24  virtual const atom *find() const;
    2425  virtual std::vector<atom*> findAll();
     26  virtual std::vector<const atom*> findAll() const;
    2527
    2628private:

  • src/Descriptors/DescriptorBase.hpp

    r97445f r795c0f  
    5151public:
    5252  typedef _Target     Target;
     53  typedef const _Target     ConstTarget;
    5354  typedef std::vector<Target> TargetVec;
     55  typedef std::vector<ConstTarget> ConstTargetVec;
    5456
    5557protected:
    … …  
    7880   * forward Method to implementation
    7981   */
     82  ConstTarget find(Container&) const;
     83
     84  /**
     85   * forward Method to implementation
     86   */
    8087  TargetVec findAll(Container&);
    8188
     89  /**
     90   * forward Method to implementation
     91   */
     92  ConstTargetVec findAll(Container&) const;
    8293
    8394private:

  • src/Descriptors/DescriptorBase_impl.hpp

    r97445f r795c0f  
    2424public:
    2525  typedef _Target Target;
     26  typedef const _Target ConstTarget;
    2627  typedef std::vector<Target> TargetVec;
     28  typedef std::vector<ConstTarget> ConstTargetVec;
    2729  typedef _Container Container;
    2830  typedef typename Container::value_type value_type;
     31  typedef const typename Container::value_type const_value_type;
    2932  typedef typename Container::iterator iterator;
     33  typedef typename Container::const_iterator const_iterator;
    3034
    3135  DescriptorBase_impl();
    32   ~DescriptorBase_impl();
     36  virtual ~DescriptorBase_impl();
    3337
    3438  virtual bool predicate(value_type)=0;
    3539
    3640  virtual Target    find(Container&);
     41  virtual ConstTarget    find(Container&) const;
    3742  virtual TargetVec findAll(Container&);
     43  virtual ConstTargetVec findAll(Container&) const;
    3844protected:
    3945  const _take<Target,value_type> take;
    … …  
    5662                           boost::bind(&DescriptorBase_impl<_Target,_Container>::predicate,this,_1));
    5763    return (res!=container.end())?(take(*res)):0;
    58   }
     64}
     65
     66template<class _Target,
     67         class _Container>
     68typename DescriptorBase_impl<_Target,_Container>::ConstTarget
     69  DescriptorBase_impl<_Target,_Container>::find(DescriptorBase_impl<_Target,_Container>::Container& container) const{
     70    const_iterator res = find_if(container.begin(),
     71                           container.end(),
     72                           boost::bind(&DescriptorBase_impl<_Target,_Container>::predicate,this,_1));
     73    return (res!=container.end())?(take(*res)):0;
     74}
    5975
    6076template<class _Target,
    … …  
    7288}
    7389
     90template<class _Target,
     91         class _Container>
     92typename DescriptorBase_impl<_Target,_Container>::ConstTargetVec
     93  DescriptorBase_impl<_Target,_Container>::findAll(DescriptorBase_impl<_Target,_Container>::Container& container) const {
     94  ConstTargetVec res;
     95  const_iterator iter;
     96  for(iter=container.begin();iter!=container.end();++iter) {
     97    if(predicate(*iter)){
     98      res.push_back(take(*iter));
     99    }
     100  }
     101  return res;
     102}
     103
    74104#endif /* DESCRIPTORBASE_IMPL_HPP_ */

  • src/World.cpp

    r97445f r795c0f  
    127127}
    128128
     129const atom* World::getAtom(AtomDescriptor descriptor) const{
     130  return const_cast<const AtomDescriptor &>(descriptor).find();
     131}
     132
    129133World::AtomComposite World::getAllAtoms(AtomDescriptor descriptor){
    130134  return descriptor.findAll();
    131135}
    132136
     137World::ConstAtomComposite World::getAllAtoms(AtomDescriptor descriptor) const {
     138  return const_cast<const AtomDescriptor &>(descriptor).findAll();
     139}
     140
    133141World::AtomComposite World::getAllAtoms(){
    134142  return getAllAtoms(AllAtoms());
    135143}
    136144
    137 int World::numAtoms(){
     145World::ConstAtomComposite World::getAllAtoms() const {
     146  return getAllAtoms(AllAtoms());
     147}
     148
     149int World::numAtoms() const {
    138150  return atoms.size();
    139151}

  • src/World.hpp

    r97445f r795c0f  
    109109
    110110  typedef ATOMSET(std::vector) AtomComposite;
     111  typedef CONSTATOMSET(std::vector) ConstAtomComposite;
    111112
    112113    /******* Notifications *******/
    … …  
    176177
    177178  /**
     179   * returns the first atom that matches a given descriptor.
     180   * Do not rely on ordering for descriptors that match more than one atom.
     181   */
     182  const atom* getAtom(AtomDescriptor descriptor) const;
     183
     184  /**
    178185   * returns a vector containing all atoms that match a given descriptor
    179186   */
    180187  AtomComposite getAllAtoms(AtomDescriptor descriptor);
     188
     189  /**
     190   * returns a vector containing all atoms that match a given descriptor
     191   */
     192  ConstAtomComposite getAllAtoms(AtomDescriptor descriptor) const;
     193
     194  /**
     195   * returns a vector containing all atoms that match a given descriptor
     196   */
    181197  AtomComposite getAllAtoms();
     198
     199  /**
     200   * returns a vector containing all atoms that match a given descriptor
     201   */
     202  ConstAtomComposite getAllAtoms() const;
    182203
    183204  /**
    … …  
    192213   * get the number of atoms in the World
    193214   */
    194   int numAtoms();
     215  int numAtoms() const;
    195216
    196217  /**
Note: See TracChangeset for help on using the changeset viewer.