1 files changed, 229 insertions, 0 deletions

diff --git a/src/stable/sptr.h b/src/stable/sptr.h
new file mode 100644
index 0000000..4eb5a52
--- /dev/null
+++ b/src/stable/sptr.h
@@ -0,0 +1,229 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_SPTR_H
+#define BU_SPTR_H
+
+#include <stdint.h>
+#include <stdio.h>
+
+namespace Bu
+{
+        template<typename T> class SPtr;
+        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src );
+
+        /**
+         *@ingroup Containers
+         */
+        template<typename T>
+        class SPtr
+        {
+                template<typename Tb, typename Ta>
+                friend SPtr<Tb> SPtrCast( SPtr<Ta> pt );
+        public:
+                SPtr() :
+                        pRefCnt( NULL ),
+                        pData( NULL )
+                {
+                }
+
+                ~SPtr()
+                {
+                        decCount();
+                }
+
+                SPtr( const SPtr<T> &src ) :
+                        pRefCnt( src.pRefCnt ),
+                        pData( src.pData )
+                {
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
+                }
+
+                SPtr( T *pSrc ) :
+                        pRefCnt( NULL ),
+                        pData( pSrc )
+                {
+                        if( pData )
+                        {
+                                pRefCnt = new int32_t;
+                                (*pRefCnt) = 1;
+                        }
+                }
+
+                /**
+                 * Get the number of references to this pointer.
+                 *@returns (int32_t) The number of references to this pointer.
+                 */
+                int32_t getRefCount() const
+                {
+                        return *pRefCnt;
+                }
+
+                void clear()
+                {
+                        decCount();
+                        pRefCnt = NULL;
+                        pData = NULL;
+                }
+
+                /**
+                 * Pointer access operator.
+                 *@returns (const T *)
+                 */
+                const T *operator->() const
+                {
+                        return pData;
+                }
+
+                /**
+                 * Dereference operator.
+                 *@returns (const T &) The value at the end of the pointer.
+                 */
+                const T &operator*() const
+                {
+                        return *pData;
+                }
+                
+                /**
+                 * Pointer access operator.
+                 *@returns (T *)
+                 */
+                T *operator->()
+                {
+                        return pData;
+                }
+
+                /**
+                 * Dereference operator.
+                 *@returns (T &) The value at the end of the pointer.
+                 */
+                T &operator*()
+                {
+                        return *pData;
+                }
+
+                /**
+                 * Assignment operator.
+                 *@param src (const SPtr<T> &)
+                 */
+                SPtr<T> operator=( const SPtr<T> &src )
+                {
+                        decCount();
+                        pRefCnt = src.pRefCnt;
+                        pData = src.pData;
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
+
+                        return *this;
+                }
+
+                /**
+                 * Assignment operator.
+                 *@param src (const SPtr<T> &)
+                 */
+                const SPtr<T> operator=( const SPtr<T> &src ) const
+                {
+                        decCount();
+                        pRefCnt = src.pRefCnt;
+                        pData = src.pData;
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
+
+                        return *this;
+                }
+
+                /**
+                 * Equals comparison operator.
+                 *@param src (const SPtr<T> &) The SPtr to compare to.
+                 *@returns (bool) Are the equal?
+                 */
+                bool operator==( const SPtr<T> &src ) const
+                {
+                        return pData == src.pData;
+                }
+
+                /**
+                 * Equals comparison operator.
+                 *@param src (const T *) The pointer to compare to.
+                 *@returns (bool) Are the equal?
+                 */
+                bool operator==( const T *src ) const
+                {
+                        return pData == src;
+                }
+                
+                /**
+                 * Not equals comparison operator.
+                 *@param src (const SPtr<T> &) The SPtr to compare to.
+                 *@returns (bool) Are the equal?
+                 */
+                bool operator!=( const SPtr<T> &src ) const
+                {
+                        return !(pData == src.pData);
+                }
+
+                /**
+                 * Not equals comparison operator.
+                 *@param src (const T *) The pointer to compare to.
+                 *@returns (bool) Are the equal?
+                 */
+                bool operator!=( const T *src ) const
+                {
+                        return !(pData == src);
+                }
+
+                /**
+                 * Boolean cast operator. Do we have a pointer?
+                 */
+                operator bool() const
+                {
+                        return pRefCnt != NULL;
+                }
+
+                /**
+                 * Do we have a pointer?
+                 *@returns (bool) Do we have a pointer?
+                 */
+                bool isSet() const
+                {
+                        return pRefCnt != NULL;
+                }
+
+        private:
+                void decCount() const
+                {
+                        if( pRefCnt )
+                        {
+                                (*pRefCnt) -= 1;
+                                //printf("Decrementing ref-count to %d\n", *pRefCnt );
+                                if( (*pRefCnt) == 0 )
+                                {
+                                        delete pRefCnt;
+                                        delete pData;
+                                        pRefCnt = NULL;
+                                        pData = NULL;
+                                }
+                        }
+                }
+
+                mutable int32_t *pRefCnt;
+                mutable T *pData;
+        };
+
+        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src )
+        {
+                SPtr<Tb> ret;
+                ret.pRefCnt = src.pRefCnt;
+                ret.pData = dynamic_cast<Tb *>(src.pData);
+                if( ret.pRefCnt )
+                        (*(ret.pRefCnt)) += 1;
+                return ret;
+        }
+}
+
+#endif