ers::IssueFactory Class Reference

Factory for all Issues. More...

#include <IssueFactory.h>

List of all members.

Public Types
typedef Issue *(*)	CreateIssueCallback ()
typedef std::map< std::string, CreateIssueCallback >	CallbackMap
Public Member Functions
bool	register_issue (const std::string &name, CreateIssueCallback creator)
	register an issue factory
Issue *	build (const std::string &name) const
	build an empty issue out of a name
Issue *	build (const std::string &name, const string_map_type *values) const
	build a issue out of name and set values
Issue *	build (const Issue *original)
	build a clone of an issue
void	write_to (std::ostream &stream) const
	writes description to stream
Static Public Member Functions
static IssueFactory *	instance ()
	method to access singleton
static void	print_registered ()
	prints all registered issue types
Protected Member Functions
	IssueFactory ()
Protected Attributes
CallbackMap	m_factory_map
Static Protected Attributes
static IssueFactory *	s_factory = 0

---

Detailed Description

Factory for all Issues.

This class implements the factory pattern for Issues. The main responsability of this class is to keep track of the existing types of Issues Each issue should register one factory method for instances of this class. This is needed for deserializing of Issues.

Author:

Matthias Wiesmann

Version:

1.0

Definition at line 31 of file IssueFactory.h.

---

Member Typedef Documentation

typedef std::map<std::string,CreateIssueCallback> ers::IssueFactory::CallbackMap

Definition at line 34 of file IssueFactory.h.

typedef Issue*(*) ers::IssueFactory::CreateIssueCallback()

Definition at line 33 of file IssueFactory.h.

---

Constructor & Destructor Documentation

ers::IssueFactory::IssueFactory

(

)

[protected]

Definition at line 21 of file IssueFactory.cxx.

Referenced by instance().

{}  

---

Member Function Documentation

ers::Issue * ers::IssueFactory::build

(

const Issue *

original

)

build a clone of an issue

Clones an Issue. This method creates (using the other build methods) an new Issue with the same value table

Parameters:

original

the Issue to be cloned

Returns:

a new cloned Issued

Note:

The problem of cause exception is not handled yet.

Definition at line 91 of file IssueFactory.cxx.

References build(), ERS_ASSERT, ERS_PRE_CHECK_PTR, ers::Issue::get_class_name(), ers::Issue::get_value_table(), and deljobs::string.

                                                      {
    ERS_PRE_CHECK_PTR(original); 
    const std::string name = original->get_class_name() ; 
    const ers::string_map_type *values = original->get_value_table();
    ERS_ASSERT(values!=0,"null value table for original"); 
    ers::Issue *clone_issue = build(name,values);
    return clone_issue ; 
}// build

ers::Issue * ers::IssueFactory::build	(	const std::string &	name,
		const string_map_type *	values
	)			const

build a issue out of name and set values

Builds an issue out of a name and a value table

Parameters:

	name	the name used to indentify the class
	values	the value-table containing the state for the Issue

Returns:

an newly allocated instance of this type or null if the name is not registered

Definition at line 76 of file IssueFactory.cxx.

References build(), and genRecEmupikp::i.

                                                                                              {
    Issue *i = build(name);
    if (i) {
        i->set_values(*values); 
    } // if i
    return i ; 
} // build

ers::Issue * ers::IssueFactory::build

(

const std::string &

name

)

const

build an empty issue out of a name

Builds an issue out of the name it was registered with

Parameters:

name

the name used to indentify the class

Returns:

an newly allocated instance of type name or DefaultIssue

Note:

If the requested type cannot be resolved an instance of type DefaultIssue

Definition at line 57 of file IssueFactory.cxx.

References ERS_ISSUE_FACTORY_ERROR, genRecEmupikp::i, and m_factory_map.

Referenced by build(), and ers::Issue::clone().

                                                            {
    CallbackMap::const_iterator i = m_factory_map.find(name); 
    if (i == m_factory_map.end()) {
        // throw ERS_ISSUE_FACTORY_ERROR(name,"issue not registred") ; 
        return new DefaultIssue(name); 
    } // Not found
    ers::Issue *issue = (i->second)() ; 
    if (0==issue) {
        throw ERS_ISSUE_FACTORY_ERROR(name,"factory function returned null"); 
    } // issue null 
    return issue ; 
} // build

ers::IssueFactory * ers::IssueFactory::instance

(

)

[static]

method to access singleton

Finds the singleton instance of the factory. If the instance is not allocated yet, it is.

Returns:

a pointer to the singleton instance

Definition at line 28 of file IssueFactory.cxx.

References IssueFactory(), and s_factory.

Referenced by ers::Issue::clone(), and print_registered().

                                            {
    if (0==s_factory) {
        s_factory = new IssueFactory();
    } // creation needed
    return s_factory ; 
} // instance

void ers::IssueFactory::print_registered

(

)

[static]

prints all registered issue types

Definition at line 35 of file IssueFactory.cxx.

References factory(), and instance().

                                       {
    IssueFactory *factory = instance() ; 
    std::cerr << *factory; 
} //print_registered_issues

bool ers::IssueFactory::register_issue	(	const std::string &	name,
		CreateIssueCallback	creator
	)

register an issue factory

Register an issue type with the factory

Parameters:

	name	the name that will be used to lookup new instances
	creator	a pointer to the function used to create new instance for that particular type of function

Returns:

true if the name was already present in the table

Definition at line 47 of file IssueFactory.cxx.

References m_factory_map, and dchain::value_type().

                                                                                       {
    return m_factory_map.insert(CallbackMap::value_type(name,creator)).second; 
} // register_Issue

void ers::IssueFactory::write_to

(

std::ostream &

stream

)

const

writes description to stream

Definition at line 100 of file IssueFactory.cxx.

References genRecEmupikp::i, m_factory_map, boss::pos, and deljobs::string.

                                                       {
    stream << "Issue factory - registered issues\n" ; 
    stream << "---------------------------------\n" ; 
    int i = 0 ; 
    for(CallbackMap::const_iterator pos=m_factory_map.begin();pos!=m_factory_map.end();++pos) {
        std::string name = pos->first; 
        stream << i << ")\t" << name << std::endl; 
        i++ ; 
    } // for
    stream << "---------------------------------\n" ; 
} // 

---

Member Data Documentation

CallbackMap ers::IssueFactory::m_factory_map [protected]

Definition at line 37 of file IssueFactory.h.

Referenced by build(), register_issue(), and write_to().

ers::IssueFactory * ers::IssueFactory::s_factory = 0 [static, protected]

Definition at line 38 of file IssueFactory.h.

Referenced by instance().

---