Changeset 323177 for molecuilder/src/Descriptors/AtomDescriptor.cpp

Timestamp:

Feb 16, 2010, 4:24:07 PM (16 years ago)

Author:

Tillmann Crueger <crueger@…>

Children:

120f8b

Parents:

973c03

Message:

Rebuilt AtomDescriptors using PIMPL-Idiom and added unittest for descriptors

File:

• molecuilder/src/Descriptors/AtomDescriptor.cpp (modified) (2 diffs)

molecuilder/src/Descriptors/AtomDescriptor.cpp

@@ -6 +6 @@
  */
 
-#include "AtomDescriptor.hpp"
+#include "Descriptors/AtomDescriptor.hpp"
+#include "Descriptors/AtomDescriptor_impl.hpp"
 
 #include "World.hpp"
 
+#include "atom.hpp"
+
 #include <boost/bind.hpp>
 #include <cassert>
+#include <iostream>
 
 using namespace std;
@@ -18 +22 @@
 typedef atoms_t::iterator atoms_iter_t;
 
-AtomDescriptor::AtomDescriptor()
+/************************ Forwarding object **************************************/
+
+
+AtomDescriptor::AtomDescriptor(impl_ptr _impl) :
+    impl(_impl)
+{}
+
+AtomDescriptor::AtomDescriptor(const AtomDescriptor& src) :
+    impl(src.get_impl())
+{}
+
+AtomDescriptor::~AtomDescriptor()
+{}
+
+AtomDescriptor& AtomDescriptor::operator=(AtomDescriptor &src){
+  if(&src!=this) {
+    impl=src.get_impl();
+  }
+  return *this;
+}
+
+atom* AtomDescriptor::find(){
+  return impl->find();
+}
+
+std::vector<atom*> AtomDescriptor::findAll(){
+  return impl->findAll();
+}
+
+AtomDescriptor::impl_ptr AtomDescriptor::get_impl() const{
+  return impl;
+}
+
+
+
+
+/**************************** implementation ********************/
+
+AtomDescriptor_impl::AtomDescriptor_impl()
 {
 }
 
-AtomDescriptor::AtomDescriptor(const AtomDescriptor &desc) {
-}
-
-AtomDescriptor::~AtomDescriptor()
+AtomDescriptor_impl::~AtomDescriptor_impl()
 {
 }
 
