source: src/Descriptors/AtomDescriptor.cpp@ d1c5e2

/*
 * AtomDescriptor.cpp
 *
 *  Created on: Feb 5, 2010
 *      Author: crueger
 */

#include "AtomDescriptor.hpp"

#include "World.hpp"

#include <boost/bind.hpp>
#include <cassert>

using namespace std;

typedef map<int,atom*> atoms_t;
typedef atoms_t::iterator atoms_iter_t;

AtomDescriptor::AtomDescriptor()
{
}

AtomDescriptor::AtomDescriptor(const AtomDescriptor &desc) {
}

AtomDescriptor::~AtomDescriptor()
{
}


atoms_t& AtomDescriptor::getAtoms(){
  return World::get()->atoms;
}

atom* AtomDescriptor::find() {
  atoms_t atoms = getAtoms();
  atoms_iter_t res = find_if(atoms.begin(),atoms.end(),boost::bind(&AtomDescriptor::predicate,this,_1));
  return (res!=atoms.end())?((*res).second):0;
}

vector<atom*> AtomDescriptor::findAll() {
  vector<atom*> res;
  atoms_t atoms = getAtoms();
  atoms_iter_t iter;
  for(iter=atoms.begin();iter!=atoms.end();++iter) {
    if(predicate(*iter))
      res.push_back((*iter).second);
  }
}

// stuff for operators

// AND
AtomAndDescriptor::AtomAndDescriptor(const AtomDescriptor &_lhs,const AtomDescriptor &_rhs){
  lhs=_lhs.clone();
  rhs=_rhs.clone();
}

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::~AtomAndDescriptor(){
}

bool AtomAndDescriptor::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);
}

// OR

AtomOrDescriptor::AtomOrDescriptor(const AtomDescriptor &_lhs,const AtomDescriptor &_rhs){
  lhs=_lhs.clone();
  rhs=_rhs.clone();
}

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){
  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);
}

// NOT

AtomNotDescriptor::AtomNotDescriptor(const AtomDescriptor &_arg){
  arg = _arg.clone();
}

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()
{
}

bool AtomNotDescriptor::predicate(std::pair<int,atom*> atom){
 return !(arg->predicate(atom));
}

AtomAndDescriptor::desc_ptr AtomNotDescriptor::clone() const{
  return desc_ptr(new AtomNotDescriptor(*arg));
}

AtomNotDescriptor operator!(const AtomDescriptor &arg){
  return AtomNotDescriptor(arg);
}