update Device with shared_ptr macros

git-svn-id: https://profuse.googlecode.com/svn/branches/profuse_interim@369 aa027e90-d47c-11dd-86d7-074df07e0730

Device/Adaptor.cpp

@@ -2,6 +2,7 @@
 
 
 #include <cstring>
+#include <cstdio>
 #include <Device/Adaptor.h>
 
 #include <ProFUSE/Exception.h>

Device/BlockDevice.cpp

@@ -78,7 +78,7 @@ unsigned BlockDevice::ImageType(const char *type, unsigned defv)
     return defv;
 }
 
-BlockDevice *BlockDevice::Open(const char *name, File::FileFlags flags, unsigned imageType)
+BlockDevicePointer BlockDevice::Open(const char *name, File::FileFlags flags, unsigned imageType)
 {
 #undef __METHOD__
 #define __METHOD__ "BlockDevice::Open"
@@ -128,7 +128,7 @@ BlockDevice *BlockDevice::Open(const char *name, File::FileFlags flags, unsigned
     }
     
     // throw an error?
-    return NULL;
+    return BlockDevicePointer();
     
 }
 
@@ -158,7 +158,7 @@ static std::string filename(const std::string& src)
 }
 
 
-BlockDevice *BlockDevice::Create(const char *fname, const char *vname, unsigned blocks, unsigned imageType)
+BlockDevicePointer BlockDevice::Create(const char *fname, const char *vname, unsigned blocks, unsigned imageType)
 {
     std::string xname;
     
@@ -191,7 +191,7 @@ BlockDevice *BlockDevice::Create(const char *fname, const char *vname, unsigned
             return DavexDiskImage::Create(fname, blocks, vname);
     }
     
-    return NULL;
+    return BlockDevicePointer();
     
 }
 

Device/BlockDevice.h

@@ -8,21 +8,21 @@
 #include <Device/TrackSector.h>
 
 #include <ProFUSE/Exception.h>
-
+#include <ProFUSE/smart_pointers.h>
 
 #include <File/File.h>
 
 namespace Device {
 
-    class BlockDevice : public std::tr1::enable_shared_from_this<BlockDevice> {
+    class BlockDevice : public ENABLE_SHARED_FROM_THIS(BlockDevice) {
 public:
 
 
     // static methods.
     static unsigned ImageType(const char *type, unsigned defv = 0);
     
-    static BlockDevice *Open(const char *name, File::FileFlags flags, unsigned imageType = 0);
-    static BlockDevice *Create(const char *fname, const char *vname, unsigned blocks, unsigned imageType = 0);
+    static BlockDevicePointer Open(const char *name, File::FileFlags flags, unsigned imageType = 0);
+    static BlockDevicePointer Create(const char *fname, const char *vname, unsigned blocks, unsigned imageType = 0);
     
     
     

Device/DavexDiskImage.cpp

@@ -85,20 +85,22 @@ void DavexDiskImage::Validate(MappedFile *f)
         throw Exception(__METHOD__ ": Invalid file format.");
 }
 
-DavexDiskImage *DavexDiskImage::Open(MappedFile *file)
+BlockDevicePointer DavexDiskImage::Open(MappedFile *file)
 {
 #undef __METHOD__
 #define __METHOD__ "DavexDiskImage::Open"
     Validate(file);
     
-    return new DavexDiskImage(file);
+    //return BlockDevicePointer(new DavexDiskImage(file));
+    
+    return MAKE_SHARED(DavexDiskImage, file);
 }
 
-DavexDiskImage *DavexDiskImage::Create(const char *name, size_t blocks)
+BlockDevicePointer DavexDiskImage::Create(const char *name, size_t blocks)
 {
     return Create(name, blocks, "Untitled");
 }
-DavexDiskImage *DavexDiskImage::Create(const char *name, size_t blocks, const char *vname)
+BlockDevicePointer DavexDiskImage::Create(const char *name, size_t blocks, const char *vname)
 {
 #undef __METHOD__
 #define __METHOD__ "DavexDiskImage::Create"
@@ -154,7 +156,9 @@ DavexDiskImage *DavexDiskImage::Create(const char *name, size_t blocks, const ch
     std::memcpy(file->address(), header.buffer(), 512);
     file->sync();
     
-    return new DavexDiskImage(file);
+    //return BlockDevicePointer(new DavexDiskImage(file));
+    
+    return MAKE_SHARED(DavexDiskImage, file);
 }
 
 

Device/DavexDiskImage.h

@@ -16,9 +16,9 @@ public:
     
     virtual ~DavexDiskImage();
     
-    static DavexDiskImage *Create(const char *name, size_t blocks);
-    static DavexDiskImage *Create(const char *name, size_t blocks, const char *vname);
-    static DavexDiskImage *Open(MappedFile *);
+    static BlockDevicePointer Create(const char *name, size_t blocks);
+    static BlockDevicePointer Create(const char *name, size_t blocks, const char *vname);
+    static BlockDevicePointer Open(MappedFile *);
 
     virtual BlockCachePointer createBlockCache();
 

Device/Device.h

@@ -9,17 +9,15 @@
 #ifndef __DEVICE_DEVICE_H__
 #define __DEVICE_DEVICE_H__
 
-#include <tr1/memory>
+#include <ProFUSE/smart_pointers.h>
 
 namespace Device {
     
     class BlockDevice;
     class BlockCache;
     
-    typedef std::tr1::shared_ptr<BlockDevice> BlockDevicePointer;
-    typedef std::tr1::shared_ptr<BlockCache> BlockCachePointer;
-
-    
+    typedef SHARED_PTR(BlockDevice) BlockDevicePointer;
+    typedef SHARED_PTR(BlockCache) BlockCachePointer;    
 }
 
 

Device/DiskCopy42Image.cpp

@@ -75,10 +75,12 @@ uint32_t DiskCopy42Image::Checksum(void *data, size_t size)
     return rv;
 }
 
-DiskCopy42Image *DiskCopy42Image::Open(MappedFile *f)
+BlockDevicePointer DiskCopy42Image::Open(MappedFile *f)
 {
     Validate(f);
-    return new DiskCopy42Image(f);
+    //return BlockDevicePointer(new DiskCopy42Image(f));
+    
+    return MAKE_SHARED(DiskCopy42Image, f);
 }
 
 static uint8_t DiskFormat(size_t blocks)
@@ -101,12 +103,12 @@ static uint8_t FormatByte(size_t blocks)
     default: return 0x22;
     }
 }
