shared_vector_base.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_SHARED_VECTOR_BASE_H
#define BTK_SHARED_VECTOR_BASE_H

#include <boost/concept_check.hpp>
#include <boost/iterator/indirect_iterator.hpp>
#include <boost/shared_ptr.hpp>

#include <vector>


namespace BTK {

template <typename T> 
class SharedVectorBase {
  typedef boost::shared_ptr<T> shared_pointer;
  typedef std::vector<shared_pointer> container_type;
  typedef typename container_type::iterator direct_iterator;
  typedef typename container_type::const_iterator const_direct_iterator;

public:
  typedef SharedVectorBase<T> self_type;


  typedef T value_type;
  typedef value_type& reference;
  typedef const reference const_reference;
  typedef value_type* pointer;
  typedef const pointer const_pointer;
  typedef typename container_type::size_type size_type;  
  typedef boost::indirect_iterator<direct_iterator> iterator;
  typedef boost::indirect_iterator<const_direct_iterator> const_iterator;

  SharedVectorBase(size_type s = 0) : _vector() {
    for (;s>0;--s) { push_back(value_type()); }
  }

  template <typename InputIterator>
  SharedVectorBase(InputIterator first, InputIterator last);
  
  SharedVectorBase(const self_type& source) : _vector(){
    deep_copy(source);
  }

  template <typename T2>
  SharedVectorBase(const SharedVectorBase<T2>& source) : _vector(){
    deep_copy(source);
  }

  virtual ~SharedVectorBase() {}

  self_type& operator=(const self_type& rhs) {
    if (&rhs == this) return *this;
    deep_copy(rhs);
    return *this;
  }

  template <typename T2>
  self_type& operator=(const SharedVectorBase<T2>& rhs) {
    deep_copy(rhs);
    return *this;
  }



  size_type size() const { return _vector.size(); }

  iterator begin() { return iterator(_vector.begin()); }
  const_iterator begin() const { return const_iterator(_vector.begin()); } 

  iterator end() { return iterator(_vector.end()); }
  const_iterator end() const { return const_iterator(_vector.end()); }

  reference operator[](size_type i) { return *(begin()+i); }
  const_reference operator[](size_type i) const { return *(end()+i); }

  reference front() { return operator[](0); }
  const_reference front() const { return operator[](0); }
  
  reference back() { return operator[](size()-1); }
  const_reference back() const { return operator[](size()-1); }

protected:


  void clear() { _vector.clear(); }

  void resize(size_type s) {
    if (s < size()) erase(begin()+s, end());
    else insert(end(), s-size(), value_type());
  }

  void reserve(size_type s) { _vector.reserve(s); }

  void push_back(const value_type& x) {
    shared_pointer p(new value_type(x));
    _vector.push_back(p);
  }

  iterator insert(iterator pos,
                  const value_type& x){
    shared_pointer p(new value_type(x));
    return iterator(_vector.insert(pos.base(),p));    
  }

  void insert(iterator pos,
        size_type s,
        const value_type& x);

  template <typename InputIterator>
  void insert(iterator pos,
              InputIterator first,
              InputIterator last);

  iterator erase(iterator pos){
    return iterator(_vector.erase(pos.base()));
  }

  iterator erase(iterator first,
                 iterator last){
    return iterator(_vector.erase(first.base(),last.base()));
  }



  void shallow_push_back(value_type* x) {
    shared_pointer p(x);
    _vector.push_back(p);
  }

  void shallow_insert(iterator pos,
                      const_iterator first,
                      const_iterator last){
    _vector.insert(pos.base(),first.base(),last.base());
  }



  template <typename T2>
  void deep_copy(const SharedVectorBase<T2>& source);

  void shallow_copy(const self_type& source);


private:
  container_type _vector;
};

} // namespace BTK

#include "shared_vector_base.hpp"

#endif

---