granicus.if.org Git - imagemagick/blob - Magick++/lib/Blob.cpp

   1 // This may look like C code, but it is really -*- C++ -*-
   2 //
   3 // Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2004
   4 //
   5 // Implementation of Blob
   6 //
   7
   8 #define MAGICKCORE_IMPLEMENTATION  1
   9 #define MAGICK_PLUSPLUS_IMPLEMENTATION 1
  10
  11 #include "Magick++/Include.h"
  12 #include "Magick++/Blob.h"
  13 #include "Magick++/BlobRef.h"
  14
  15 #include <string.h>
  16
  17 Magick::Blob::Blob(void)
  18   : _blobRef(new Magick::BlobRef(0,0))
  19 {
  20 }
  21
  22 Magick::Blob::Blob(const void* data_,size_t length_)
  23   : _blobRef(new Magick::BlobRef(data_, length_))
  24 {
  25 }
  26
  27 Magick::Blob::Blob(const Magick::Blob& blob_)
  28   : _blobRef(blob_._blobRef)
  29 {
  30   // Increase reference count
  31   Lock(&_blobRef->mutexLock);
  32   ++_blobRef->refCount;
  33 }
  34
  35 Magick::Blob::~Blob()
  36 {
  37   bool
  38     doDelete;
  39
  40   doDelete=false;
  41   {
  42     Lock(&_blobRef->mutexLock);
  43     if (--_blobRef->refCount == 0)
  44       doDelete=true;
  45   }
  46
  47   if (doDelete)
  48     {
  49       // Delete old blob reference with associated data
  50       delete _blobRef;
  51     }
  52   _blobRef=0;
  53 }
  54
  55 Magick::Blob& Magick::Blob::operator=(const Magick::Blob& blob_)
  56 {
  57   bool
  58     doDelete;
  59
  60   if (this != &blob_)
  61     {
  62       {
  63         Lock(&blob_._blobRef->mutexLock);
  64         ++blob_._blobRef->refCount;
  65       }
  66       doDelete=false;
  67       {
  68         Lock(&_blobRef->mutexLock);
  69         if (--_blobRef->refCount == 0)
  70           doDelete=true;
  71       }
  72       if (doDelete)
  73         {
  74           delete _blobRef;
  75         }
  76       _blobRef=blob_._blobRef;
  77     }
  78   return(*this);
  79 }
  80
  81 void Magick::Blob::base64(const std::string base64_)
  82 {
  83   size_t
  84     length;
  85
  86   unsigned char
  87     *decoded;
  88
  89   decoded=Base64Decode(base64_.c_str(),&length);
  90
  91   if(decoded)
  92     updateNoCopy(static_cast<void*>(decoded),length,
  93       Magick::Blob::MallocAllocator);
  94 }
  95
  96 std::string Magick::Blob::base64(void) const
  97 {
  98   size_t
  99     encoded_length;
 100
 101   char
 102     *encoded;
 103
 104   std::string
 105     result;
 106
 107   encoded_length=0;
 108   encoded=Base64Encode(static_cast<const unsigned char*>(data()),length(),
 109     &encoded_length);
 110
 111   if(encoded)
 112     {
 113       result=std::string(encoded,encoded_length);
 114       encoded=(char *) RelinquishMagickMemory(encoded);
 115       return result;
 116     }
 117
 118   return(std::string());
 119 }
 120
 121 const void* Magick::Blob::data(void) const
 122 {
 123   return(_blobRef->data);
 124 }
 125
 126 size_t Magick::Blob::length(void) const
 127 {
 128   return(_blobRef->length);
 129 }
 130
 131 void Magick::Blob::update(const void* data_,size_t length_)
 132 {
 133   bool
 134     doDelete;
 135
 136   doDelete=false;
 137   {
 138     Lock(&_blobRef->mutexLock);
 139     if (--_blobRef->refCount == 0)
 140       doDelete=true;
 141   }
 142   if (doDelete)
 143     {
 144       // Delete old blob reference with associated data
 145       delete _blobRef;
 146     }
 147
 148   _blobRef=new Magick::BlobRef(data_,length_);
 149 }
 150
 151 void Magick::Blob::updateNoCopy(void* data_,size_t length_,
 152   Magick::Blob::Allocator allocator_)
 153 {
 154   bool
 155     doDelete;
 156
 157   doDelete=false;
 158   {
 159     Lock(&_blobRef->mutexLock);
 160     if (--_blobRef->refCount == 0)
 161       doDelete=true;
 162   }
 163   if (doDelete)
 164     {
 165       // Delete old blob reference with associated data
 166       delete _blobRef;
 167     }
 168   _blobRef=new Magick::BlobRef(0,0);
 169   _blobRef->data=data_;
 170   _blobRef->length=length_;
 171   _blobRef->allocator=allocator_;
 172 }
 173