atom_container.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_ATOM_CONTAINER_H
#define BTK_ATOM_CONTAINER_H

#include "atom.h"
#include "atom_group_concept.h"
#include "group_types.h"
#include "shared_vector_base.h"

#include <boost/concept_check.hpp>

namespace BTK {

template <typename AtomType> 
class AtomContainer : public SharedVectorBase<AtomType>, public AtomGroupConcept {
  BOOST_CLASS_REQUIRE2( AtomType, Atom, boost, ConvertibleConcept);

  typedef SharedVectorBase<AtomType> base_type;
  typedef AtomGroupConcept group_concept_type;
  typedef AtomContainer<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;


  AtomContainer(size_type s = 0) : base_type(s), group_concept_type() {}

  template <typename AtomIterator>
  AtomContainer(AtomIterator first,
                AtomIterator last) 
    : base_type(first,last), 
      group_concept_type() 
  {
    set_group();
  }

  AtomContainer(const self_type& source) 
    : base_type(source), 
      group_concept_type() 
  {
    set_group();
  }

  template <typename T2>
  AtomContainer(const AtomContainer<T2>& source) 
    : base_type(source), 
      group_concept_type() 
  {
    set_group();
  }

  ~AtomContainer() {} 


  self_type& 
  operator=(const self_type& rhs) 
  {
    if (&rhs == this) return *this;
    base_type::operator=(rhs);
    set_group();
    return *this;
  }

  template <typename T2>
  self_type& 
  operator=(const AtomContainer<T2>& rhs) 
  {
    base_type::operator=(rhs);
    set_group();
    return *this;
  }

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

  virtual 
  const AtomGroupConcept::group_variant_container_t& 
  group_variant_codes() const 
  {
    static AtomGroupConcept::group_variant_container_t s;
    return s;
  }
  
  virtual 
  const std::string& 
  group_name3() const 
  {
    static std::string s("XXX");
    return s;
  }

  virtual int group_num() const { return 0; }




  size_type atom_size() const { return this->size(); }
  
  atom_iterator atom_begin() { return this->begin(); }
  const_atom_iterator atom_begin() const { return this->begin(); }
  
  atom_iterator atom_end() { return this->end(); }
  const_atom_iterator atom_end() const { return this->end(); }

  reference atom(size_type i) { return this->operator[](i); }
  const_reference atom(size_type i) const { return this->operator[](i); }

  reference atom_back() { return this->back(); }
  const_reference atom_back() const { return this->back(); }

  reference atom_front() { return this->front(); }
  const_reference atom_front() const { return this->front(); }

private:
  void 
  set_group()
  {
    iterator i=begin(),i_end=end();
    for(;i!=i_end;++i) i->set_group(*this);
  }
};

} // namespace BTK


#endif 

---