git.cworth.org Git - vogl/blob - src/voglcommon/vogl_blob_manager.h

   1 /**************************************************************************
   2  *
   3  * Copyright 2013-2014 RAD Game Tools and Valve Software
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  *
  24  **************************************************************************/
  25
  26 // File: vogl_blob_manager.h
  27 #ifndef VOGL_BLOB_MANAGER_H
  28 #define VOGL_BLOB_MANAGER_H
  29
  30 #include "vogl_map.h"
  31 #include "vogl_data_stream.h"
  32 #include "vogl_miniz_zip.h"
  33
  34 enum vogl_blob_manager_type_t
  35 {
  36     cBMTNull,
  37     cBMTFile,
  38     cBMTMemory,
  39     cBMTArchive,
  40     cBMTMulti
  41 };
  42
  43 enum vogl_blob_manager_flags_t
  44 {
  45     cBMFReadable = 1,
  46     cBMFWritable = 2,
  47     cBMFReadWrite = cBMFReadable | cBMFWritable,
  48     cBMFOpenExisting = 4,
  49     cBMFOpenExistingOrCreateNew = 8,
  50 };
  51
  52 //----------------------------------------------------------------------------------------------------------------------
  53 // class vogl_blob_manager
  54 //----------------------------------------------------------------------------------------------------------------------
  55 class vogl_blob_manager
  56 {
  57 public:
  58     vogl_blob_manager();
  59     virtual ~vogl_blob_manager();
  60
  61     virtual bool deinit()
  62     {
  63         m_flags = 0;
  64         m_initialized = false;
  65         return true;
  66     }
  67
  68     virtual bool is_initialized() const
  69     {
  70         return m_initialized;
  71     }
  72
  73     virtual bool populate(const vogl_blob_manager &other);
  74
  75     virtual vogl_blob_manager_type_t get_type() const = 0;
  76
  77     vogl::dynamic_string compute_unique_id(const void *pData, uint size, const vogl::dynamic_string &prefix = "", const dynamic_string &ext = "", const uint64_t *pCRC64 = NULL) const;
  78     vogl::dynamic_string get_prefix(const vogl::dynamic_string &id) const;
  79     vogl::dynamic_string get_extension(const vogl::dynamic_string &id) const;
  80
  81     virtual bool get(const dynamic_string &id, vogl::uint8_vec &data) const;
  82
  83     virtual vogl::dynamic_string add_buf_compute_unique_id(const void *pData, uint size, const vogl::dynamic_string &prefix, const dynamic_string &ext, const uint64_t *pCRC64 = NULL);
  84     virtual vogl::dynamic_string add_stream_compute_unique_id(vogl::data_stream &stream, const vogl::dynamic_string &prefix, const dynamic_string &ext, const uint64_t *pCRC64 = NULL);
  85
  86     virtual vogl::dynamic_string add_stream_using_id(vogl::data_stream &stream, const vogl::dynamic_string &id);
  87
  88     virtual vogl::dynamic_string add_buf_using_id(const void *pData, uint size, const vogl::dynamic_string &id) = 0;
  89
  90     virtual vogl::data_stream *open(const vogl::dynamic_string &id) const = 0;
  91     virtual void close(data_stream *pStream) const = 0;
  92
  93     virtual bool does_exist(const dynamic_string &id) const = 0;
  94
  95     virtual uint64_t get_size(const dynamic_string &id) const = 0;
  96
  97     virtual vogl::dynamic_string_array enumerate() const = 0;
  98
  99     virtual vogl::dynamic_string copy_file(vogl_blob_manager &src_blob_manager, const vogl::dynamic_string &src_id, const vogl::dynamic_string &dst_id);
 100
 101 protected:
 102     uint32 m_flags;
 103
 104     bool is_readable() const
 105     {
 106         return (m_flags & cBMFReadable) != 0;
 107     }
 108     bool is_writable() const
 109     {
 110         return (m_flags & cBMFWritable) != 0;
 111     }
 112     bool is_read_only() const
 113     {
 114         return (m_flags & cBMFReadWrite) == cBMFReadable;
 115     }
 116     bool is_write_only() const
 117     {
 118         return (m_flags & cBMFReadWrite) == cBMFWritable;
 119     }
 120
 121     bool init(uint32 flags)
 122     {
 123         if ((flags & cBMFReadWrite) == 0)
 124             return false;
 125         m_flags = flags;
 126         return true;
 127     }
 128
 129     bool m_initialized;
 130 };
 131
 132 //----------------------------------------------------------------------------------------------------------------------
 133 // class vogl_null_blob_manager
 134 //----------------------------------------------------------------------------------------------------------------------
 135 class vogl_null_blob_manager : public vogl_blob_manager
 136 {
 137 public:
 138     vogl_null_blob_manager()
 139         : vogl_blob_manager()
 140     {
 141     }
 142
 143     virtual ~vogl_null_blob_manager()
 144     {
 145     }
 146
 147     bool init(uint32 flags)
 148     {
 149         vogl_blob_manager::init(flags);
 150         m_initialized = true;
 151         return true;
 152     }
 153
 154     bool deinit()
 155     {
 156         return vogl_blob_manager::deinit();
 157     }
 158
 159     virtual vogl_blob_manager_type_t get_type() const
 160     {
 161         return cBMTNull;
 162     }
 163
 164     virtual vogl::dynamic_string add_buf_using_id(const void *pData, uint size, const vogl::dynamic_string &id)
 165     {
 166         VOGL_NOTE_UNUSED(pData);
 167         VOGL_NOTE_UNUSED(size);
 168         return id;
 169     }
 170
 171     virtual vogl::data_stream *open(const dynamic_string &id) const
 172     {
 173         VOGL_NOTE_UNUSED(id);
 174         return NULL;
 175     }
 176
 177     virtual void close(vogl::data_stream *pStream) const
 178     {
 179         VOGL_NOTE_UNUSED(pStream);
 180     }
 181
 182     virtual bool does_exist(const vogl::dynamic_string &id) const
 183     {
 184         VOGL_NOTE_UNUSED(id);
 185         return false;
 186     }
 187
 188     virtual uint64_t get_size(const vogl::dynamic_string &id) const
 189     {
 190         VOGL_NOTE_UNUSED(id);
 191         return 0;
 192     }
 193
 194     virtual vogl::dynamic_string_array enumerate() const
 195     {
 196         return vogl::dynamic_string_array();
 197     }
 198 };
 199
 200 //----------------------------------------------------------------------------------------------------------------------
 201 // class vogl_memory_blob_manager
 202 //----------------------------------------------------------------------------------------------------------------------
 203 class vogl_memory_blob_manager : public vogl_blob_manager
 204 {
 205 public:
 206     vogl_memory_blob_manager();
 207     virtual ~vogl_memory_blob_manager();
 208
 209     bool init(uint32 flags);
 210
 211     virtual bool deinit();
 212
 213     virtual vogl_blob_manager_type_t get_type() const
 214     {
 215         return cBMTMemory;
 216     }
 217
 218     virtual vogl::dynamic_string add_buf_using_id(const void *pData, uint size, const vogl::dynamic_string &id);
 219
 220     virtual vogl::data_stream *open(const dynamic_string &id) const;
 221     virtual void close(vogl::data_stream *pStream) const;
 222
 223     virtual bool does_exist(const vogl::dynamic_string &id) const;
 224
 225     virtual uint64_t get_size(const vogl::dynamic_string &id) const;
 226
 227     virtual vogl::dynamic_string_array enumerate() const;
 228
 229     bool create_archive(mz_zip_archive &zip);
 230     bool read_archive(mz_zip_archive &zip);
 231
 232 private:
 233     struct blob
 234     {
 235         vogl::dynamic_string m_id;
 236         vogl::uint8_vec m_blob;
 237     };
 238
 239     typedef vogl::map<vogl::dynamic_string, blob, vogl::dynamic_string_less_than_case_sensitive, vogl::dynamic_string_equal_to_case_sensitive> blob_map;
 240     blob_map m_blobs;
 241 };
 242
 243 //----------------------------------------------------------------------------------------------------------------------
 244 // class vogl_loose_file_blob_manager
 245 //----------------------------------------------------------------------------------------------------------------------
 246 class vogl_loose_file_blob_manager : public vogl_blob_manager
 247 {
 248 public:
 249     vogl_loose_file_blob_manager();
 250     virtual ~vogl_loose_file_blob_manager();
 251
 252     bool init(uint32 flags);
 253     bool init(uint32 flags, const char *pPath);
 254
 255     void set_path(const vogl::dynamic_string &path)
 256     {
 257         m_path = path;
 258     }
 259     const vogl::dynamic_string &get_path()
 260     {
 261         return m_path;
 262     }
 263
 264     virtual bool deinit();
 265
 266     virtual vogl_blob_manager_type_t get_type() const
 267     {
 268         return cBMTFile;
 269     }
 270
 271     virtual vogl::dynamic_string add_buf_using_id(const void *pData, uint size, const vogl::dynamic_string &id);
 272
 273     virtual vogl::data_stream *open(const vogl::dynamic_string &id) const;
 274     virtual void close(vogl::data_stream *pStream) const;
 275
 276     virtual bool does_exist(const vogl::dynamic_string &id) const;
 277
 278     virtual uint64_t get_size(const vogl::dynamic_string &id) const;
 279
 280     virtual vogl::dynamic_string_array enumerate() const;
 281
 282 private:
 283     vogl::dynamic_string get_filename(const vogl::dynamic_string &id) const;
 284
 285     dynamic_string m_path;
 286 };
 287
 288 //----------------------------------------------------------------------------------------------------------------------
 289 // class vogl_archive_blob_manager
 290 //----------------------------------------------------------------------------------------------------------------------
 291 class vogl_archive_blob_manager : public vogl_blob_manager
 292 {
 293 public:
 294     vogl_archive_blob_manager();
 295     virtual ~vogl_archive_blob_manager();
 296
 297     bool init_memory(uint32 flags, const void *pZip_data, size_t size);
 298
 299     bool init_heap(uint32 flags);
 300     void *deinit_heap(size_t &size);
 301
 302     bool init_file(uint32 flags, const char *pFilename, uint64_t file_start_ofs = 0, uint64_t actual_archive_size = 0);
 303
 304     // Same as init_file(), but creates a temporary archive. It's up to you to delete the archive.
 305     bool init_file_temp(uint32 flags, const char *pPath);
 306
 307     bool init_cfile(uint32 flags, FILE *pFile, uint64_t cur_size);
 308
 309     const dynamic_string &get_archive_filename() const
 310     {
 311         return m_archive_filename;
 312     }
 313
 314     uint64_t get_archive_size() const;
 315     bool write_archive_to_stream(vogl::data_stream &stream) const;
 316
 317     // TODO: init_data_stream
 318
 319     virtual bool deinit();
 320
 321     virtual vogl_blob_manager_type_t get_type() const
 322     {
 323         return cBMTArchive;
 324     }
 325
 326     virtual vogl::dynamic_string add_buf_using_id(const void *pData, uint size, const vogl::dynamic_string &id);
 327
 328     virtual vogl::data_stream *open(const vogl::dynamic_string &id) const;
 329     virtual void close(vogl::data_stream *pStream) const;
 330
 331     virtual bool does_exist(const vogl::dynamic_string &id) const;
 332
 333     virtual uint64_t get_size(const vogl::dynamic_string &id) const;
 334
 335     virtual vogl::dynamic_string_array enumerate() const;
 336
 337 private:
 338     mutable mz_zip_archive m_zip;
 339     dynamic_string m_archive_filename;
 340
 341     struct blob
 342     {
 343         vogl::dynamic_string m_id;
 344         uint m_file_index;
 345         uint64_t m_size;
 346
 347         blob()
 348         {
 349         }
 350         blob(const dynamic_string &id, uint file_index, uint64_t size)
 351             : m_id(id), m_file_index(file_index), m_size(size)
 352         {
 353         }
 354     };
 355
 356     typedef vogl::map<vogl::dynamic_string, blob, vogl::dynamic_string_less_than_case_sensitive, vogl::dynamic_string_equal_to_case_sensitive> blob_map;
 357     blob_map m_blobs;
 358
 359     vogl::dynamic_string get_filename(const vogl::dynamic_string &id) const;
 360     bool populate_blob_map();
 361 };
 362
 363 //----------------------------------------------------------------------------------------------------------------------
 364 // class vogl_multi_blob_manager
 365 //----------------------------------------------------------------------------------------------------------------------
 366 class vogl_multi_blob_manager : public vogl_blob_manager
 367 {
 368 public:
 369     vogl_multi_blob_manager();
 370
 371     virtual ~vogl_multi_blob_manager();
 372
 373     bool init(uint32 flags);
 374
 375     void add_blob_manager(vogl_blob_manager *pBlob_manager);
 376
 377     void remove_blob_manager(vogl_blob_manager *pBlob_manager);
 378
 379     typedef vogl::vector<vogl_blob_manager *> vogl_blob_manager_ptr_vec;
 380
 381     const vogl_blob_manager_ptr_vec &get_blob_managers() const
 382     {
 383         return m_blob_managers;
 384     }
 385     vogl_blob_manager_ptr_vec &get_blob_managers()
 386     {
 387         return m_blob_managers;
 388     }
 389
 390     virtual bool deinit();
 391
 392     virtual vogl_blob_manager_type_t get_type() const
 393     {
 394         return cBMTMulti;
 395     }
 396
 397     virtual vogl::dynamic_string add_buf_using_id(const void *pData, uint size, const vogl::dynamic_string &id);
 398
 399     virtual vogl::data_stream *open(const dynamic_string &id) const;
 400
 401     virtual void close(vogl::data_stream *pStream) const;
 402
 403     virtual bool does_exist(const vogl::dynamic_string &id) const;
 404
 405     virtual uint64_t get_size(const vogl::dynamic_string &id) const;
 406
 407     virtual vogl::dynamic_string_array enumerate() const;
 408
 409 private:
 410     vogl_blob_manager_ptr_vec m_blob_managers;
 411 };
 412
 413 #endif // VOGL_BLOB_MANAGER_H