MemoryManagerOptions Class Reference

#include <MemoryManagerOptions.hpp>

Inheritance diagram for MemoryManagerOptions:

[legend]

Collaboration diagram for MemoryManagerOptions:

[legend]

List of all members.

Public Types
enum	MatrixType { none, sparse }
Public Member Functions
MatrixType	matrixType ()
	MemoryManagerOptions ()
void	get (IdentifierSet &I)
const ReferenceCounting < Parameter >	get (const char *parameterName) const
void	reset ()
Static Public Member Functions
static const char *	identifier ()
Protected Member Functions
template<typename EnumType>
void	get (const char *label, EnumType &e) const
void	get (const char *label, real_t &d) const
void	get (const char *label, int &i) const
void	get (const char *label, std::string &s) const
void	add (ReferenceCounting< Parameter > p)
Private Member Functions
std::ostream &	put (std::ostream &os) const
Friends
std::ostream &	operator<< (std::ostream &os, const ParametrizableObject &P)
	Writes the ParametrizableObject.

---

Detailed Description

Definition at line 23 of file MemoryManagerOptions.hpp.

---

Member Enumeration Documentation

enum MemoryManagerOptions::MatrixType

Enumerator:

none
sparse

Definition at line 34 of file MemoryManagerOptions.hpp.

                  {
    none,
    sparse
  };

---

Constructor & Destructor Documentation

MemoryManagerOptions::MemoryManagerOptions

(

)

[inline, explicit]

Definition at line 52 of file MemoryManagerOptions.hpp.

References none, and sparse.

  {
    // autodoc: "sets matrix type"
    EnumParameter<MatrixType>* E
      = new EnumParameter<MatrixType>(MemoryManagerOptions::sparse,
                                      "matrix");

    // autodoc: "used for sparse matrices, cost is approximatly $27\times n_v\times {n_u}^2$, where $n_v$ is the number of vertices and $n_u$ the number of unknown (for a $Q_1$ discretization)"
    (*E).addSwitch("sparse",
                   MemoryManagerOptions::sparse);

    // autodoc: "do not store the matrix. Cost no memory, but is slower"
    (*E).addSwitch("none",
                   MemoryManagerOptions::none);
    add(E);
  }

---

Member Function Documentation

std::ostream& MemoryManagerOptions::put

(

std::ostream &

os

)

const [inline, private, virtual]

Implements ParametrizableObject.

Definition at line 27 of file MemoryManagerOptions.hpp.

References identifier().

  {
    os << this->identifier();
    return os;
  }

Here is the call graph for this function:

static const char* MemoryManagerOptions::identifier

(

)

[inline, static]

Definition at line 39 of file MemoryManagerOptions.hpp.

Referenced by put().

  {
    // autodoc: "sets memory management options"
    return "memory";
  }

MatrixType MemoryManagerOptions::matrixType

(

)

[inline]

Definition at line 45 of file MemoryManagerOptions.hpp.

References none.

Referenced by MemoryManager::ReserveMatrix().

  {
    MemoryManagerOptions::MatrixType __t = none;
    get("matrix", __t);
    return __t;
  }

void ParametrizableObject::get

(

IdentifierSet &

I

)

[inline, inherited]

Definition at line 54 of file ParametrizableObject.hpp.

References ParametrizableObject::__parameters.

  {
    for (ParameterList::iterator i = __parameters.begin();
         i != __parameters.end(); ++i)
      {
        (*(*i).second).get(I);
        I.insert((*i).first);
      }
  }

template<typename EnumType>

void ParametrizableObject::get	(	const char *	label,
		EnumType &	e
	)			const [inline, protected, inherited]

Definition at line 71 of file ParametrizableObject.hpp.

References Parameter::Enum.

  {
    ReferenceCounting<Parameter> p = get(label);
    if((*p).type() == Parameter::Enum) {
      e = dynamic_cast<const EnumParameter<EnumType>&>(*p);
      return;
    }
  }

void ParametrizableObject::get	(	const char *	label,
		real_t &	d
	)			const [inline, protected, inherited]

Definition at line 80 of file ParametrizableObject.hpp.

References Parameter::Double.

  {
    ReferenceCounting<Parameter> p = get(label);
    if((*p).type() == Parameter::Double) {
      d = dynamic_cast<const DoubleParameter&>(*p);
      return;
    }      
  }

void ParametrizableObject::get	(	const char *	label,
		int &	i
	)			const [inline, protected, inherited]

Definition at line 89 of file ParametrizableObject.hpp.

References Parameter::Integer.

  {
    ReferenceCounting<Parameter> p = get(label);
    if((*p).type() == Parameter::Integer) {
      i = dynamic_cast<const IntegerParameter&>(*p);
      return;
    }      
  }

void ParametrizableObject::get	(	const char *	label,
		std::string &	s
	)			const [inline, protected, inherited]

Definition at line 98 of file ParametrizableObject.hpp.

References Parameter::String.

  {
    ReferenceCounting<Parameter> p = get(label);
    if((*p).type() == Parameter::String) {
      s = dynamic_cast<const StringParameter&>(*p);
      return;
    }      
  }

const ReferenceCounting<Parameter> ParametrizableObject::get

(

const char *

parameterName

)

const [inline, inherited]

Definition at line 117 of file ParametrizableObject.hpp.

References ParametrizableObject::__parameters, ErrorHandler::normal, and stringify().

  {
    ParameterList::const_iterator i = __parameters.find(parameterName);
    if (i != __parameters.end()) {
      return (*i).second;
    } else {
      throw ErrorHandler(__FILE__,__LINE__,
                         stringify(parameterName)+" not found",
                         ErrorHandler::normal);
      return 0;
    }
  }

Here is the call graph for this function:

void ParametrizableObject::add

(

ReferenceCounting< Parameter >

p

)

[inline, protected, inherited]

Definition at line 65 of file ParametrizableObject.hpp.

References ParametrizableObject::__parameters.

  {
    __parameters[(*p).label()] = p;
  }

void ParametrizableObject::reset

(

)

[inline, inherited]

Definition at line 109 of file ParametrizableObject.hpp.

References ParametrizableObject::__parameters.

  {
    for (ParameterList::iterator i = __parameters.begin();
         i != __parameters.end(); ++i) {
      (*(*i).second).reset();
    }
  }

---

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	os,
		const ParametrizableObject &	P
	)			[friend, inherited]

Writes the ParametrizableObject.

Definition at line 22 of file ParametrizableObject.cpp.

{
  os  << P.put(os);
  return os;
}

---

The documentation for this class was generated from the following file:

• MemoryManagerOptions.hpp