GRegistry.hpp
4.92 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
/***************************************************************************
* GRegistry.hpp - Interface class for registries *
* ----------------------------------------------------------------------- *
* copyright (C) 2012-2013 by Juergen Knoedlseder *
* ----------------------------------------------------------------------- *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 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 General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
***************************************************************************/
/**
* @file GRegistry.hpp
* @brief Interface class definition for registries
* @author Juergen Knoedlseder
*/
#ifndef GREGISTRY_HPP
#define GREGISTRY_HPP
/* __ Includes ___________________________________________________________ */
#include <string>
#include <iostream>
#include "GLog.hpp"
#include "GTypemaps.hpp"
/***********************************************************************//**
* @class GRegistryPointer
*
* @brief Smart pointer for registry classes
***************************************************************************/
template <class T>
class GRegistryPointer {
public:
// Constructors and destructors
GRegistryPointer(void) : m_ptr(0) { }
GRegistryPointer(const GRegistryPointer<T>& ptr) : m_ptr(ptr.m_ptr) { }
virtual ~GRegistryPointer(void) { free_members(); }
// Operators
GRegistryPointer<T>& operator=(const GRegistryPointer<T>& ptr) {
if (this != &ptr) {
free_members();
m_ptr = ptr.m_ptr;
}
return *this;
}
T& operator*() const { return *m_ptr; }
T* operator->() const { return m_ptr; }
T& operator[](const int& index) const { return m_ptr[index]; }
// Methods
void assign(T* ptr) {
free_members();
m_ptr = ptr;
}
private:
// Protected methods
void free_members(void) {
if (m_ptr != NULL) delete [] m_ptr;
}
// Private members
T* m_ptr; //!< Pointer
};
/***********************************************************************//**
* @class GRegistry
*
* @brief Interface class for registries
*
* This class defines the interface for registries. A registry is a
* container class that contains instance of derived classes. For example,
* if three different derived classes exist for a given base class, the
* registry will contain one instance for each derived class. Using the
* clone mechanism, the registry may thus provide a new instance of a given
* derived class, depending on the type of the derived class.
*
* The interface class requires the implementation of the following methods
* for all registry classes:
*
* size(void) Number of elements in registry class
*
* name(const int& index) Name of registered class by index
*
* print() Print content of registry
***************************************************************************/
class GRegistry {
public:
/// @brief Destructor
///
/// Destroys class.
virtual ~GRegistry(void) {}
/// @brief Return number of classes in registry
///
/// Returns the number of classes that have been registered in the
/// registry.
virtual int size(void) const = 0;
/// @brief Return name of registered class by index
///
/// @param[in] index Class index [0,...,size()-1]
///
/// Returns the name of a registered class, specified by its index in
/// the registry.
virtual std::string name(const int& index) const = 0;
/// @brief Print content of object
///
/// @return String containing the content of the object.
///
/// Formats the content in a standard way and puts this content in a
/// C++ string that is returned.
virtual std::string print(const GChatter& chatter = NORMAL) const = 0;
};
/* __ Prototypes _________________________________________________________ */
std::ostream& operator<<(std::ostream& os, const GRegistry& registry);
GLog& operator<<(GLog& log, const GRegistry& registry);
#endif /* GREGISTRY_HPP */