polymer.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_POLYMER_H
#define BTK_POLYMER_H

#include "molecule.h"
#include "monomer_container.h"

#include <boost/function.hpp>

#include <iosfwd>
#include <string>

namespace BTK {

  // user typedefs
  template <typename MonomerType> class Polymer;
  typedef Polymer<basic_monomer> basic_polymer;

template <typename MonomerType>  
class Polymer : public MonomerContainer<MonomerType> {
  typedef MonomerContainer<MonomerType> base_type;
  typedef Molecule<typename MonomerType::atom_type> base_molecule_type;
  typedef Polymer<MonomerType> self_type;
public:


  typedef typename base_type::value_type value_type;
  typedef typename base_type::reference reference;
  typedef typename base_type::const_reference const_reference;
  typedef typename base_type::pointer pointer;
  typedef typename base_type::const_pointer const_pointer;
  typedef typename base_type::size_type size_type;
  typedef typename base_type::iterator iterator;
  typedef typename base_type::const_iterator const_iterator;


  typedef value_type monomer_type;
  typedef iterator monomer_iterator;
  typedef const_iterator const_monomer_iterator;
  
  typedef typename base_molecule_type::value_type atom_type;
  typedef typename base_molecule_type::iterator atom_iterator;
  typedef typename base_molecule_type::const_iterator const_atom_iterator;
  typedef typename base_molecule_type::reference atom_reference;
  typedef typename base_molecule_type::const_reference const_atom_reference;

  typedef boost::function<void(atom_iterator,atom_iterator)> build_strategy_t; 


  Polymer(size_type s = 0,
          build_strategy_t build_strategy = 0);
 
  template <typename AtomIterator>
  Polymer(AtomIterator first,
          AtomIterator last,
          build_strategy_t build_strategy = 0);

  Polymer(const self_type& source);  

  template <typename T2>
  Polymer(const Polymer<T2>& source);  

  ~Polymer() {}


  self_type& 
  operator=(const self_type& rhs);

  template <typename T2>
  self_type& 
  operator=(const Polymer<T2>& rhs);

  // pull in part of molecule interface
  //
  const std::string& name() const { return _molecule.name(); }
  void set_name(const std::string& name) { _molecule.set_name(name); }

  char chain_id() const { return _molecule.chain_id(); } 
  void set_chain_id(char chain_id) { _molecule.set_chain_id(chain_id); }

  size_type atom_size() const { return _molecule.atom_size(); }
  
  atom_iterator atom_begin() { return _molecule.atom_begin(); }
  const_atom_iterator atom_begin() const { return _molecule.atom_begin(); }
  
  atom_iterator atom_end() { return _molecule.atom_end(); }
  const_atom_iterator atom_end() const { return _molecule.atom_end(); }

  atom_reference atom(size_type i) { return _molecule.operator[](i); }
  const_atom_reference atom(size_type i) const { return _molecule.operator[](i); }

  atom_reference atom_back() { return _molecule.atom_back(); }
  const_atom_reference atom_back() const { return _molecule.atom_back(); }

  atom_reference atom_front() { return _molecule.atom_front(); }
  const_atom_reference atom_front() const { return _molecule.atom_front(); }



  // exposing protected members of monomer_container or molecule
  // requires a molecule sync until a better system for shallow copy
  // sync can be found
  //
  void monomer_push_back(const monomer_type& m){
    push_back(m);
    sync_molecule_to_monomers();
  }

  build_strategy_t build_strategy() const { return _build_strategy; }

protected:

  template <typename AtomIterator>
  void add_monomer(AtomIterator first,
                   AtomIterator last,
                   const AtomGroupConcept::group_variant_container_t& modifiers);

  template <typename AtomIterator>
  void create_monomers(AtomIterator first,
                       AtomIterator last);

  void sync_molecule_to_monomers();

private:
  base_molecule_type _molecule; 
  build_strategy_t _build_strategy;
};

} // namespace BTK

template <typename MonomerType>
std::ostream& operator<<(std::ostream& os,
                         const BTK::Polymer<MonomerType>& p);


#include "polymer.hpp"

#endif 

---