-DiskCopy42Image *DiskCopy42Image::Create(const char *name, size_t blocks)
+BlockDevicePointer DiskCopy42Image::Create(const char *name, size_t blocks)
 {
     return Create(name, blocks, "Untitled");
 }
 
-DiskCopy42Image *DiskCopy42Image::Create(const char *name, size_t blocks, const char *vname)
+BlockDevicePointer DiskCopy42Image::Create(const char *name, size_t blocks, const char *vname)
 {
     MappedFile *file = MappedFile::Create(name, blocks * 512 + oUserData);
 
@@ -163,7 +165,9 @@ DiskCopy42Image *DiskCopy42Image::Create(const char *name, size_t blocks, const
     std::memcpy(file->address(), header.buffer(), oUserData);
     file->sync();
     
-    return new DiskCopy42Image(file);
+    //return BlockDevicePointer(new DiskCopy42Image(file));
+    
+    return MAKE_SHARED(DiskCopy42Image, file);
 }
 
 void DiskCopy42Image::Validate(MappedFile *file)

Device/DiskCopy42Image.h

@@ -12,10 +12,10 @@ class DiskCopy42Image : public DiskImage {
 public:
     virtual ~DiskCopy42Image();
 
-    static DiskCopy42Image *Create(const char *name, size_t blocks);
-    static DiskCopy42Image *Create(const char *name, size_t blocks, const char *vname);
+    static BlockDevicePointer Create(const char *name, size_t blocks);
+    static BlockDevicePointer Create(const char *name, size_t blocks, const char *vname);
     
-    static DiskCopy42Image *Open(MappedFile *);
+    static BlockDevicePointer Open(MappedFile *);
 
     static uint32_t Checksum(void *data, size_t size);
 

Device/DiskImage.cpp

@@ -112,16 +112,18 @@ ProDOSOrderDiskImage::ProDOSOrderDiskImage(MappedFile *file) :
     setAdaptor(new POAdaptor(address()));
 }
 
-ProDOSOrderDiskImage *ProDOSOrderDiskImage::Create(const char *name, size_t blocks)
+BlockDevicePointer ProDOSOrderDiskImage::Create(const char *name, size_t blocks)
 {
     MappedFile *file = MappedFile::Create(name, blocks * 512);
-    return new ProDOSOrderDiskImage(file);
+    //return BlockDevicePointer(new ProDOSOrderDiskImage(file));
+    return MAKE_SHARED(ProDOSOrderDiskImage, file);
 }
 
-ProDOSOrderDiskImage *ProDOSOrderDiskImage::Open(MappedFile *file)
+BlockDevicePointer ProDOSOrderDiskImage::Open(MappedFile *file)
 {
     Validate(file);
-    return new ProDOSOrderDiskImage(file);
+    //return BlockDevicePointer(new ProDOSOrderDiskImage(file));
+    return MAKE_SHARED(ProDOSOrderDiskImage, file);
 }
 
 void ProDOSOrderDiskImage::Validate(MappedFile *f)
@@ -165,16 +167,19 @@ DOSOrderDiskImage::DOSOrderDiskImage(MappedFile *file) :
 }
 
 
