type_system_proxy.hpp

Go to the documentation of this file.

// -*- mode: c++; indent-tabs-mode: nil; -*-
//
//The Biomolecule Toolkit (BTK) is a C++ library for use in the
//modeling, analysis, and design of biological macromolecules.
//Copyright (C) 2006, 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_IO_TYPE_SYSTEM_PROXY_HPP
#define BTK_IO_TYPE_SYSTEM_PROXY_HPP

#include <boost/shared_ptr.hpp>

namespace BTK {
namespace IO {

template <typename TS>
class TypeSystemProxy
{
public:
  typedef TS type_system;
  typedef TypeSystemProxy<type_system> self_type;
  

  typedef typename type_system::element_dictionary element_dictionary;
  typedef typename type_system::atom_dictionary atom_dictionary;
  typedef typename type_system::monomer_dictionary monomer_dictionary;
  typedef typename type_system::structure_dictionary structure_dictionary;

  typedef typename element_dictionary::id_type element_id_type;
  typedef typename atom_dictionary::id_type atom_id_type;
  typedef typename monomer_dictionary::id_type monomer_id_type;
  typedef typename structure_dictionary::id_type structure_id_type;
  
  TypeSystemProxy() : 
    _ptr(new type_system()) {}

  TypeSystemProxy(self_type const & src) :
    _ptr(src._ptr) {}

  TypeSystemProxy(type_system const & ts) : 
    _ptr(new type_system(ts)) {}


  element_dictionary & get_element_dictionary() 
  { return _ptr->get_element_dictionary(); }
  atom_dictionary & get_atom_dictionary() 
  { return _ptr->get_atom_dictionary(); }
  monomer_dictionary & get_monomer_dictionary() 
  { return _ptr->get_monomer_dictionary(); }
  structure_dictionary & get_structure_dictionary()
  { return _ptr->get_structure_dictionary(); }


  element_dictionary const & get_element_dictionary() const 
  { return _ptr->get_element_dictionary(); }
  atom_dictionary const & get_atom_dictionary() const
  { return _ptr->get_atom_dictionary(); }
  monomer_dictionary const & get_monomer_dictionary() const
  { return _ptr->get_monomer_dictionary(); }
  structure_dictionary const & get_structure_dictionary() const 
  { return _ptr->get_structure_dictionary(); }

  self_type clone() const  
  {
    return self_type(*_ptr);
  }

  bool operator==(self_type const & rhs) const
  {
    return _ptr == rhs._ptr;
  }

  bool operator!=(self_type const & rhs) const
  {
    return _ptr != rhs._ptr;
  }

private:
  boost::shared_ptr<type_system> _ptr;
};

} // namespace IO
} // namespace BTK

#endif

---