Added loads of debugging to sharedcore, we're sure it's to blame, but not as

much anymore, for the fishtrax issues, maybe.

1 files changed, 45 insertions, 4 deletions

diff --git a/src/sharedcore.h b/src/sharedcore.h
index 3b60c42..7960fa2 100644
--- a/src/sharedcore.h
+++ b/src/sharedcore.h
@@ -10,6 +10,20 @@
 
 #include "bu/util.h"
 
+#include <stdio.h>
+#include <stdarg.h>
+
+void hardlog(const char *fmt, ...);
+
+void fncin( void *base, const char *fn, void *core, int *refcnt, int params, ... );
+void fncout( void *base, const char *fn, void *core, int *refcnt, int params, ... );
+
+
+#define fin( count, ... ) fncin( (void *)this, __FUNCTION__, core, iRefCount, count, ##__VA_ARGS__ )
+#define fout( count, ... ) fncout( (void *)this, __FUNCTION__, core, iRefCount, count, ##__VA_ARGS__ )
+
+#define rc  ((iRefCount==NULL)?(-1):(*iRefCount))
+
 namespace Bu
 {
         template<typename Core>
@@ -18,26 +32,36 @@ namespace Bu
                 typedef class SharedCore<Core> _SharedType;
         public:
                 SharedCore() :
-                        core( _allocateCore() ),
-                        iRefCount( new int(1) )
+                        core( NULL ),
+                        iRefCount( NULL )
                 {
+                        fin( 0 );
+                        core = _allocateCore();
+                        iRefCount = new int(1);
+                        fout( 0 );
                 }
 
                 SharedCore( const _SharedType &rSrc ) :
                         core( NULL ),
                         iRefCount( NULL )
                 {
+                        fin( 1, &rSrc );
                         _softCopy( rSrc );
+                        fout( 1, &rSrc );
                 }
 
                 virtual ~SharedCore()
                 {
+                        fin( 0 );
                         _deref();
+                        fout( 0 );
                 }
 
                 SharedCore &operator=( const SharedCore &rhs )
                 {
+                        fin( 1, &rhs );
                         _softCopy( rhs );
+                        fout( 1, &rhs );
                         return *this;
                 }
 
@@ -50,34 +74,43 @@ namespace Bu
                 Core *core;
                 void _hardCopy()
                 {
+                        fin( 0 );
                         if( !core || !iRefCount )
-                                return;
+                        {       fout( 0 );      return; }
                         if( (*iRefCount) == 1 )
-                                return;
+                        {       fout( 0 );      return; }
                         Core *copy = _copyCore( core );
                         _deref();
                         core = copy;
                         iRefCount = new int( 1 );
+                        fout( 0 );
                 }
 
                 virtual Core *_allocateCore()
                 {
+                        fin( 0 );
+                        fout( 0 );
                         return new Core();
                 }
 
                 virtual Core *_copyCore( Core *pSrc )
                 {
+                        fin( 0 );
+                        fout( 0 );
                         return new Core( *pSrc );
                 }
 
                 virtual void _deallocateCore( Core *pSrc )
                 {
+                        fin( 0 );
+                        fout( 0 );
                         delete pSrc;
                 }
 
         private:
                 void _deref()
                 {
+                        fin( 0 );
                         if( (--(*iRefCount)) == 0 )
                         {
                                 _deallocateCore( core );
@@ -85,25 +118,33 @@ namespace Bu
                         }
                         core = NULL;
                         iRefCount = NULL;
+                        fout( 0 );
                 }
 
                 void _incRefCount()
                 {
+                        fin( 0 );
                         if( iRefCount && core )
                                 ++(*iRefCount);
+                        fout( 0 );
                 }
 
                 void _softCopy( const _SharedType &rSrc )
                 {
+                        fin( 1, &rSrc );
                         if( core )
                                 _deref();
                         core = rSrc.core;
                         iRefCount = rSrc.iRefCount;
                         _incRefCount();
+                        fout( 1, &rSrc );
                 }
 
                 int *iRefCount;
         };
 };
 
+#undef fin
+#undef fout
+
 #endif