Ticket #8803: shared_ptr_v2.patch

common/ptr.h

@@ +1 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ */
+
+#ifndef COMMON_PTR_H
+#define COMMON_PTR_H
+
+#include "common/scummsys.h"
+
+namespace Common {
+
+template<class T>
+class SharedPtr {
+        template<class T2> friend class SharedPtr;
+public:
+        typedef int RefValue;
+        typedef T ValueType;
+        typedef T *Pointer;
+
+        SharedPtr() : _refCount(0), _pointer(0) {}
+        template<class T2> explicit SharedPtr(T2 *p) : _refCount(new RefValue(1)), _pointer(p) {}
+
+        SharedPtr(const SharedPtr &r) : _refCount(r._refCount), _pointer(r._pointer) { ++(*_refCount); }
+        template<class T2> SharedPtr(const SharedPtr<T2> &r) : _refCount(r._refCount), _pointer(r._pointer) { ++(*_refCount); }
+
+        ~SharedPtr() { decRef(); }
+
+        SharedPtr &operator =(const SharedPtr &r) {
+                if (r._refCount)
+                        ++(*r._refCount);
+                decRef();
+
+                _refCount = r._refCount;
+                _pointer = r._pointer;
+
+                return *this;
+        }
+
+        template<class T2>
+        SharedPtr &operator =(const SharedPtr<T2> &r) {
+                if (r._refCount)
+                        ++(*r._refCount);
+                decRef();
+
+                _refCount = r._refCount;
+                _pointer = r._pointer;
+
+                return *this;
+        }
+
+        ValueType &operator *() const { assert(_pointer); return *_pointer; }
+        Pointer operator ->() const { assert(_pointer); return _pointer; }
+        Pointer get() const { return _pointer; }
+
+        operator bool() const { return _pointer != 0; }
+        bool unique() const { return refCount() == 1; }
+        RefValue refCount() const { return _refCount ? *_refCount : 0; }
+private:
+        void decRef() {
+                if (_refCount) {
+                        --(*_refCount);
+                        if (!*_refCount) {
+                                delete _refCount;
+                                delete _pointer;
+                                _refCount = 0;
+                                _pointer = 0;
+                        }
+                }
+        }
+
+        RefValue *_refCount;
+        T *_pointer;
+};
+
+} // end of namespace Common
+
+template<class T1, class T2>
+bool operator ==(const Common::SharedPtr<T1> &l, const Common::SharedPtr<T2> &r) {
+        return l.get() == r.get();
+}
+
+template<class T1, class T2>
+bool operator !=(const Common::SharedPtr<T1> &l, const Common::SharedPtr<T2> &r) {
+        return l.get() != r.get();
+}
+
+
+#endif
+

engines/kyra/resource.cpp

@@ -29 +29 @@
 #include "common/file.h"
 #include "common/fs.h"
 #include "common/func.h"
-#include "common/algorithm.h"
 
 #include "gui/message.h"
 
@@ -43 +42 @@
 
 Resource::~Resource() {
         unloadAllPakFiles();
-        for (LoaderIterator i = _loaders.begin(); i != _loaders.end(); ++i)
-                delete (*i);
         _loaders.clear();
 }
 
@@ -648 +645 @@
 }
 
 void Resource::initializeLoaders() {
-        _loaders.push_back(new ResLoaderPak());
-        _loaders.push_back(new ResLoaderIns());
+        _loaders.push_back(LoaderList::value_type(new ResLoaderPak()));
+        _loaders.push_back(LoaderList::value_type(new ResLoaderIns()));
 }
 
 const ResArchiveLoader *Resource::getLoader(ResFileEntry::kType type) const {
         for (CLoaderIterator i = _loaders.begin(); i != _loaders.end(); ++i) {
                 if ((*i)->getType() == type)
-                        return *i;
+                        return (*i).get();
         }
         return 0;
 }
 
 } // end of namespace Kyra
 
+

engines/kyra/resource.h

@@ -34 +34 @@
 #include "common/hash-str.h"
 #include "common/hashmap.h"
 #include "common/stream.h"
+#include "common/ptr.h"
 
 #include "kyra/kyra.h"
 
@@ -111 +112 @@
 
         void initializeLoaders();
         const ResArchiveLoader *getLoader(ResFileEntry::kType type) const;
-        typedef Common::List<ResArchiveLoader*>::iterator LoaderIterator;
-        typedef Common::List<ResArchiveLoader*>::const_iterator CLoaderIterator;
-        Common::List<ResArchiveLoader*> _loaders;
+        typedef Common::List<Common::SharedPtr<ResArchiveLoader> > LoaderList;
+        typedef LoaderList::iterator LoaderIterator;
+        typedef LoaderList::const_iterator CLoaderIterator;
+        LoaderList _loaders;
         ResFileMap _map;
 
         KyraEngine *_vm;
@@ -331 +333 @@
 #endif
 
 
+

test/common/ptr.h

@@ +1 @@
+#include <cxxtest/TestSuite.h>
+
+#include "common/ptr.h"
+
+class PtrTestSuite : public CxxTest::TestSuite
+{
+        public:
+        void test_assign() {
+                Common::SharedPtr<int> p1(new int(1));
+                TS_ASSERT(p1.unique());
+                TS_ASSERT_EQUALS(*p1, 1);
+
+                {
+                        Common::SharedPtr<int> p2 = p1;
+                        TS_ASSERT(!p1.unique());
+                        TS_ASSERT(p1.refCount() == p2.refCount());
+                        TS_ASSERT(p1.refCount() == 2);
+                        TS_ASSERT(p1 == p2);
+                        TS_ASSERT_EQUALS(*p2, 1);
+                        {
+                                Common::SharedPtr<int> p3;
+                                p3 = p2;
+                                TS_ASSERT(p3 == p2 && p3 == p1);
+                                TS_ASSERT(p1.refCount() == 3);
+                                TS_ASSERT_EQUALS(*p3, 1);
+                                *p3 = 0;
+                                TS_ASSERT_EQUALS(*p3, 0);
+                        }
+                        TS_ASSERT_EQUALS(*p2, 0);
+                        TS_ASSERT(p1.refCount() == 2);
+                }
+
+                TS_ASSERT_EQUALS(*p1, 0);
+                TS_ASSERT(p1.unique());
+        }
+};