buildable_atom_decorator.h

Go to the documentation of this file.

// -*- mode: c++; -*-
//
//The Biomolecule Toolkit (BTK) is a C++ library for use in the
//modeling, analysis, and design of biological macromolecules.
//Copyright (C) 2004, Christopher Saunders (ctsa@users.sourceforge.net)
//
//This program is free software; you can redistribute it and/or modify
//it under the terms of the GNU Lesser General Public License as published
//by the Free Software Foundation; either version 2.1 of the License, or (at
//your option) any later version.
//
//This program is distributed in the hope that it will be useful,  but
//WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//Lesser General Public License for more details. 
//
//You should have received a copy of the GNU Lesser General Public License 
//along with this program; if not, write to the Free Software Foundation, 
//Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


#ifndef BTK_BUILDABLE_ATOM_DECORATOR_H
#define BTK_BUILDABLE_ATOM_DECORATOR_H

#include "atom.h"
#include "buildable_atom_group_concept.h"

#include <boost/concept_check.hpp>

#include <map>
#include <set>


namespace BTK {

  template <typename AtomBase>
  class BuildableAtomDecorator : public AtomBase {
    BOOST_CLASS_REQUIRE2(AtomBase,Atom,boost,ConvertibleConcept);
    
    typedef AtomBase base_type;
    typedef BuildableAtomDecorator<AtomBase> self_type;

    typedef std::set<self_type*> adjacent_container_t;
    typedef std::map<self_type*,unsigned> bond_cache_t;
    typedef BuildableAtomGroupConcept buildable_group_t;

  public:
    typedef typename adjacent_container_t::iterator adjacent_iterator;
    typedef typename adjacent_container_t::const_iterator const_adjacent_iterator;

    //
    BuildableAtomDecorator() 
      : base_type(), 
        _adjacent(), 
        _is_built(false), 
        _is_bond_distance_cached(false), 
        _bond_distance_cache(),
        _buildable_group(0){}

    BuildableAtomDecorator(const self_type& source)
      : base_type(source),
        _adjacent(),
        _is_built(source._is_built),
        _is_bond_distance_cached(false),
        _bond_distance_cache(),
        _buildable_group(0) {}

    BuildableAtomDecorator(const base_type& a) 
      : base_type(a), 
        _adjacent(), 
        _is_built(false), 
        _is_bond_distance_cached(false), 
        _bond_distance_cache(),
        _buildable_group(0) {}

    ~BuildableAtomDecorator() {}


    self_type&
    operator=(const self_type& rhs)
    {
      if( &rhs == this ) return *this;
      base_type::operator=(rhs);
      _adjacent.clear();
      _is_built = rhs._is_built;
      _is_bond_distance_cached = false;
      _bond_distance_cache.clear();
      _buildable_group = 0;
      return *this;
    }

    self_type& 
    operator=(const base_type& rhs)
    {
      base_type::operator=(rhs);
      _adjacent.clear();
      _is_built = false;
      _is_bond_distance_cached = false;
      _bond_distance_cache.clear();
      _buildable_group = 0;
      return *this;
    }

    bool is_built() const { return _is_built; }
    void set_is_built(bool i) { this->_is_built = i; }



    bool is_bond_distance_cached() const { return _is_bond_distance_cached; }

    void 
    set_is_bond_distance_cached(bool i) 
    { 
      _is_bond_distance_cached = i;
      if(! _is_bond_distance_cached ) _bond_distance_cache.clear(); 
    }

    unsigned 
    bond_distance_4(self_type& a2)
    {
      typename bond_cache_t::const_iterator cib = _bond_distance_cache.find(&a2);
      if( cib == _bond_distance_cache.end() ) { 
        return 5;
      }else{ 
        return cib->second;
      }
    }

    //
    void 
    set_bond_distance_4(self_type& a2,
                        unsigned dist)
    {
      if (dist >= 5) return;
      _bond_distance_cache[&a2] = dist;
    }

    adjacent_iterator adjacent_begin() { return _adjacent.begin(); }
    adjacent_iterator adjacent_end() { return _adjacent.end(); }

    template <typename AtomType>
    void 
    add_adjacent(AtomType& next_atom)
    {
      if(this==&next_atom) return;

      _adjacent.insert(static_cast<self_type*>(&next_atom));
    }

    bool 
    build() 
    {
      if(_is_built) return true;
      if(_buildable_group) return _buildable_group->build_atom(atom_index(),false);
      else                 return false;
    }

    bool 
    boot_build() 
    {
      if(_is_built) return true;
      if(_buildable_group) return _buildable_group->build_atom(atom_index(),true);
      else                 return false;
    }

    void set_buildable_group(buildable_group_t& g) { _buildable_group = &g; }

  private:
    adjacent_container_t _adjacent;
    bool _is_built;
    bool _is_bond_distance_cached;
    bond_cache_t _bond_distance_cache;
    buildable_group_t* _buildable_group;
  };

} // namespace BTK

#endif

---