-
-atoms_t& AtomDescriptor::getAtoms(){
+atoms_t& AtomDescriptor_impl::getAtoms(){
   return World::get()->atoms;
 }
 
-atom* AtomDescriptor::find() {
+atom* AtomDescriptor_impl::find() {
   atoms_t atoms = getAtoms();
-  atoms_iter_t res = find_if(atoms.begin(),atoms.end(),boost::bind(&AtomDescriptor::predicate,this,_1));
+  atoms_iter_t res = find_if(atoms.begin(),atoms.end(),boost::bind(&AtomDescriptor_impl::predicate,this,_1));
   return (res!=atoms.end())?((*res).second):0;
 }
 
-vector<atom*> AtomDescriptor::findAll() {
+vector<atom*> AtomDescriptor_impl::findAll() {
   vector<atom*> res;
   atoms_t atoms = getAtoms();
   atoms_iter_t iter;
   for(iter=atoms.begin();iter!=atoms.end();++iter) {
-    if(predicate(*iter))
+    if(predicate(*iter)){
       res.push_back((*iter).second);
+    }
   }
+  return res;
 }
 
-// stuff for operators
+/************************** Universe and Emptyset *****************/
+
+AtomAllDescriptor_impl::AtomAllDescriptor_impl()
+{}
+
+AtomAllDescriptor_impl::~AtomAllDescriptor_impl()
+{}
+
+bool AtomAllDescriptor_impl::predicate(std::pair<int,atom*>){
+  return true;
+}
+
+AtomDescriptor AllAtoms(){
+  return AtomDescriptor(AtomDescriptor::impl_ptr(new AtomAllDescriptor_impl));
+}
+
+AtomNoneDescriptor_impl::AtomNoneDescriptor_impl()
+{}
+
+AtomNoneDescriptor_impl::~AtomNoneDescriptor_impl()
+{}
+
+bool AtomNoneDescriptor_impl::predicate(std::pair<int,atom*>){
+  return false;
+}
+
+AtomDescriptor NoAtoms(){
+  return AtomDescriptor(AtomDescriptor::impl_ptr(new AtomNoneDescriptor_impl));
+}
+
+/************************** Operator stuff ************************/
 
 // AND
-AtomAndDescriptor::AtomAndDescriptor(const AtomDescriptor &_lhs,const AtomDescriptor &_rhs){
-  lhs=_lhs.clone();
-  rhs=_rhs.clone();
-}
+AtomAndDescriptor_impl::AtomAndDescriptor_impl(AtomDescriptor::impl_ptr _lhs, AtomDescriptor::impl_ptr _rhs) :
+    lhs(_lhs), rhs(_rhs)
+{}
 
-AtomAndDescriptor::AtomAndDescriptor(const AtomAndDescriptor &_desc)
-{
-  // the copy constructor needs it's parameter as const to work,
-  // however we need to be able to transfer the ownership of the pointers
-  // to the new method to avoid another cloning.
-  //
-  // the only place where the copy constructor is used for these classes,
-  // is when returning a temporary.
-  // this is one of the very rare cases when const_cast makes sense
-  AtomAndDescriptor &desc = const_cast<AtomAndDescriptor&>(_desc);
-  lhs = desc.lhs;
-  rhs = desc.rhs;
-}
+AtomAndDescriptor_impl::~AtomAndDescriptor_impl()
+{}
 
-AtomAndDescriptor::~AtomAndDescriptor(){
-}
-
-bool AtomAndDescriptor::predicate(std::pair<int,atom*> atom){
+bool AtomAndDescriptor_impl::predicate(std::pair<int,atom*> atom){
   return lhs->predicate(atom) && rhs->predicate(atom);
 }
-
-AtomAndDescriptor::desc_ptr AtomAndDescriptor::clone() const{
-  return desc_ptr(new AtomAndDescriptor(*lhs,*rhs));
-}
-
-AtomAndDescriptor operator&&(const AtomDescriptor &lhs, const AtomDescriptor &rhs){
-  return AtomAndDescriptor(lhs,rhs);
+AtomDescriptor operator&&(const AtomDescriptor &lhs, const AtomDescriptor &rhs){
+  AtomDescriptor::impl_ptr newImpl = AtomDescriptor::impl_ptr(new AtomAndDescriptor_impl(lhs.get_impl(),rhs.get_impl()));
+  return AtomDescriptor(newImpl);
 }
 
 // OR
+AtomOrDescriptor_impl::AtomOrDescriptor_impl(AtomDescriptor::impl_ptr _lhs ,AtomDescriptor::impl_ptr _rhs) :
+    lhs(_lhs), rhs(_rhs)
+{}
 
-AtomOrDescriptor::AtomOrDescriptor(const AtomDescriptor &_lhs,const AtomDescriptor &_rhs){
-  lhs=_lhs.clone();
-  rhs=_rhs.clone();
+AtomOrDescriptor_impl::~AtomOrDescriptor_impl(){
 }
 
-AtomOrDescriptor::AtomOrDescriptor(const AtomOrDescriptor &_desc)
-{
-  // the copy constructor needs it's parameter as const to work,
-  // however we need to be able to transfer the ownership of the pointers
-  // to the new method to avoid another cloning.
-  //
-  // the only place where the copy constructor is used for these classes,
-  // is when returning a temporary.
-  // this is one of the very rare cases when const_cast makes sense
-  AtomOrDescriptor &desc = const_cast<AtomOrDescriptor&>(_desc);
-  lhs = desc.lhs;
-  rhs = desc.rhs;
-}
-
-AtomOrDescriptor::~AtomOrDescriptor(){
-}
-
-bool AtomOrDescriptor::predicate(std::pair<int,atom*> atom){
+bool AtomOrDescriptor_impl::predicate(std::pair<int,atom*> atom){
   return lhs->predicate(atom) || rhs->predicate(atom);
 }
 
-AtomAndDescriptor::desc_ptr AtomOrDescriptor::clone() const{
-  return desc_ptr(new AtomOrDescriptor(*lhs,*rhs));
-}
-
-AtomOrDescriptor  operator||(const AtomDescriptor &lhs, const AtomDescriptor &rhs){
-  return AtomOrDescriptor(lhs,rhs);
+AtomDescriptor  operator||(const AtomDescriptor &lhs, const AtomDescriptor &rhs){
+  AtomDescriptor::impl_ptr newImpl = AtomDescriptor::impl_ptr(new AtomOrDescriptor_impl(lhs.get_impl(),rhs.get_impl()));
+  return AtomDescriptor(newImpl);
 }
 
 // NOT
 
-AtomNotDescriptor::AtomNotDescriptor(const AtomDescriptor &_arg){
-  arg = _arg.clone();
-}
+AtomNotDescriptor_impl::AtomNotDescriptor_impl(AtomDescriptor::impl_ptr _arg) :
+    arg(_arg)
+{}
 
-AtomNotDescriptor::AtomNotDescriptor(const AtomNotDescriptor &_desc) {
-  // the copy constructor needs it's parameter as const to work,
-  // however we need to be able to transfer the ownership of the pointers
-  // to the new method to avoid another cloning.
-  //
-  // the only place where the copy constructor is used for these classes,
-  // is when returning a temporary.
-  // this is one of the very rare cases when const_cast makes sense
-  AtomNotDescriptor &desc = const_cast<AtomNotDescriptor&>(_desc);
-  arg = desc.arg;
-}
 
-AtomNotDescriptor::~AtomNotDescriptor()
+AtomNotDescriptor_impl::~AtomNotDescriptor_impl()
 {
 }
 
-bool AtomNotDescriptor::predicate(std::pair<int,atom*> atom){
+bool AtomNotDescriptor_impl::predicate(std::pair<int,atom*> atom){
  return !(arg->predicate(atom));
 }
 
-AtomAndDescriptor::desc_ptr AtomNotDescriptor::clone() const{
-  return desc_ptr(new AtomNotDescriptor(*arg));
+AtomDescriptor operator!(const AtomDescriptor &arg){
+  AtomDescriptor::impl_ptr newImpl = AtomDescriptor::impl_ptr(new AtomNotDescriptor_impl(arg.get_impl()));
+  return AtomDescriptor(newImpl);
 }
-
-AtomNotDescriptor operator!(const AtomDescriptor &arg){
-  return AtomNotDescriptor(arg);
-}