molecule.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) 2001, Eric Alm <ealm3141@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_MOLECULE_H
#define BTK_MOLECULE_H


#include "atom_container.h"

#include <iosfwd>
#include <string>
#include <vector>


namespace BTK {


  // user typedefs
  template <typename AtomType> class Molecule;
  typedef Molecule<Atom> basic_molecule;


template <typename AtomType>
class Molecule : public AtomContainer<AtomType> {
  typedef AtomContainer<AtomType> base_type;
 public:
  typedef Molecule<AtomType> self_type;


  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 atom_type;
  typedef iterator atom_iterator;
  typedef const_iterator const_atom_iterator;


  Molecule(size_type s = 0)
    : base_type(s), _chain_id('A'), _name(""){}

  template <typename AtomIterator>
  Molecule(AtomIterator first,
           AtomIterator last) 
    : base_type(first,last), _chain_id('A'), _name("") {}

  Molecule(const self_type& source) 
    : base_type(source), _chain_id(source._chain_id), _name(source._name) {}

  template <typename T2>
  Molecule(const Molecule<T2>& source) 
    : base_type(source), _chain_id(source.chain_id()), _name(source.name()) {}
  
  ~Molecule() {}

  self_type& operator=(const self_type& rhs);

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


  // update atomgroup interface
  virtual GROUP::index_t group_index() const { return GROUP::MOLECULE; }


  const std::string& name() const { return _name; }
  void set_name(const std::string& name) { _name = name; }

  char chain_id() const { return _chain_id; } 
  void set_chain_id(char chain_id) { _chain_id = chain_id; }

  // molecule is not a combined container class (like polymer), so it's safe to
  // pull protected members public
  using base_type::clear;
  using base_type::erase;
  using base_type::push_back;
  using base_type::insert;
  using base_type::shallow_push_back;
  using base_type::shallow_insert;
  using base_type::shallow_copy;
        
private:
  char _chain_id;
  std::string _name;
};

} // namespace BTK

template <typename AtomType>
std::ostream& operator<<(std::ostream& os,
                         const BTK::Molecule<AtomType>& m);

#include "molecule.hpp"

#endif

---