shared_vector_base.hpp

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.


#include <boost/concept_check.hpp>

#include <algorithm>
#include <iterator>


template <typename T>
template <typename InputIterator>
BTK::SharedVectorBase<T>::
SharedVectorBase(InputIterator first,
                 InputIterator last){
//  
//  typedef typename std::iterator_traits<InputIterator>::value_type InputT;
//  boost::function_requires<boost::ConvertibleConcept<InputT,value_type> >();
  
  for (;first!=last;++first) { push_back(static_cast<value_type>(*first)); }
}

template <typename T>
void 
BTK::SharedVectorBase<T>::
insert(iterator pos,
       size_type s,
       const value_type& x){
  direct_iterator _pos = pos.base();
  for(;s>0;--s){
    shared_pointer p(new value_type(x));
    _pos = _vector.insert(_pos,p);
    _pos++;
  }
}

template <typename T>
template <typename InputIterator>
void 
BTK::SharedVectorBase<T>::
insert(iterator pos,
       InputIterator first,
       InputIterator last){
  direct_iterator _pos = pos.base();
  while(first != last){
    shared_pointer p(new value_type(*first));
    _pos = _vector.insert(_pos,p);
    ++_pos; ++first;
  }
}

template <typename T>
template <typename T2>
void 
BTK::SharedVectorBase<T>::
deep_copy(const SharedVectorBase<T2>& source) {
  boost::function_requires<boost::ConvertibleConcept<T2,value_type> >();

  clear();
  reserve(source.size());
  typename SharedVectorBase<T2>::const_iterator i=source.begin(),i_end=source.end();
  for(;i!=i_end;++i){
    push_back(*i);
  }
#if 0
  // ctsa:
  // I can't get this code:
  // Polymer<Monomer<Atom> > m;
  // Polymer<Monomer<MonomerAtom> > m2;
  // m = m2;
  // ...to work using std copy, the atom types up-convert just fine in the code above
  std::copy(source.begin(),
      source.end(),
      std::back_insert_iterator<self_type>(*this));
#endif
}

template <typename T>
void 
BTK::SharedVectorBase<T>::
shallow_copy(const self_type& source){
  clear();
  reserve(source.size());
  std::copy(source._vector.begin(),
      source._vector.end(),
      std::back_insert_iterator<container_type>(_vector));
}

---