shared_vector.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_H
#define BTK_SHARED_VECTOR_H

#include "shared_vector_base.h"


namespace BTK {

template <typename T> 
class SharedVector : public SharedVectorBase<T> {
  typedef SharedVectorBase<T> base_type;
public:
  typedef SharedVector<T> 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;

  SharedVector(size_type s = 0) : base_type(s) {}

  template <typename InputIterator>
  SharedVector(InputIterator first, InputIterator last) : base_type(first,last) {}
  
  SharedVector(const self_type& source) : base_type(source) {}

  template <typename T2>
  SharedVector(const SharedVector<T2>& source) : base_type(source) {}

  ~SharedVector() {}

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

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

  // protected->public
  using base_type::clear;
  using base_type::resize;
  using base_type::reserve;
  using base_type::push_back;
  using base_type::insert;
  using base_type::erase;
  using base_type::shallow_push_back;
  using base_type::shallow_insert;
  using base_type::shallow_copy;

  template <typename InputIterator>
  void insert(iterator pos,
              InputIterator first,
              InputIterator last) { base_type::insert(pos,first,last); }

};

} // namespace BTK

#endif

---