-DOSOrderDiskImage *DOSOrderDiskImage::Create(const char *name, size_t blocks)
+BlockDevicePointer DOSOrderDiskImage::Create(const char *name, size_t blocks)
 {
     MappedFile *file = MappedFile::Create(name, blocks * 512);
-    return new DOSOrderDiskImage(file);
+    //return BlockDevicePointer(new DOSOrderDiskImage(file));
+    return MAKE_SHARED(DOSOrderDiskImage, file);
 }
 
-DOSOrderDiskImage *DOSOrderDiskImage::Open(MappedFile *file)
+BlockDevicePointer DOSOrderDiskImage::Open(MappedFile *file)
 {
     Validate(file);
-    return new DOSOrderDiskImage(file);
+    //return BlockDevicePointer(new DOSOrderDiskImage(file));
+    return MAKE_SHARED(DOSOrderDiskImage, file);
+    
 }
 
 void DOSOrderDiskImage::Validate(MappedFile *f)

Device/DiskImage.h

@@ -57,8 +57,8 @@ class ProDOSOrderDiskImage : public DiskImage {
 public:
 
     
-    static ProDOSOrderDiskImage *Create(const char *name, size_t blocks);
-    static ProDOSOrderDiskImage *Open(MappedFile *);
+    static BlockDevicePointer Create(const char *name, size_t blocks);
+    static BlockDevicePointer Open(MappedFile *);
 
     
     virtual BlockCachePointer createBlockCache();
@@ -75,8 +75,8 @@ class DOSOrderDiskImage : public DiskImage {
 public:
     
 
-    static DOSOrderDiskImage *Create(const char *name, size_t blocks);
-    static DOSOrderDiskImage *Open(MappedFile *);
+    static BlockDevicePointer Create(const char *name, size_t blocks);
+    static BlockDevicePointer Open(MappedFile *);
 
 private:
     DOSOrderDiskImage();

Device/RawDevice.cpp

@@ -196,9 +196,10 @@ RawDevice::~RawDevice()
 }
 
 
-RawDevice *RawDevice::Open(const char *name, File::FileFlags flags)
+BlockDevicePointer RawDevice::Open(const char *name, File::FileFlags flags)
 {
-    return new RawDevice(name, flags);
+    //return BlockDevicePointer(new RawDevice(name, flags));
+    return MAKE_SHARED(RawDevice, name, flags); 
 }
 
 

Device/RawDevice.h

@@ -17,7 +17,7 @@ public:
 
 
     
-    static RawDevice *Open(const char *name, File::FileFlags flags);
+    static BlockDevicePointer Open(const char *name, File::FileFlags flags);
     
     
     virtual ~RawDevice();

Device/UniversalDiskImage.cpp

@@ -41,7 +41,7 @@ UniversalDiskImage::UniversalDiskImage(MappedFile *file) :
     setAdaptor(new POAdaptor(_dataOffset + data));
 }
 
-UniversalDiskImage *UniversalDiskImage::Create(const char *name, size_t blocks)
+BlockDevicePointer UniversalDiskImage::Create(const char *name, size_t blocks)
 {
     // 64-byte header.
     MappedFile *file = MappedFile::Create(name, blocks * 512 + 64);
@@ -81,13 +81,17 @@ UniversalDiskImage *UniversalDiskImage::Create(const char *name, size_t blocks)
     std::memcpy(file->address(), header.buffer(), 64);
     
 
-    return new UniversalDiskImage(file);
+    //return BlockDevicePointer(new UniversalDiskImage(file));
+    
+    return MAKE_SHARED(UniversalDiskImage, file);
 }
 
-UniversalDiskImage *UniversalDiskImage::Open(MappedFile *file)
+BlockDevicePointer UniversalDiskImage::Open(MappedFile *file)
 {
     Validate(file);
-    return new UniversalDiskImage(file);
+
+    //return BlockDevicePointer(new UniversalDiskImage(file));
+    return MAKE_SHARED(UniversalDiskImage, file);
 }
 
 

Device/UniversalDiskImage.h

@@ -14,8 +14,8 @@ public:
 
     
     
-    static UniversalDiskImage *Create(const char *name, size_t blocks);
-    static UniversalDiskImage *Open(MappedFile *);
+    static BlockDevicePointer Create(const char *name, size_t blocks);
+    static BlockDevicePointer Open(MappedFile *);
 
     virtual bool readOnly();