You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@activemq.apache.org by ch...@apache.org on 2006/03/02 19:29:35 UTC
svn commit: r382462 - in
/incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1: ap.hpp atomic.hpp
namespace.hpp p.hpp platform.hpp
Author: chirino
Date: Thu Mar 2 10:29:33 2006
New Revision: 382462
URL: http://svn.apache.org/viewcvs?rev=382462&view=rev
Log:
BSDish lic. we can redistribut this code.
Added:
incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/ap.hpp (with props)
incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/atomic.hpp (with props)
incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/namespace.hpp (with props)
incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/p.hpp (with props)
incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/platform.hpp (with props)
Added: incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/ap.hpp
URL: http://svn.apache.org/viewcvs/incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/ap.hpp?rev=382462&view=auto
==============================================================================
--- incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/ap.hpp (added)
+++ incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/ap.hpp Thu Mar 2 10:29:33 2006
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2006, David Fahlander
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer. Redistributions in binary
+ * form must reproduce the above copyright notice, this list of conditions and
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. Neither the name of slurk.org nor the names
+ * of its contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef IFR_V1_AP_HPP_
+#define IFR_V1_AP_HPP_
+
+#include <new>
+#include <cstdlib>
+#include <cassert>
+#include <util/ifr/p>
+
+namespace ifr {
+ namespace v1 {
+
+template <typename T> class ap {
+private:
+ struct Array : refcounted {
+ // Members
+ size_t size_;
+ p<T>* array_;
+ // Construct
+ Array (size_t size) : size_ (size) {
+ array_ = (p<T>*) malloc (size * sizeof(p<T>));
+ if (array_ == NULL) {
+ throw std::bad_alloc ();
+ }
+ memset (array_, 0, sizeof (p<T>) * size);
+ }
+ virtual ~Array () {
+ for (size_t i=0; i<size_; ++i) {
+ if (array_[i] != NULL) {
+ smartptr_release (reinterpret_cast<T*>(p_help::get_obj (array_[i])), reinterpret_cast<T*> (NULL));
+ }
+ }
+ free (array_);
+ }
+ };
+ p<Array> a;
+public:
+ ap () {}
+ ap& operator = (class NullClass* nullclass) {
+ assert (nullclass == NULL);
+ a = NULL;
+ return *this;
+ }
+ ap (size_t size) : a (new Array (size)) {}
+ p<T>& operator [] (size_t pos) {
+ return a->array_[pos];
+ }
+ const p<T>& operator [] (size_t pos) const {
+ return array_[pos];
+ }
+ size_t size() const {
+ return a->size_;
+ }
+};
+
+ }
+}
+
+#endif // IFR_V1_AP_HPP_
Propchange: incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/ap.hpp
------------------------------------------------------------------------------
svn:executable = *
Added: incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/atomic.hpp
URL: http://svn.apache.org/viewcvs/incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/atomic.hpp?rev=382462&view=auto
==============================================================================
--- incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/atomic.hpp (added)
+++ incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/atomic.hpp Thu Mar 2 10:29:33 2006
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2005-2006, David Fahlander
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer. Redistributions in binary
+ * form must reproduce the above copyright notice, this list of conditions and
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. Neither the name of slurk.org nor the names
+ * of its contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef IFR_V1_ATOMIC_HPP_
+#define IFR_V1_ATOMIC_HPP_
+
+#include "platform.hpp"
+
+namespace ifr {
+ namespace v1 {
+ class atomic {
+ private:
+ // Invalidate copy constructor and assignment operator
+ atomic (const atomic&);
+ atomic& operator= (const atomic&);
+
+#ifdef BUN_USE_PTHREAD
+ protected:
+ long counter_;
+ pthread_mutex_t m_;
+ public:
+ atomic () : counter_ (0) {
+ pthread_mutex_init(&m_, NULL);
+ }
+ atomic (long init_value) : counter_ (init_value) {
+ pthread_mutex_init(&m_, NULL);
+ }
+ ~atomic () {
+ pthread_mutex_destroy(&m_);
+ }
+ void increment() {
+ pthread_mutex_lock(&m_);
+ ++counter_;
+ pthread_mutex_unlock(&m_);
+ }
+ bool decrement() {
+ pthread_mutex_lock(&m_);
+ if (!--counter_) {
+ pthread_mutex_unlock(&m_);
+ return true;
+ } else {
+ pthread_mutex_unlock(&m_);
+ return false;
+ }
+ }
+ long get_value() const {
+ pthread_mutex_lock(&m_);
+ long retval = counter_;
+ pthread_mutex_unlock(&m_);
+ return retval;
+ }
+ static const char* implementation () {
+ return "pthread";
+ }
+#elif defined BUN_USE_GNU_ATOMIC
+ protected:
+ mutable _Atomic_word counter_;
+ public:
+ atomic () : counter_ (0) {}
+ atomic (long init_value) : counter_ (init_value) {}
+ void increment() {
+ __atomic_add(&counter_, 1);
+ }
+ bool decrement() {
+ return (__exchange_and_add(&counter_, -1) == 1);
+ }
+ long get_value() const {
+ return __exchange_and_add(&counter_, 0);
+ }
+ static const char* implementation () {
+ return "gnu atomic";
+ }
+#elif defined BUN_USE_INTERLOCKED
+ protected:
+ mutable long counter_;
+ public:
+ atomic () : counter_ (0) {}
+ atomic (long init_value) : counter_ (init_value) {}
+ void increment() {
+ _InterlockedIncrement (&counter_);
+ }
+ bool decrement() {
+ return (_InterlockedDecrement (&counter_) == 0);
+ }
+ long get_value() const {
+ return _InterlockedExchangeAdd (&counter_, 0);
+ }
+ static const char* implementation () {
+ return "windows interlocked";
+ }
+#else
+#error "Atomic Operations Unsupported"
+#endif
+ };
+ }
+}
+#endif // IFR_V1_ATOMIC_HPP_
+
Propchange: incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/atomic.hpp
------------------------------------------------------------------------------
svn:executable = *
Added: incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/namespace.hpp
URL: http://svn.apache.org/viewcvs/incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/namespace.hpp?rev=382462&view=auto
==============================================================================
--- incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/namespace.hpp (added)
+++ incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/namespace.hpp Thu Mar 2 10:29:33 2006
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2005-2006, David Fahlander
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer. Redistributions in binary
+ * form must reproduce the above copyright notice, this list of conditions and
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. Neither the name of slurk.org nor the names
+ * of its contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef IFR_V1_NAMESPACE_HPP_
+#define IFR_V1_NAMESPACE_HPP_
+
+namespace ifr {
+ using namespace v1;
+}
+
+#endif // IFR_V1_NAMESPACE_HPP_
Propchange: incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/namespace.hpp
------------------------------------------------------------------------------
svn:executable = *
Added: incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/p.hpp
URL: http://svn.apache.org/viewcvs/incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/p.hpp?rev=382462&view=auto
==============================================================================
--- incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/p.hpp (added)
+++ incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/p.hpp Thu Mar 2 10:29:33 2006
@@ -0,0 +1,351 @@
+/*
+ * Copyright (c) 2005-2006, David Fahlander
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer. Redistributions in binary
+ * form must reproduce the above copyright notice, this list of conditions and
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. Neither the name of slurk.org nor the names
+ * of its contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef IFR_V1_P_HPP_
+#define IFR_V1_P_HPP_
+
+#include "atomic.hpp"
+
+namespace ifr {
+ namespace v1 {
+ // Forward declaration of p
+ template <typename T> class p;
+
+ // This is an internal class that helps getting the private member obj_ from p.
+ // The normal thing would be to use "friend" but that is not possible since
+ // there are template methods and classes that must be friends.
+ struct p_help {
+ template <typename T> static void* get_obj (const p<T>& sp) {
+ return sp.obj_;
+ }
+ };
+
+ /** Generic thread-safe reference counted smart pointer for any type.
+ */
+ template <typename T> class p {
+ friend struct p_help;
+ private: // Should be private. But public because p<A> cannot be friend of p<B> on GCC compiler.
+ void* obj_;
+ public:
+ /** Default constructor. Initiates pointer to zero.
+ */
+ p () : obj_ (0) {}
+ /** Constructor taking ownership of given pointer. Caller looses the ownership of given object.
+ */
+ p (T* obj) {
+ if (obj) {
+ obj_ = smartptr_assign (reinterpret_cast<T*>(obj), reinterpret_cast<T*>(NULL));
+ } else {
+ obj_ = NULL;
+ }
+ }
+ p (T*& obj) {
+ // This constructor is not ment to compile!
+ // It is here to generate an error when trying to assign a p<T> from
+ // an lvalue. p<T> must only be assigned directly from the return value
+ // of the new() operator.
+ //
+ // Compiler will not complain about the error text below, but will complain
+ // about "ambigous call to overloaded function"...
+ ERROR_CANNOT_ASSIGN_P_FROM_LVALUE(obj);
+ }
+
+ /** Destructor. Decrements reference count and eventually deletes the object.
+ */
+ ~p () {
+ if (obj_) smartptr_release (reinterpret_cast<T*>(obj_), reinterpret_cast<T*>(NULL));
+ }
+ /** Copy Constructor. Increments reference count since we also own the object now.
+ */
+ p (const p& other) {
+ obj_ = other.obj_;
+ if (obj_) smartptr_addref (reinterpret_cast<T*>(obj_), reinterpret_cast<T*>(NULL));
+ }
+ /** Copy Constructor for p of compatible class.
+ Increments reference count since we also own the object now.
+ */
+ template <class DerivedClass> p (const p<DerivedClass>& other) {
+ obj_ = smartptr_convert(
+ (T*)NULL,
+ (T*)NULL,
+ reinterpret_cast<DerivedClass*>(p_help::get_obj(other)),
+ (DerivedClass*)NULL);
+ if (obj_) smartptr_addref (reinterpret_cast<T*>(obj_), reinterpret_cast<T*>(NULL));
+ }
+ /** Assignment operator. Increments reference count since we also own the object now.
+ Decrements refcount of the old object because we don't own that anymore.
+ */
+ p& operator = (const p& other) {
+ if (other.obj_) smartptr_addref (reinterpret_cast<T*>(other.obj_), reinterpret_cast<T*>(NULL));
+ if (obj_) smartptr_release (reinterpret_cast<T*>(obj_), reinterpret_cast<T*>(NULL));
+ obj_ = other.obj_;
+ return *this;
+ }
+ /** Assignment operator for p of compatible class.
+ Increments reference count since we also own the object now. Decrements refcount
+ of the old object because we don't own that anymore.
+ */
+ template <class DerivedClass> p& operator = (const p<DerivedClass>& other) {
+ if (p_help::get_obj(other)) smartptr_addref (reinterpret_cast<DerivedClass*>(p_help::get_obj(other)), reinterpret_cast<DerivedClass*>(NULL));
+ if (obj_) smartptr_release (reinterpret_cast<T*>(obj_), reinterpret_cast<T*>(NULL));
+ obj_ = smartptr_convert((T*)NULL, (T*)NULL, reinterpret_cast<DerivedClass*>(p_help::get_obj(other)), (DerivedClass*)NULL);
+ return *this;
+ }
+ /** Assignment operator taking ownership of given pointer.
+ Caller looses the ownership of given object. Decrements refcount
+ of the old object because we don't own that anymore.
+ */
+ p& operator = (T* obj) {
+ if (obj_) smartptr_release (reinterpret_cast<T*>(obj_), reinterpret_cast<T*>(NULL));
+ if (obj) {
+ obj_ = smartptr_assign (reinterpret_cast<T*>(obj), reinterpret_cast<T*>(NULL));
+ } else {
+ obj_ = NULL;
+ }
+ return *this;
+ }
+ p& operator = (T*& obj) {
+ // This constructor is not ment to compile!
+ // It is here to generate an error when trying to assign a p<T> from
+ // an lvalue. p<T> must only be assigned directly from the return value
+ // of the new() operator.
+ //
+ // Compiler will not complain about the error text below, but will complain
+ // about "ambigous call to overloaded function"...
+ ERROR_CANNOT_ASSIGN_P_FROM_LVALUE(obj);
+ return *this;
+ }
+ /** Member reach operator.
+ */
+ T* operator -> () const {return smartptr_get (reinterpret_cast<T*>(obj_), reinterpret_cast<T*>(NULL));}
+ /** Reference reach operator.
+ */
+ T& operator * () const {
+ return *smartptr_get (reinterpret_cast<T*>(obj_), reinterpret_cast<T*>(NULL));
+ }
+ /** Equal Operator. Compares the container's pointer value. Used in order to insert the p in std::maps and std::set.
+ */
+ bool operator == (const p& other) const {return obj_ == other.obj_;}
+ /** Equal Operator. Compares the pointer value. Used mainly to compare with NULL.
+ */
+ bool operator == (const T* other) const {
+ return smartptr_get(reinterpret_cast<T*>(obj_), reinterpret_cast<T*>(NULL)) == other;
+ }
+ /** No-Equal Operator. Compares the container's pointer value. Used in order to insert the p in std collections.
+ */
+ bool operator != (const p& other) const {return obj_ != other.obj_;}
+ /** No-Equal Operator. Compares the pointer value. Used mainly to compare with NULL.
+ */
+ bool operator != (const T* other) const {
+ return smartptr_get(reinterpret_cast<T*>(obj_), reinterpret_cast<T*>(NULL)) != other;
+ }
+ /** Less Operator. Compares the container's pointer value. Used in order to insert the p in std collections.
+ */
+ bool operator < (const p& other) const {
+ return smartptr_get(reinterpret_cast<T*>(obj_), reinterpret_cast<T*>(NULL)) <
+ smartptr_get(reinterpret_cast<T*>(other.obj_), reinterpret_cast<T*>(NULL));
+ }
+ };
+
+ /**
+ */
+ template <typename T> long get_refcount (const p<T>& ptr) {
+ return smartptr_get_refcount (reinterpret_cast<const T*>(p_help::get_obj(ptr)), (const T*) NULL);
+ }
+
+ /**
+ */
+ template <typename T> const T* getptr (const p<T>& ptr) {
+ return smartptr_get (reinterpret_cast<T*>(p_help::get_obj(ptr)), (T*) NULL);
+ }
+
+ /**
+ */
+ template <typename T> T* getptr (p<T>& ptr) {
+ return smartptr_get (reinterpret_cast<T*>(p_help::get_obj(ptr)), (T*) NULL);
+ }
+
+ /**
+ */
+ template <typename T> p<T> encapsulate (T* ptr) {
+ return smartptr_encapsulate (ptr, (T*) NULL);
+ }
+
+ /**
+ */
+ template <typename T> struct PointerHolder {
+ atomic refcount_;
+ T* obj_;
+ PointerHolder (T* obj, long initcount) : refcount_ (initcount), obj_ (obj) {}
+ void addref () {
+ refcount_.increment();
+ }
+ void release () {
+ if (refcount_.decrement()) {
+ delete obj_;
+ delete this;
+ }
+ }
+ };
+
+
+ /* Overloaded smartptr functions for void
+ */
+ template <typename T> void* smartptr_assign (T* obj, void*) {
+ return new PointerHolder<T> (obj, 1);
+ }
+ template <typename T> void smartptr_addref (T* obj, void*) {
+ reinterpret_cast<PointerHolder<T>*>(obj)->refcount_.increment();
+ }
+ template <typename T> void smartptr_release (T* obj, void*) {
+ reinterpret_cast<PointerHolder<T>*>(obj)->release();
+ }
+ template <typename T> T* smartptr_get (T* obj, void*) {
+ return (obj ? reinterpret_cast<PointerHolder<T>*>(obj)->obj_ : NULL);
+ }
+ template <typename Base, typename Derived> Base* smartptr_convert (Base*, void*, Derived* obj, void*) {
+ return obj;
+ }
+ template <typename T> long smartptr_get_refcount (const T* obj, const void*) {
+ return reinterpret_cast<const PointerHolder<T>*>(obj)->refcount_.get_value();
+ }
+ template <typename T> T* smartptr_encapsulate (T* obj, void*) {
+ // This constructor is not ment to compile!
+ // It is here to generate an error when trying to call encapsulate() on
+ // an instance of a class that is not possible to re-encapsulate into a smart pointer.
+ // This error can occur if the class does not derive from recounted, IUnknown
+ // or any other class that supports re-encapsulation into a smart pointer.
+ ERROR_TYPE_NOT_POSSIBLE_TO_ENCAPSULATE(obj);
+ }
+
+
+ /** Base class that, when derived from, makes your class
+ * Faster to assign to a p<your class>.
+ * Faster to delete when your refcount reaches zero.
+ * Possible to use with encapsulate().
+ */
+ class refcounted {
+ friend void addref (refcounted*);
+ friend void release (refcounted*);
+ friend long get_refcount (const refcounted*);
+ private:
+ atomic refcount_;
+ public:
+ refcounted() : refcount_ (1) {}
+ virtual ~refcounted() {}
+ };
+
+ inline void addref (refcounted* o) {
+ o->refcount_.increment();
+ }
+ inline void release (refcounted* o) {
+ if (o->refcount_.decrement()) delete o;
+ }
+ inline long get_refcount (const refcounted* o) {
+ return o->refcount_.get_value();
+ }
+
+ /* Overloaded smartptr functions for refcounted
+ */
+ template <typename T> T* smartptr_assign (T* obj, refcounted*) {
+ return obj;
+ }
+ template <typename T> void smartptr_addref (T* obj, refcounted*) {
+ addref (obj);
+ }
+ template <typename T> void smartptr_release (T* obj, refcounted*) {
+ release (obj);
+ }
+ template <typename T> T* smartptr_get (T* obj, refcounted*) {
+ return obj;
+ }
+ template <typename Base, typename Derived> Base* smartptr_convert (Base*, refcounted*, Derived* obj, refcounted*) {
+ return obj;
+ }
+ template <typename Base, typename Derived> Base* smartptr_convert (Base*, void*, Derived* obj, refcounted*) {
+ // This overloaded method must not compile.
+ // It is here to generate an error when trying to mix instances of refcounted and non-refcounted.
+ // If you get a compilation error here, you should derive from refcount already in given
+ // base class and not only in given subclass.
+ // If that is not possible, your subclass must not derive from refcounted.
+ ERROR_CANNOT_ASSIGN_REFCOUNTED_INSTANCE_TO_NON_REFCOUNTED_BASE((Base*) NULL, obj);
+ return NULL;
+ }
+ template <typename T> long smartptr_get_refcount (const T* obj, const refcounted*) {
+ return get_refcount (obj);
+ }
+ template <typename T> T* smartptr_encapsulate (T* obj, refcounted*) {
+ addref(obj);
+ return obj;
+ }
+ }
+}
+
+/** IUnknown - Makes p<> hold COM objects according to it's standard.
+*/
+struct IUnknown;
+
+namespace bun {
+ namespace v1 {
+ /* Overloaded smartptr functions for IUnknown
+ */
+ template <typename T> T* smartptr_assign (T* obj, IUnknown*) {
+ return obj;
+ }
+ template <typename T> void smartptr_addref (T* obj, IUnknown*) {
+ obj->AddRef();
+ }
+ template <typename T> void smartptr_release (T* obj, IUnknown*) {
+ obj->Release();
+ }
+ template <typename T> T* smartptr_get (T* obj, IUnknown*) {
+ return obj;
+ }
+ template <typename Base, typename Derived> Base* smartptr_convert (Base*, IUnknown*, Derived* obj, IUnknown*) {
+ return obj;
+ }
+ template <typename Base, typename Derived> Base* smartptr_convert (Base*, void*, Derived* obj, IUnknown*) {
+ // This overloaded method must not compile.
+ // It is here to generate an error when trying to mix instances of IUnknown and non-IUnknown.
+ // If you get a compilation error here, you should derive from IUnknown already in given
+ // base class and not only in given subclass.
+ // If that is not possible, your subclass must not derive from IUnknown.
+ ERROR_CANNOT_ASSIGN_IUNKNOWN_INSTANCE_TO_NON_IUNKNOWN_BASE((Base*) NULL, obj);
+ return NULL;
+ }
+ template <typename T> long smartptr_get_refcount (const T* obj, const IUnknown*) {
+ const_cast<T*>(obj)->AddRef();
+ return (long) const_cast<T*>(obj)->Release();
+ }
+ template <typename T> T* smartptr_encapsulate (T* obj, IUnknown*) {
+ obj->AddRef();
+ return obj;
+ }
+ }
+}
+
+#endif // IFR_V1_P_HPP_
Propchange: incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/p.hpp
------------------------------------------------------------------------------
svn:executable = *
Added: incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/platform.hpp
URL: http://svn.apache.org/viewcvs/incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/platform.hpp?rev=382462&view=auto
==============================================================================
--- incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/platform.hpp (added)
+++ incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/platform.hpp Thu Mar 2 10:29:33 2006
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2005-2006, David Fahlander
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer. Redistributions in binary
+ * form must reproduce the above copyright notice, this list of conditions and
+ * the following disclaimer in the documentation and/or other materials provided
+ * with the distribution. Neither the name of slurk.org nor the names
+ * of its contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef IFR_V1_PLATFORM_HPP_
+#define IFR_V1_PLATFORM_HPP_
+
+// GCC
+#if defined __GNUC__
+#ifndef STDCALL
+#define STDCALL __attribute__ ((stdcall))
+#endif
+// Microsoft Visual C++
+#elif defined _MSC_VER
+#define STDCALL __stdcall
+#endif
+
+#if !defined (_WIN64) && defined (WIN64)
+#define _WIN64
+#endif
+
+#if !defined (_WIN32) && defined (WIN32)
+#define _WIN32
+#endif
+
+#if !defined (_WINDOWS) && (defined (_WIN32) || defined (_WIN64))
+#define _WINDOWS
+#endif
+
+#if (defined __GNUC__)
+#define BUN_USE_GNU_ATOMIC
+#include <bits/c++config.h>
+#include <bits/atomicity.h>
+#ifdef __GLIBCXX__
+using __gnu_cxx::__atomic_add;
+using __gnu_cxx::__exchange_and_add;
+#endif
+#elif (!defined __GNUC__) && ( defined _WINDOWS ) // Non-GCC compiler, windows platform:
+#define BUN_USE_INTERLOCKED
+#else // Compiler or processor for which we got no atomic count support
+#define BUN_USE_PTHREAD
+#include <pthread.h>
+#endif
+
+
+
+#ifdef _WINDOWS
+
+// Defining Critical Section, needed for windows critical section handling.
+// We dont want to include windows.h since it contains TOO much dirt.
+extern "C" {
+ #ifdef __GNUC__
+ // GNU C Compiler
+ struct _CRITICAL_SECTION;
+ typedef struct _CRITICAL_SECTION CRITICAL_SECTION;
+ #else
+ // Other Windows Compilers. Same structure as in windows.h
+ struct _RTL_CRITICAL_SECTION;
+ typedef struct _RTL_CRITICAL_SECTION CRITICAL_SECTION;
+ #ifdef _MSC_VER
+ // Interlocked functions. Only for MSVC Compiler. GCC uses inline assembler.
+ // Todo: Support Borland and other c++ compilers on windows with either inline
+ // assember or using Interlocked functions.
+ long __cdecl _InterlockedIncrement(volatile long*);
+ long __cdecl _InterlockedDecrement(volatile long*);
+ long __cdecl _InterlockedExchangeAdd (volatile long*, long);
+ #pragma intrinsic( _InterlockedIncrement )
+ #pragma intrinsic( _InterlockedDecrement )
+ #pragma intrinsic( _InterlockedExchangeAdd )
+ #endif
+ #endif
+ // Declare CriticalSection functions:
+ __declspec(dllimport) void STDCALL InitializeCriticalSection (CRITICAL_SECTION*);
+ __declspec(dllimport) void STDCALL EnterCriticalSection (CRITICAL_SECTION*);
+ __declspec(dllimport) void STDCALL LeaveCriticalSection (CRITICAL_SECTION*);
+ __declspec(dllimport) void STDCALL DeleteCriticalSection (CRITICAL_SECTION*);
+
+ namespace bun {
+ namespace v1 {
+ namespace windows {
+ struct CriticalSection {
+ void* DebugInfo;
+ long LockCount;
+ long RecursionCount;
+ void* OwningThread;
+ void* LockSemaphore;
+ unsigned long SpinCount;
+ operator CRITICAL_SECTION* () {
+ return reinterpret_cast<CRITICAL_SECTION*>(this);
+ }
+ };
+ }
+ }
+ }
+}
+#endif
+
+#endif // IFR_V1_PLATFORM_HPP_
+
Propchange: incubator/activemq/trunk/openwire-cpp/src/util/ifr/v1/platform.hpp
------------------------------------------------------------------------------
svn:executable = *