Teuchos_RCPNode.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
// 
//                    Teuchos: Common Tools Package
//                 Copyright (2004) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library 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 library 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 library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef TEUCHOS_RCP_NODE_HPP
#define TEUCHOS_RCP_NODE_HPP


#include "Teuchos_ConfigDefs.hpp"
#include "Teuchos_any.hpp"
#include "Teuchos_map.hpp"


namespace Teuchos {


enum EPrePostDestruction { PRE_DESTROY, POST_DESTROY };


class RCPNode {
public:
  RCPNode(bool has_ownership_in)
    : count_(1), has_ownership_(has_ownership_in), extra_data_map_(NULL)
    {}
  virtual ~RCPNode()
    {
      if(extra_data_map_)
        delete extra_data_map_;
    }
  int count() const {
    return count_; 
  }
  int incr_count() {
    return ++count_;
  }
  int deincr_count() {
    return --count_;
  }
  void has_ownership(bool has_ownership_in) {
    has_ownership_ = has_ownership_in;
  }
  bool has_ownership() const {
    return has_ownership_;
  }
  void set_extra_data(
    const any &extra_data, const std::string& name,
    EPrePostDestruction destroy_when, bool force_unique );
  any& get_extra_data( const std::string& type_name,
    const std::string& name );
  const any& get_extra_data( const std::string& type_name,
    const std::string& name ) const
    {
      return const_cast<RCPNode*>(this)->get_extra_data(type_name,name);
    }
  any* get_optional_extra_data(
    const std::string& type_name, const std::string& name );
  const any* get_optional_extra_data(
    const std::string& type_name, const std::string& name ) const
    {
      return const_cast<RCPNode*>(this)->get_optional_extra_data(type_name,name);
    }
protected:
  void pre_delete_extra_data() {
    if(extra_data_map_)
      impl_pre_delete_extra_data();
  }
private:
  struct extra_data_entry_t {
    extra_data_entry_t() : destroy_when(POST_DESTROY) {}
    extra_data_entry_t( const any &_extra_data, EPrePostDestruction _destroy_when )
      : extra_data(_extra_data), destroy_when(_destroy_when) {}
    any extra_data;
    EPrePostDestruction destroy_when;
  }; 
  typedef Teuchos::map<std::string,extra_data_entry_t> extra_data_map_t;
  int count_;
  bool has_ownership_;
  extra_data_map_t *extra_data_map_;
  // Above is made a pointer to reduce overhead for the general case
  // where this is not used
  void impl_pre_delete_extra_data();
  // Not defined and not to be called
  RCPNode();
  RCPNode(const RCPNode&);
  RCPNode& operator=(const RCPNode&);
}; // end class RCPNode;


template<class T, class Dealloc_T>
class RCPNodeTmpl : public RCPNode {
public:
  RCPNodeTmpl(T* p, Dealloc_T dealloc, bool has_ownership_in)
    : RCPNode(has_ownership_in), ptr_(p), dealloc_(dealloc)
    {}
  Dealloc_T& get_nonconst_dealloc() { return dealloc_; }
  const Dealloc_T& get_dealloc() const { return dealloc_; }
  ~RCPNodeTmpl() {
    this->pre_delete_extra_data();
    if( has_ownership() )
      dealloc_.free(ptr_);
  }
private:
  T *ptr_;
  Dealloc_T dealloc_;
  // not defined and not to be called
  RCPNodeTmpl();
  RCPNodeTmpl(const RCPNodeTmpl&);
  RCPNodeTmpl& operator=(const RCPNodeTmpl&);

}; // end class RCPNodeTmpl<T>


void add_new_RCPNode( RCPNode* rcp_node, const std::string &info );


void remove_RCPNode( RCPNode* rcp_node );


class PrintActiveRCPNodes {
public:
  PrintActiveRCPNodes();
  ~PrintActiveRCPNodes();
  void foo();
private:
  static int count_;
};


bool isTracingActiveRCPNodes();


#ifdef TEUCHOS_DEBUG

void setTracingActiveRCPNodes(bool tracingActiveNodes);

#endif // TEUCHOS_DEBUG


int numActiveRCPNodes();


void printActiveRCPNodes(std::ostream &out);


void throw_null_ptr_error( const std::string &type_name );


} // end namespace Teuchos


namespace {
// This static variable should be delcared before all other static variables
// that depend on RCP or other classes. Therefore, this static varaible should
// be deleted *after* all of these other static variables that depend on RCP
// or created classes go away!
Teuchos::PrintActiveRCPNodes local_printActiveRCPNodes;
} // namespace


#endif // TEUCHOS_RCP_NODE_HPP

---