# blob.hpp

Go to the documentation of this file.

    00001 /* $Id: blob.hpp 24900 2013-01-08 22:46:42Z planetmaker $ */
    00002
    00003 /*
    00004  * This file is part of OpenTTD.
    00005  * OpenTTD 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, version 2.
    00006  * OpenTTD 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.
    00007  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
    00008  */
    00009
    00012 #ifndef BLOB_HPP
    00013 #define BLOB_HPP
    00014
    00015 #include "../core/alloc_func.hpp"
    00016
    00047 class ByteBlob {
    00048 protected:
    00050   struct BlobHeader {
    00051     size_t items;
    00052     size_t capacity;
    00053   };
    00054
    00056   union {
    00057     byte       *data;
    00058     BlobHeader *header;
    00059   };
    00060
    00061 private:
    00067   static BlobHeader hdrEmpty[];
    00068
    00069 public:
    00070   static const size_t tail_reserve = 4;
    00071   static const size_t header_size = sizeof(BlobHeader);
    00072
    00074   inline ByteBlob() { InitEmpty(); }
    00075
    00077   inline ByteBlob(const ByteBlob &src)
    00078   {
    00079     InitEmpty();
    00080     AppendRaw(src);
    00081   }
    00082
    00084   inline ByteBlob(BlobHeader * const & src)
    00085   {
    00086     assert(src != NULL);
    00087     header = src;
    00088     *const_cast<BlobHeader**>(&src) = NULL;
    00089   }
    00090
    00092   inline ~ByteBlob()
    00093   {
    00094     Free();
    00095   }
    00096
    00097 protected:
    00099   static inline BlobHeader *RawAlloc(size_t num_bytes)
    00100   {
    00101     return (BlobHeader*)MallocT<byte>(num_bytes);
    00102   }
    00103
    00108   static inline BlobHeader *Zero()
    00109   {
    00110     return const_cast<BlobHeader *>(&ByteBlob::hdrEmpty[1]);
    00111   }
    00112
    00114   static inline size_t AllocPolicy(size_t min_alloc)
    00115   {
    00116     if (min_alloc < (1 << 9)) {
    00117       if (min_alloc < (1 << 5)) return (1 << 5);
    00118       return (min_alloc < (1 << 7)) ? (1 << 7) : (1 << 9);
    00119     }
    00120     if (min_alloc < (1 << 15)) {
    00121       if (min_alloc < (1 << 11)) return (1 << 11);
    00122       return (min_alloc < (1 << 13)) ? (1 << 13) : (1 << 15);
    00123     }
    00124     if (min_alloc < (1 << 20)) {
    00125       if (min_alloc < (1 << 17)) return (1 << 17);
    00126       return (min_alloc < (1 << 19)) ? (1 << 19) : (1 << 20);
    00127     }
    00128     min_alloc = (min_alloc | ((1 << 20) - 1)) + 1;
    00129     return min_alloc;
    00130   }
    00131
    00133   static inline void RawFree(BlobHeader *p)
    00134   {
    00135     /* Just to silence an unsilencable GCC 4.4+ warning. */
    00136     assert(p != ByteBlob::hdrEmpty);
    00137
    00138     /* In case GCC warns about the following, see GCC's PR38509 why it is bogus. */
    00139     free(p);
    00140   }
    00141
    00143   inline void InitEmpty()
    00144   {
    00145     header = Zero();
    00146   }
    00147
    00149   inline void Init(BlobHeader *src)
    00150   {
    00151     header = &src[1];
    00152   }
    00153
    00155   inline BlobHeader& Hdr()
    00156   {
    00157     return *(header - 1);
    00158   }
    00159
    00161   inline const BlobHeader& Hdr() const
    00162   {
    00163     return *(header - 1);
    00164   }
    00165
    00167   inline size_t& LengthRef()
    00168   {
    00169     return Hdr().items;
    00170   }
    00171
    00172 public:
    00174   inline bool IsEmpty() const
    00175   {
    00176     return Length() == 0;
    00177   }
    00178
    00180   inline size_t Length() const
    00181   {
    00182     return Hdr().items;
    00183   }
    00184
    00186   inline size_t Capacity() const
    00187   {
    00188     return Hdr().capacity;
    00189   }
    00190
    00192   inline byte *Begin()
    00193   {
    00194     return data;
    00195   }
    00196
    00198   inline const byte *Begin() const
    00199   {
    00200     return data;
    00201   }
    00202
    00204   inline void Clear()
    00205   {
    00206     LengthRef() = 0;
    00207   }
    00208
    00210   inline void Free()
    00211   {
    00212     if (Capacity() > 0) {
    00213       RawFree(&Hdr());
    00214       InitEmpty();
    00215     }
    00216   }
    00217
    00219   inline void AppendRaw(const void *p, size_t num_bytes)
    00220   {
    00221     assert(p != NULL);
    00222     if (num_bytes > 0) {
    00223       memcpy(Append(num_bytes), p, num_bytes);
    00224     }
    00225   }
    00226
    00228   inline void AppendRaw(const ByteBlob& src)
    00229   {
    00230     if (!src.IsEmpty()) {
    00231       memcpy(Append(src.Length()), src.Begin(), src.Length());
    00232     }
    00233   }
    00234
    00239   inline byte *Prepare(size_t num_bytes)
    00240   {
    00241     size_t new_size = Length() + num_bytes;
    00242     if (new_size > Capacity()) SmartAlloc(new_size);
    00243     return data + Length();
    00244   }
    00245
    00250   inline byte *Append(size_t num_bytes)
    00251   {
    00252     byte *pNewData = Prepare(num_bytes);
    00253     LengthRef() += num_bytes;
    00254     return pNewData;
    00255   }
    00256
    00258   void SmartAlloc(size_t new_size)
    00259   {
    00260     if (Capacity() >= new_size) return;
    00261     /* calculate minimum block size we need to allocate
    00262      * and ask allocation policy for some reasonable block size */
    00263     assert(new_size < SIZE_MAX - header_size - tail_reserve);
    00264     new_size = AllocPolicy(header_size + new_size + tail_reserve);
    00265
    00266     /* allocate new block and setup header */
    00267     BlobHeader *tmp = RawAlloc(new_size);
    00268     tmp->items = Length();
    00269     tmp->capacity = new_size - (header_size + tail_reserve);
    00270
    00271     /* copy existing data */
    00272     if (tmp->items != 0) {
    00273       memcpy(tmp + 1, data, tmp->items);
    00274     }
    00275
    00276     /* replace our block with new one */
    00277     if (Capacity() > 0) {
    00278       RawFree(&Hdr());
    00279     }
    00280     Init(tmp);
    00281   }
    00282
    00284   inline void FixTail() const
    00285   {
    00286     if (Capacity() > 0) {
    00287       byte *p = &data[Length()];
    00288       for (uint i = 0; i < tail_reserve; i++) {
    00289         p[i] = 0;
    00290       }
    00291     }
    00292   }
    00293 };
    00294
    00304 template <typename T>
    00305 class CBlobT : public ByteBlob {
    00306   /* make template arguments public: */
    00307 public:
    00308   typedef ByteBlob base;
    00309
    00310   static const size_t type_size = sizeof(T);
    00311
    00312   struct OnTransfer {
    00313     typename base::BlobHeader *header;
    00314     OnTransfer(const OnTransfer& src) : header(src.header) {assert(src.header != NULL); *const_cast<typename base::BlobHeader**>(&src.header) = NULL;}
    00315     OnTransfer(CBlobT& src) : header(src.header) {src.InitEmpty();}
    00316     ~OnTransfer() {assert(header == NULL);}
    00317   };
    00318
    00320   inline CBlobT()
    00321     : base()
    00322   {}
    00323
    00325   inline CBlobT(const OnTransfer& ot)
    00326     : base(ot.header)
    00327   {}
    00328
    00330   inline ~CBlobT()
    00331   {
    00332     Free();
    00333   }
    00334
    00336   inline void CheckIdx(size_t index) const
    00337   {
    00338     assert(index < Size());
    00339   }
    00340
    00342   inline T *Data()
    00343   {
    00344     return (T*)base::Begin();
    00345   }
    00346
    00348   inline const T *Data() const
    00349   {
    00350     return (const T*)base::Begin();
    00351   }
    00352
    00354   inline T *Data(size_t index)
    00355   {
    00356     CheckIdx(index);
    00357     return (Data() + index);
    00358   }
    00359
    00361   inline const T *Data(size_t index) const
    00362   {
    00363     CheckIdx(index);
    00364     return (Data() + index);
    00365   }
    00366
    00368   inline size_t Size() const
    00369   {
    00370     return (base::Length() / type_size);
    00371   }
    00372
    00374   inline size_t MaxSize() const
    00375   {
    00376     return (base::Capacity() / type_size);
    00377   }
    00378
    00380   inline size_t GetReserve() const
    00381   {
    00382     return ((base::Capacity() - base::Length()) / type_size);
    00383   }
    00384
    00386   inline T *GrowSizeNC(size_t num_items)
    00387   {
    00388     return (T*)base::Append(num_items * type_size);
    00389   }
    00390
    00395   inline T *MakeFreeSpace(size_t num_items)
    00396   {
    00397     return (T*)base::Prepare(num_items * type_size);
    00398   }
    00399
    00400   inline OnTransfer Transfer()
    00401   {
    00402     return OnTransfer(*this);
    00403   }
    00404 };
    00405
    00406
    00407 #endif /* BLOB_HPP */