icinga2/lib/base/object.hpp

197 lines
5.0 KiB
C++
Raw Normal View History

/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012-2014 Icinga Development Team (http://www.icinga.org) *
* *
* 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 2 *
* 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, write to the Free Software Foundation *
2012-05-11 13:33:57 +02:00
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#ifndef OBJECT_H
#define OBJECT_H
2012-03-28 13:24:49 +02:00
2014-05-25 16:23:35 +02:00
#include "base/i2-base.hpp"
#include "base/debug.hpp"
2013-03-18 22:40:40 +01:00
#include <boost/thread/thread.hpp>
#ifndef _DEBUG
2013-03-15 18:21:29 +01:00
#include <boost/thread/mutex.hpp>
2013-03-18 22:40:40 +01:00
#else /* _DEBUG */
#include <boost/thread/recursive_mutex.hpp>
#endif /* _DEBUG */
2013-03-18 19:02:42 +01:00
#include <boost/smart_ptr/shared_ptr.hpp>
#include <boost/smart_ptr/weak_ptr.hpp>
2013-03-16 21:18:53 +01:00
#include <boost/smart_ptr/enable_shared_from_this.hpp>
#include <boost/smart_ptr/make_shared.hpp>
2014-04-03 15:36:13 +02:00
#include <boost/tuple/tuple.hpp>
2013-03-15 18:21:29 +01:00
2013-03-18 19:02:42 +01:00
using boost::shared_ptr;
using boost::weak_ptr;
using boost::enable_shared_from_this;
2013-03-18 19:02:42 +01:00
using boost::dynamic_pointer_cast;
using boost::static_pointer_cast;
using boost::make_shared;
2014-04-03 15:36:13 +02:00
using boost::tie;
2013-03-18 19:02:42 +01:00
2012-03-28 13:24:49 +02:00
namespace icinga
{
class Value;
#define DECLARE_PTR_TYPEDEFS(klass) \
typedef shared_ptr<klass> Ptr; \
typedef weak_ptr<klass> WeakPtr
class Type;
2012-04-22 16:45:31 +02:00
/**
* Base class for all heap-allocated objects. At least one of its methods
* has to be virtual for RTTI to work.
2012-05-18 22:21:28 +02:00
*
* @ingroup base
2012-04-22 16:45:31 +02:00
*/
class I2_BASE_API Object : public enable_shared_from_this<Object>
2012-03-28 13:24:49 +02:00
{
public:
DECLARE_PTR_TYPEDEFS(Object);
2012-03-28 13:24:49 +02:00
Object(void);
virtual ~Object(void);
virtual const Type *GetReflectionType(void) const;
virtual void SetField(int id, const Value& value);
virtual Value GetField(int id) const;
2012-06-16 16:54:55 +02:00
/**
* Holds a shared pointer and provides support for implicit upcasts.
2012-09-19 12:32:39 +02:00
*
* @ingroup base
2012-06-16 16:54:55 +02:00
*/
class SharedPtrHolder
{
2012-06-16 16:54:55 +02:00
public:
2012-09-19 12:32:39 +02:00
/**
* Constructor for the SharedPtrHolder class.
*
* @param object The shared pointer that should be used to
* construct this shared pointer holder.
*/
2012-06-16 16:54:55 +02:00
explicit SharedPtrHolder(const Object::Ptr& object)
: m_Object(object)
{ }
2012-09-19 12:32:39 +02:00
/**
* Retrieves a shared pointer for the object that is associated
* this holder instance.
*
* @returns A shared pointer.
*/
2012-06-16 16:54:55 +02:00
template<typename T>
operator shared_ptr<T>(void) const
{
#ifdef _DEBUG
2012-06-16 16:54:55 +02:00
shared_ptr<T> other = dynamic_pointer_cast<T>(m_Object);
ASSERT(other);
#else /* _DEBUG */
2012-06-16 16:54:55 +02:00
shared_ptr<T> other = static_pointer_cast<T>(m_Object);
#endif /* _DEBUG */
2012-06-16 16:54:55 +02:00
return other;
}
2012-09-19 12:32:39 +02:00
/**
* Retrieves a weak pointer for the object that is associated
* with this holder instance.
*
* @returns A weak pointer.
*/
2012-06-16 16:54:55 +02:00
template<typename T>
operator weak_ptr<T>(void) const
{
return static_cast<shared_ptr<T> >(*this);
}
operator Value(void) const;
2012-06-16 16:54:55 +02:00
private:
2012-09-19 12:32:39 +02:00
Object::Ptr m_Object; /**< The object that belongs to this
holder instance */
2012-06-16 16:54:55 +02:00
};
2013-03-04 15:52:42 +01:00
#ifdef _DEBUG
bool OwnsLock(void) const;
#endif /* _DEBUG */
2012-08-03 13:19:55 +02:00
protected:
2013-03-01 12:07:52 +01:00
SharedPtrHolder GetSelf(void);
private:
2012-06-16 16:54:55 +02:00
Object(const Object& other);
2012-08-07 21:02:12 +02:00
Object& operator=(const Object& rhs);
2012-06-16 16:54:55 +02:00
2013-03-04 15:52:42 +01:00
#ifndef _DEBUG
typedef boost::mutex MutexType;
#else /* _DEBUG */
typedef boost::recursive_mutex MutexType;
2013-03-01 12:07:52 +01:00
static boost::mutex m_DebugMutex;
2013-03-04 15:52:42 +01:00
mutable bool m_Locked;
mutable boost::thread::id m_LockOwner;
2013-03-02 09:07:47 +01:00
#endif /* _DEBUG */
2013-03-01 12:07:52 +01:00
2013-03-04 15:52:42 +01:00
mutable MutexType m_Mutex;
2013-03-06 11:03:50 +01:00
friend struct ObjectLock;
2013-02-17 19:14:34 +01:00
};
/**
* Compares a weak pointer with a raw pointer.
2012-09-19 12:32:39 +02:00
*
* @ingroup base
*/
2012-03-28 13:24:49 +02:00
template<class T>
struct WeakPtrEqual
2012-03-28 13:24:49 +02:00
{
private:
2012-09-19 12:32:39 +02:00
const void *m_Ref; /**< The object. */
2012-03-28 13:24:49 +02:00
public:
2012-09-19 12:32:39 +02:00
/**
* Constructor for the WeakPtrEqual class.
*
* @param ref The object that should be compared with the weak pointer.
*/
WeakPtrEqual(const void *ref) : m_Ref(ref) { }
2012-03-28 13:24:49 +02:00
/**
* Compares the two pointers.
*
* @param wref The weak pointer.
* @returns true if the pointers point to the same object, false otherwise.
*/
2012-03-28 13:24:49 +02:00
bool operator()(const weak_ptr<T>& wref) const
{
2012-08-08 08:34:15 +02:00
return (wref.lock().get() == static_cast<const T *>(m_Ref));
2012-03-28 13:24:49 +02:00
}
};
template<typename T>
class ObjectImpl
{
};
2012-03-28 13:24:49 +02:00
}
#endif /* OBJECT_H */