ers::IssueFactory Class Reference

Factory for all Issues. More...

#include <IssueFactory.h>

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

CallbackMap

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

Definition at line 34 of file IssueFactory.h.

CreateIssueCallback

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

Definition at line 33 of file IssueFactory.h.

Constructor & Destructor Documentation

IssueFactory()

ers::IssueFactory::IssueFactory ( )

protected

Definition at line 21 of file IssueFactory.cxx.

{}  

Member Function Documentation

build() [1/3]

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.

                                                      {
    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

build() [2/3]

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.

                                                            {
    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

Referenced by ers::Issue::clone().

build() [3/3]

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.

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

instance()

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.

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

Referenced by ers::Issue::clone().

print_registered()

void ers::IssueFactory::print_registered ( )

static

prints all registered issue types

Definition at line 35 of file IssueFactory.cxx.

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

register_issue()

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.

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

write_to()

void ers::IssueFactory::write_to

(

std::ostream &

stream

)

const

writes description to stream

Definition at line 100 of file IssueFactory.cxx.

                                                       {
    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

m_factory_map

CallbackMap ers::IssueFactory::m_factory_map

protected

Definition at line 37 of file IssueFactory.h.

s_factory

ers::IssueFactory * ers::IssueFactory::s_factory = 0

staticprotected

Definition at line 38 of file IssueFactory.h.

---

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

• IssueFactory.h
• IssueFactory.cxx