class CheckerComponent : public DynamicObject
{
public:
- typedef shared_ptr<CheckerComponent> Ptr;
- typedef weak_ptr<CheckerComponent> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(CheckerComponent);
typedef boost::multi_index_container<
Service::Ptr,
class CheckResultReader : public DynamicObject
{
public:
- typedef shared_ptr<CheckResultReader> Ptr;
- typedef weak_ptr<CheckResultReader> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(CheckResultReader);
CheckResultReader(const Dictionary::Ptr& properties);
class CompatComponent : public DynamicObject
{
public:
+ DECLARE_PTR_TYPEDEFS(CompatComponent);
+
CompatComponent(const Dictionary::Ptr& serializedUpdate);
virtual void Start(void);
class CompatLog : public DynamicObject
{
public:
- typedef shared_ptr<CompatLog> Ptr;
- typedef weak_ptr<CompatLog> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(CompatLog);
CompatLog(const Dictionary::Ptr& serializedUpdate);
class DelegationComponent : public DynamicObject
{
public:
+ DECLARE_PTR_TYPEDEFS(DelegationComponent);
+
DelegationComponent(const Dictionary::Ptr& serializedUpdate);
virtual void Start(void);
class DemoComponent : public DynamicObject
{
public:
+ DECLARE_PTR_TYPEDEFS(DemoComponent);
+
DemoComponent(const Dictionary::Ptr& serializedUpdate);
virtual void Start(void);
class AndFilter : public CombinerFilter
{
public:
- typedef shared_ptr<AndFilter> Ptr;
- typedef weak_ptr<AndFilter> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(AndFilter);
AndFilter(void);
class AttributeFilter : public Filter
{
public:
- typedef shared_ptr<AttributeFilter> Ptr;
- typedef weak_ptr<AttributeFilter> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(AttributeFilter);
AttributeFilter(const String& column, const String& op, const String& operand);
class CombinerFilter : public Filter
{
public:
- typedef shared_ptr<CombinerFilter> Ptr;
- typedef weak_ptr<CombinerFilter> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(CombinerFilter);
CombinerFilter(void);
class CommentsTable : public Table
{
public:
- typedef shared_ptr<CommentsTable> Ptr;
- typedef weak_ptr<CommentsTable> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(CommentsTable);
CommentsTable(void);
class ContactGroupsTable : public Table
{
public:
- typedef shared_ptr<ContactGroupsTable> Ptr;
- typedef weak_ptr<ContactGroupsTable> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(ContactGroupsTable);
ContactGroupsTable(void);
class ContactsTable : public Table
{
public:
- typedef shared_ptr<ContactsTable> Ptr;
- typedef weak_ptr<ContactsTable> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(ContactsTable);
ContactsTable(void);
class DowntimesTable : public Table
{
public:
- typedef shared_ptr<DowntimesTable> Ptr;
- typedef weak_ptr<DowntimesTable> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(DowntimesTable);
DowntimesTable(void);
class Filter : public Object
{
public:
- typedef shared_ptr<Filter> Ptr;
- typedef weak_ptr<Filter> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Filter);
virtual bool Apply(const Table::Ptr& table, const Object::Ptr& object) = 0;
class HostsTable : public Table
{
public:
- typedef shared_ptr<HostsTable> Ptr;
- typedef weak_ptr<HostsTable> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(HostsTable);
HostsTable(void);
class NegateFilter : public Filter
{
public:
- typedef shared_ptr<NegateFilter> Ptr;
- typedef weak_ptr<NegateFilter> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(NegateFilter);
NegateFilter(const Filter::Ptr& inner);
class OrFilter : public CombinerFilter
{
public:
- typedef shared_ptr<OrFilter> Ptr;
- typedef weak_ptr<OrFilter> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(OrFilter);
OrFilter(void);
class Query : public Object
{
public:
- typedef shared_ptr<Query> Ptr;
- typedef weak_ptr<Query> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Query);
Query(const std::vector<String>& lines);
class ServicesTable : public Table
{
public:
- typedef shared_ptr<ServicesTable> Ptr;
- typedef weak_ptr<ServicesTable> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(ServicesTable);
ServicesTable(void);
class StatusTable : public Table
{
public:
- typedef shared_ptr<StatusTable> Ptr;
- typedef weak_ptr<StatusTable> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(StatusTable);
StatusTable(void);
class Table : public Object
{
public:
- typedef shared_ptr<Table> Ptr;
- typedef weak_ptr<Table> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Table);
typedef boost::function<void (const Object::Ptr&)> AddRowFunction;
class NotificationComponent : public DynamicObject
{
public:
+ DECLARE_PTR_TYPEDEFS(NotificationComponent);
+
NotificationComponent(const Dictionary::Ptr& serializedUpdate);
virtual void Start(void);
class ReplicationComponent : public DynamicObject
{
public:
+ DECLARE_PTR_TYPEDEFS(ReplicationComponent);
+
ReplicationComponent(const Dictionary::Ptr& serializedUpdate);
virtual void Start(void);
*/
class I2_BASE_API Application : public DynamicObject {
public:
- typedef shared_ptr<Application> Ptr;
- typedef weak_ptr<Application> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Application);
explicit Application(const Dictionary::Ptr& serializedUpdate);
~Application(void);
class I2_BASE_API Array : public Object
{
public:
- typedef shared_ptr<Array> Ptr;
- typedef weak_ptr<Array> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Array);
/**
* An iterator that can be used to iterate over array elements.
class I2_BASE_API BufferedStream : public Stream
{
public:
- typedef shared_ptr<BufferedStream> Ptr;
- typedef weak_ptr<BufferedStream> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(BufferedStream);
BufferedStream(const Stream::Ptr& innerStream);
~BufferedStream(void);
class I2_BASE_API ConsoleLogger : public StreamLogger
{
public:
- typedef shared_ptr<ConsoleLogger> Ptr;
- typedef weak_ptr<ConsoleLogger> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(ConsoleLogger);
explicit ConsoleLogger(const Dictionary::Ptr& serializedUpdate);
};
class I2_BASE_API Dictionary : public Object
{
public:
- typedef shared_ptr<Dictionary> Ptr;
- typedef weak_ptr<Dictionary> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Dictionary);
/**
* An iterator that can be used to iterate over dictionary elements.
class I2_BASE_API DynamicObject : public Object
{
public:
- typedef shared_ptr<DynamicObject> Ptr;
- typedef weak_ptr<DynamicObject> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(DynamicObject);
typedef std::map<String, AttributeHolder, string_iless> AttributeMap;
typedef AttributeMap::iterator AttributeIterator;
class I2_BASE_API DynamicType : public Object
{
public:
- typedef shared_ptr<DynamicType> Ptr;
- typedef weak_ptr<DynamicType> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(DynamicType);
typedef boost::function<DynamicObject::Ptr (const Dictionary::Ptr&)> ObjectFactory;
class I2_BASE_API FIFO : public Stream
{
public:
- static const size_t BlockSize = 16 * 1024;
+ DECLARE_PTR_TYPEDEFS(FIFO);
- typedef shared_ptr<FIFO> Ptr;
- typedef weak_ptr<FIFO> WeakPtr;
+ static const size_t BlockSize = 16 * 1024;
FIFO(void);
~FIFO(void);
class I2_BASE_API FileLogger : public StreamLogger
{
public:
- typedef shared_ptr<FileLogger> Ptr;
- typedef weak_ptr<FileLogger> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(FileLogger);
explicit FileLogger(const Dictionary::Ptr& serializedUpdate);
class I2_BASE_API Logger : public DynamicObject
{
public:
- typedef shared_ptr<Logger> Ptr;
- typedef weak_ptr<Logger> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Logger);
explicit Logger(const Dictionary::Ptr& serializedUpdate);
class I2_BASE_API NetworkStream : public Stream
{
public:
- typedef shared_ptr<NetworkStream> Ptr;
- typedef weak_ptr<NetworkStream> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(NetworkStream);
NetworkStream(const Socket::Ptr& socket);
class Value;
+#define DECLARE_PTR_TYPEDEFS(klass) \
+ typedef shared_ptr<klass> Ptr; \
+ typedef weak_ptr<klass> WeakPtr
+
/**
* Base class for all heap-allocated objects. At least one of its methods
* has to be virtual for RTTI to work.
class I2_BASE_API Object : public boost::enable_shared_from_this<Object>
{
public:
- typedef shared_ptr<Object> Ptr;
- typedef weak_ptr<Object> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Object);
Object(void);
virtual ~Object(void);
class I2_BASE_API Process : public Object
{
public:
- typedef shared_ptr<Process> Ptr;
- typedef weak_ptr<Process> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Process);
static const std::deque<Process::Ptr>::size_type MaxTasksPerThread = 512;
class I2_BASE_API RingBuffer : public Object
{
public:
- typedef shared_ptr<RingBuffer> Ptr;
- typedef weak_ptr<RingBuffer> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(RingBuffer);
typedef std::vector<int>::size_type SizeType;
class I2_BASE_API Script : public DynamicObject
{
public:
- typedef shared_ptr<Script> Ptr;
- typedef weak_ptr<Script> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Script);
Script(const Dictionary::Ptr& serializedUpdate);
class I2_BASE_API ScriptFunction : public Object
{
public:
- typedef shared_ptr<ScriptFunction> Ptr;
- typedef weak_ptr<ScriptFunction> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(ScriptFunction);
typedef boost::function<Value (const std::vector<Value>& arguments)> Callback;
class I2_BASE_API ScriptInterpreter : public Object
{
public:
- typedef shared_ptr<ScriptInterpreter> Ptr;
- typedef weak_ptr<ScriptInterpreter> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(ScriptInterpreter);
~ScriptInterpreter(void);
class I2_BASE_API ScriptLanguage : public Object
{
public:
- typedef shared_ptr<ScriptLanguage> Ptr;
- typedef weak_ptr<ScriptLanguage> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(ScriptLanguage);
static void Register(const String& name, const ScriptLanguage::Ptr& language);
static void Unregister(const String& name);
class I2_BASE_API Socket : public Object
{
public:
- typedef shared_ptr<Socket> Ptr;
- typedef weak_ptr<Socket> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Socket);
Socket(void);
Socket(SOCKET fd);
class StdioStream : public Stream
{
public:
- typedef shared_ptr<StdioStream> Ptr;
- typedef weak_ptr<StdioStream> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(StdioStream);
StdioStream(std::iostream *innerStream, bool ownsStream);
~StdioStream(void);
class I2_BASE_API Stream : public Object
{
public:
- typedef shared_ptr<Stream> Ptr;
- typedef weak_ptr<Stream> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Stream);
/**
* Reads data from the stream.
class I2_BASE_API StreamLogger : public Logger
{
public:
- typedef shared_ptr<StreamLogger> Ptr;
- typedef weak_ptr<StreamLogger> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(StreamLogger);
StreamLogger(const Dictionary::Ptr& serializedUpdate);
~StreamLogger(void);
class I2_BASE_API SyslogLogger : public Logger
{
public:
- typedef shared_ptr<SyslogLogger> Ptr;
- typedef weak_ptr<SyslogLogger> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(SyslogLogger);
explicit SyslogLogger(const Dictionary::Ptr& serializedUpdate);
class I2_BASE_API TcpSocket : public Socket
{
public:
- typedef shared_ptr<TcpSocket> Ptr;
- typedef weak_ptr<TcpSocket> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(TcpSocket);
void Bind(const String& service, int family);
void Bind(const String& node, const String& service, int family);
class I2_BASE_API Timer : public Object
{
public:
- typedef shared_ptr<Timer> Ptr;
- typedef weak_ptr<Timer> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Timer);
Timer(void);
class I2_BASE_API TlsStream : public Stream
{
public:
- typedef shared_ptr<TlsStream> Ptr;
- typedef weak_ptr<TlsStream> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(TlsStream);
TlsStream(const Stream::Ptr& innerStream, TlsRole role, shared_ptr<SSL_CTX> sslContext);
class UnixSocket : public Socket
{
public:
- typedef shared_ptr<UnixSocket> Ptr;
- typedef weak_ptr<UnixSocket> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(UnixSocket);
UnixSocket(void);
*/
class I2_CONFIG_API ConfigItem : public Object {
public:
- typedef shared_ptr<ConfigItem> Ptr;
- typedef weak_ptr<ConfigItem> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(ConfigItem);
ConfigItem(const String& type, const String& name, const String& unit,
bool abstract, const ExpressionList::Ptr& exprl, const std::vector<String>& parents,
class I2_CONFIG_API ConfigItemBuilder : public Object
{
public:
- typedef shared_ptr<ConfigItemBuilder> Ptr;
- typedef weak_ptr<ConfigItemBuilder> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(ConfigItemBuilder);
ConfigItemBuilder(void);
explicit ConfigItemBuilder(const DebugInfo& debugInfo);
*/\r
class I2_CONFIG_API ConfigType : public Object {\r
public:\r
- typedef shared_ptr<ConfigType> Ptr;\r
- typedef weak_ptr<ConfigType> WeakPtr;\r
+ DECLARE_PTR_TYPEDEFS(ConfigType);\r
\r
ConfigType(const String& name, const DebugInfo& debuginfo);\r
\r
class I2_CONFIG_API ExpressionList : public Object
{
public:
- typedef shared_ptr<ExpressionList> Ptr;
- typedef weak_ptr<ExpressionList> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(ExpressionList);
void AddExpression(const Expression& expression);
class I2_CONFIG_API TypeRuleList : public Object\r
{\r
public:\r
- typedef shared_ptr<TypeRuleList> Ptr;\r
- typedef weak_ptr<TypeRuleList> WeakPtr;\r
+ DECLARE_PTR_TYPEDEFS(TypeRuleList);\r
\r
void SetValidator(const String& validator);\r
String GetValidator(void) const;\r
class I2_BASE_API CheckCommand : public Command
{
public:
- typedef shared_ptr<CheckCommand> Ptr;
- typedef weak_ptr<CheckCommand> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(CheckCommand);
explicit CheckCommand(const Dictionary::Ptr& serializedUpdate);
class I2_BASE_API Command : public DynamicObject, public MacroResolver
{
public:
- typedef shared_ptr<Command> Ptr;
- typedef weak_ptr<Command> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Command);
explicit Command(const Dictionary::Ptr& serializedUpdate);
class I2_BASE_API EventCommand : public Command
{
public:
- typedef shared_ptr<EventCommand> Ptr;
- typedef weak_ptr<EventCommand> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(EventCommand);
explicit EventCommand(const Dictionary::Ptr& serializedUpdate);
class I2_ICINGA_API Host : public DynamicObject, public MacroResolver
{
public:
- typedef shared_ptr<Host> Ptr;
- typedef weak_ptr<Host> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Host);
explicit Host(const Dictionary::Ptr& serializedUpdate);
~Host(void);
class I2_ICINGA_API HostGroup : public DynamicObject
{
public:
- typedef shared_ptr<HostGroup> Ptr;
- typedef weak_ptr<HostGroup> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(HostGroup);
explicit HostGroup(const Dictionary::Ptr& serializedUpdate);
~HostGroup(void);
class I2_ICINGA_API IcingaApplication : public Application, public MacroResolver
{
public:
- typedef shared_ptr<IcingaApplication> Ptr;
- typedef weak_ptr<IcingaApplication> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(IcingaApplication);
explicit IcingaApplication(const Dictionary::Ptr& serializedUpdate);
class I2_ICINGA_API MacroResolver
{
public:
- typedef shared_ptr<MacroResolver> Ptr;
- typedef weak_ptr<MacroResolver> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(MacroResolver);
virtual bool ResolveMacro(const String& macro, const Dictionary::Ptr& cr, String *result) const = 0;
};
class I2_ICINGA_API StaticMacroResolver : public Object, public MacroResolver
{
public:
- typedef shared_ptr<StaticMacroResolver> Ptr;
- typedef weak_ptr<StaticMacroResolver> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(StaticMacroResolver);
StaticMacroResolver(void);
class I2_ICINGA_API Notification : public DynamicObject, public MacroResolver
{
public:
- typedef shared_ptr<Notification> Ptr;
- typedef weak_ptr<Notification> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Notification);
explicit Notification(const Dictionary::Ptr& serializedUpdate);
~Notification(void);
class I2_BASE_API NotificationCommand : public Command
{
public:
- typedef shared_ptr<NotificationCommand> Ptr;
- typedef weak_ptr<NotificationCommand> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(NotificationCommand);
explicit NotificationCommand(const Dictionary::Ptr& serializedUpdate);
class I2_ICINGA_API PerfdataWriter : public DynamicObject
{
public:
- typedef shared_ptr<PerfdataWriter> Ptr;
- typedef weak_ptr<PerfdataWriter> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(PerfdataWriter);
PerfdataWriter(const Dictionary::Ptr& properties);
class I2_ICINGA_API Service : public DynamicObject, public MacroResolver
{
public:
- typedef shared_ptr<Service> Ptr;
- typedef weak_ptr<Service> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Service);
explicit Service(const Dictionary::Ptr& serializedUpdate);
~Service(void);
class I2_ICINGA_API ServiceGroup : public DynamicObject
{
public:
- typedef shared_ptr<ServiceGroup> Ptr;
- typedef weak_ptr<ServiceGroup> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(ServiceGroup);
explicit ServiceGroup(const Dictionary::Ptr& serializedUpdate);
~ServiceGroup(void);
class I2_ICINGA_API TimePeriod : public DynamicObject
{
public:
- typedef shared_ptr<TimePeriod> Ptr;
- typedef weak_ptr<TimePeriod> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(TimePeriod);
explicit TimePeriod(const Dictionary::Ptr& serializedUpdate);
class I2_ICINGA_API User : public DynamicObject, public MacroResolver
{
public:
- typedef shared_ptr<User> Ptr;
- typedef weak_ptr<User> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(User);
explicit User(const Dictionary::Ptr& serializedUpdate);
~User(void);
class I2_ICINGA_API UserGroup : public DynamicObject
{
public:
- typedef shared_ptr<UserGroup> Ptr;
- typedef weak_ptr<UserGroup> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(UserGroup);
explicit UserGroup(const Dictionary::Ptr& serializedUpdate);
~UserGroup(void);
class PythonInterpreter : public ScriptInterpreter
{
public:
- typedef shared_ptr<PythonInterpreter> Ptr;
- typedef weak_ptr<PythonInterpreter> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(PythonInterpreter);
PythonInterpreter(const PythonLanguage::Ptr& language, const Script::Ptr& script);
~PythonInterpreter(void);
class PythonLanguage : public ScriptLanguage
{
public:
- typedef shared_ptr<PythonLanguage> Ptr;
- typedef weak_ptr<PythonLanguage> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(PythonLanguage);
PythonLanguage(void);
~PythonLanguage(void);
class I2_REMOTING_API Endpoint : public DynamicObject
{
public:
- typedef shared_ptr<Endpoint> Ptr;
- typedef weak_ptr<Endpoint> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(Endpoint);
typedef void (Callback)(const Endpoint::Ptr&, const Endpoint::Ptr&, const RequestMessage&);
class I2_REMOTING_API EndpointManager : public Object
{
public:
- typedef shared_ptr<EndpointManager> Ptr;
- typedef weak_ptr<EndpointManager> WeakPtr;
+ DECLARE_PTR_TYPEDEFS(EndpointManager);
EndpointManager(void);
projects / icinga2 / commitdiff