monomer.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) 2003, Tim Robertson <kid50@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_MONOMER_H
#define BTK_MONOMER_H

#include "atom_container.h"
#include "atom.h"

#include <boost/concept_check.hpp>

#include <string>

namespace BTK {

  // user typedefs
  template <typename AtomType> class Monomer;
  typedef Monomer<Atom> basic_monomer;

template <typename AtomType> 
class Monomer : public AtomContainer<AtomType>{
  typedef AtomContainer<AtomType> base_type;
  typedef Monomer<AtomType> 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 atom_type;
  typedef iterator atom_iterator;
  typedef const_iterator const_atom_iterator;


  Monomer(size_type s = 0) 
    : base_type(s), 
      _group_num(0) {}

  template <typename AtomIterator>
  Monomer(AtomIterator first, 
          AtomIterator last,
          self_type* prev_monomer = 0,
          self_type* next_monomer = 0,
          const AtomGroupConcept::group_variant_container_t& modifiers = group_variant_container_t()) 
    : base_type(first,last), 
      _group_num(first->group_num()), 
      _group_name3(first->group_name3()) 
  {
    // these parameters are actually placeholders -- touch them so they look used
    prev_monomer += 1;
    next_monomer += 1;
    modifiers.size();
  }

  template <typename T2>
  Monomer(const Monomer<T2>& source) 
    : base_type(source), 
      _group_num(source.group_num()), 
      _group_name3(source.group_name3()) {}

  ~Monomer() {}


  template <typename T2>
  self_type& 
  operator=(const Monomer<T2>& rhs) 
  {
    base_type::operator=(rhs);  
    _group_num = rhs.group_num();
    _group_name3 = rhs.group_name3();
    return *this;
  }

  // update atom group interface
  virtual GROUP::index_t group_index() const { return GROUP::MONOMER; }

  virtual int group_num() const { return _group_num; }
  void set_group_num(int x) { _group_num = x; }

  virtual const std::string& group_name3() const { return _group_name3; }


  virtual char group_name1() const { return 'X'; }

private:
  int _group_num;
  std::string _group_name3;
};

} // namespace BTK

#endif

---