SPtr is now Bu::ified, and the List class now acts the way we think const lists

should act, you can't change anything in there.  I'm still debating changing
the const_iterator to a constIterator, or something else that's more Bu::worthy.

Heh, the namespaces are funny...ok...I'm really tired.

1 files changed, 147 insertions, 0 deletions

diff --git a/src/sptr.h b/src/sptr.h
new file mode 100644
index 0000000..faa8524
--- /dev/null
+++ b/src/sptr.h
@@ -0,0 +1,147 @@
+#ifndef SPTR_H
+#define 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 );
+
+        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;
+                        }
+                }
+
+                int32_t count() const
+                {
+                        return *pRefCnt;
+                }
+
+                const T *operator->() const
+                {
+                        return pData;
+                }
+
+                const T &operator*() const
+                {
+                        return *pData;
+                }
+                
+                T *operator->()
+                {
+                        return pData;
+                }
+
+                T &operator*()
+                {
+                        return *pData;
+                }
+
+                SPtr<T> operator=( const SPtr<T> &src )
+                {
+                        decCount();
+                        pRefCnt = src.pRefCnt;
+                        pData = src.pData;
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
+
+                        return *this;
+                }
+
+                const SPtr<T> operator=( const SPtr<T> &src ) const
+                {
+                        decCount();
+                        pRefCnt = src.pRefCnt;
+                        pData = src.pData;
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
+
+                        return *this;
+                }
+
+                bool operator==( const SPtr<T> &src ) const
+                {
+                        return pData == src.pData;
+                }
+
+                bool operator==( const T *src ) const
+                {
+                        return pData == src;
+                }
+
+                operator bool() const
+                {
+                        return pRefCnt != NULL;
+                }
+
+                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