include/wx/archive.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        archive.h
   3 // Purpose:     Streams for archive formats
   4 // Author:      Mike Wetherell
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 2004 Mike Wetherell
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifndef _WX_ARCHIVE_H__
  11 #define _WX_ARCHIVE_H__
  12
  13 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  14 #pragma interface "archive.h"
  15 #endif
  16
  17 #include "wx/defs.h"
  18
  19 #if wxUSE_ZLIB && wxUSE_STREAMS && wxUSE_ZIPSTREAM
  20
  21 #include "wx/stream.h"
  22 #include "wx/filename.h"
  23
  24
  25 /////////////////////////////////////////////////////////////////////////////
  26 // wxArchiveNotifier
  27
  28 class WXDLLIMPEXP_BASE wxArchiveNotifier
  29 {
  30 public:
  31     virtual ~wxArchiveNotifier() { }
  32
  33     virtual void OnEntryUpdated(class wxArchiveEntry& entry) = 0;
  34 };
  35
  36
  37 /////////////////////////////////////////////////////////////////////////////
  38 // wxArchiveEntry
  39 //
  40 // Holds an entry's meta data, such as filename and timestamp.
  41
  42 class WXDLLIMPEXP_BASE wxArchiveEntry : public wxObject
  43 {
  44 public:
  45     virtual ~wxArchiveEntry() { }
  46
  47     virtual wxDateTime   GetDateTime() const = 0;
  48     virtual wxFileOffset GetSize() const = 0;
  49     virtual wxFileOffset GetOffset() const = 0;
  50     virtual bool         IsDir() const = 0;
  51     virtual bool         IsReadOnly() const = 0;
  52     virtual wxString     GetInternalName() const = 0;
  53     virtual wxPathFormat GetInternalFormat() const = 0;
  54     virtual wxString     GetName(wxPathFormat format = wxPATH_NATIVE) const = 0;
  55
  56     virtual void SetDateTime(const wxDateTime& dt) = 0;
  57     virtual void SetSize(wxFileOffset size) = 0;
  58     virtual void SetIsDir(bool isDir = true) = 0;
  59     virtual void SetIsReadOnly(bool isReadOnly = true) = 0;
  60     virtual void SetName(const wxString& name,
  61                          wxPathFormat format = wxPATH_NATIVE) = 0;
  62
  63     wxArchiveEntry *Clone() const { return DoClone(); }
  64
  65     void SetNotifier(wxArchiveNotifier& notifier);
  66     virtual void UnsetNotifier() { m_notifier = NULL; }
  67
  68 protected:
  69     wxArchiveEntry() : m_notifier(NULL) { }
  70
  71     virtual void SetOffset(wxFileOffset offset) = 0;
  72     virtual wxArchiveEntry* DoClone() const = 0;
  73
  74     wxArchiveNotifier *GetNotifier() const { return m_notifier; }
  75     wxArchiveEntry& operator=(const wxArchiveEntry& entry);
  76
  77 private:
  78     wxArchiveNotifier *m_notifier;
  79
  80     DECLARE_ABSTRACT_CLASS(wxArchiveEntry)
  81 };
  82
  83
  84 /////////////////////////////////////////////////////////////////////////////
  85 // wxArchiveInputStream
  86 //
  87 // GetNextEntry() returns an wxArchiveEntry object containing the meta-data
  88 // for the next entry in the archive (and gives away ownership). Reading from
  89 // the wxArchiveInputStream then returns the entry's data. Eof() becomes true
  90 // after an attempt has been made to read past the end of the entry's data.
  91 //
  92 // When there are no more entries, GetNextEntry() returns NULL and sets Eof().
  93
  94 class WXDLLIMPEXP_BASE wxArchiveInputStream : public wxFilterInputStream
  95 {
  96 public:
  97     typedef wxArchiveEntry entry_type;
  98
  99     virtual ~wxArchiveInputStream() { }
 100
 101     virtual bool OpenEntry(wxArchiveEntry& entry) = 0;
 102     virtual bool CloseEntry() = 0;
 103
 104     wxArchiveEntry *GetNextEntry()  { return DoGetNextEntry(); }
 105
 106     virtual char Peek()             { return wxInputStream::Peek(); }
 107
 108 protected:
 109     wxArchiveInputStream(wxInputStream& stream, wxMBConv& conv);
 110
 111     virtual wxArchiveEntry *DoGetNextEntry() = 0;
 112
 113     wxMBConv& GetConv() const       { return m_conv; }
 114
 115 private:
 116     wxMBConv& m_conv;
 117 };
 118
 119
 120 /////////////////////////////////////////////////////////////////////////////
 121 // wxArchiveOutputStream
 122 //
 123 // PutNextEntry is used to create a new entry in the output archive, then
 124 // the entry's data is written to the wxArchiveOutputStream.
 125 //
 126 // Only one entry can be open for output at a time; another call to
 127 // PutNextEntry closes the current entry and begins the next.
 128 //
 129 // The overload 'bool PutNextEntry(wxArchiveEntry *entry)' takes ownership
 130 // of the entry object.
 131
 132 class WXDLLIMPEXP_BASE wxArchiveOutputStream : public wxFilterOutputStream
 133 {
 134 public:
 135     virtual ~wxArchiveOutputStream() { }
 136
 137     virtual bool PutNextEntry(wxArchiveEntry *entry) = 0;
 138
 139     virtual bool PutNextEntry(const wxString& name,
 140                               const wxDateTime& dt = wxDateTime::Now(),
 141                               wxFileOffset size = wxInvalidOffset) = 0;
 142
 143     virtual bool PutNextDirEntry(const wxString& name,
 144                                  const wxDateTime& dt = wxDateTime::Now()) = 0;
 145
 146     virtual bool CopyEntry(wxArchiveEntry *entry,
 147                            wxArchiveInputStream& stream) = 0;
 148
 149     virtual bool CopyArchiveMetaData(wxArchiveInputStream& stream) = 0;
 150
 151     virtual bool CloseEntry() = 0;
 152
 153 protected:
 154     wxArchiveOutputStream(wxOutputStream& stream, wxMBConv& conv);
 155
 156     wxMBConv& GetConv() const { return m_conv; }
 157
 158 private:
 159     wxMBConv& m_conv;
 160 };
 161
 162
 163 /////////////////////////////////////////////////////////////////////////////
 164 // wxArchiveClassFactory
 165 //
 166 // A wxArchiveClassFactory instance for a particular archive type allows
 167 // the creation of the other classes that may be needed.
 168
 169 class WXDLLIMPEXP_BASE wxArchiveClassFactory : public wxObject
 170 {
 171 public:
 172     virtual ~wxArchiveClassFactory() { }
 173
 174     wxArchiveEntry *NewEntry() const
 175         { return DoNewEntry(); }
 176     wxArchiveInputStream *NewStream(wxInputStream& stream) const
 177         { return DoNewStream(stream); }
 178     wxArchiveOutputStream *NewStream(wxOutputStream& stream) const
 179         { return DoNewStream(stream); }
 180
 181     virtual wxString GetInternalName(
 182         const wxString& name,
 183         wxPathFormat format = wxPATH_NATIVE) const = 0;
 184
 185     void SetConv(wxMBConv& conv) { m_pConv = &conv; }
 186     wxMBConv& GetConv() const { return *m_pConv; }
 187
 188 protected:
 189     virtual wxArchiveEntry        *DoNewEntry() const = 0;
 190     virtual wxArchiveInputStream  *DoNewStream(wxInputStream& stream) const = 0;
 191     virtual wxArchiveOutputStream *DoNewStream(wxOutputStream& stream) const = 0;
 192
 193     wxArchiveClassFactory() : m_pConv(&wxConvLocal) { }
 194     wxArchiveClassFactory& operator=(const wxArchiveClassFactory& WXUNUSED(f))
 195         { return *this; }
 196
 197 private:
 198     wxMBConv *m_pConv;
 199
 200     DECLARE_ABSTRACT_CLASS(wxArchiveClassFactory)
 201 };
 202
 203
 204 /////////////////////////////////////////////////////////////////////////////
 205 // wxArchiveIterator
 206 //
 207 // An input iterator that can be used to transfer an archive's catalog to
 208 // a container.
 209
 210 #if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
 211 #include <iterator>
 212 #include <utility>
 213
 214 template <class X, class Y>
 215 void WXDLLIMPEXP_BASE _wxSetArchiveIteratorValue(
 216     X& val, Y entry, void *WXUNUSED(d))
 217 {
 218     val = X(entry);
 219 }
 220 template <class X, class Y, class Z>
 221 void WXDLLIMPEXP_BASE _wxSetArchiveIteratorValue(
 222     std::pair<X, Y>& val, Z entry, Z WXUNUSED(d))
 223 {
 224     val = std::make_pair(X(entry->GetInternalName()), Y(entry));
 225 }
 226
 227 #if defined _MSC_VER && _MSC_VER < 1300
 228 template <class Arc, class T = Arc::entry_type*>
 229 #else
 230 template <class Arc, class T = typename Arc::entry_type*>
 231 #endif
 232 class WXDLLIMPEXP_BASE wxArchiveIterator
 233 {
 234 public:
 235     typedef std::input_iterator_tag iterator_category;
 236     typedef T value_type;
 237     typedef ptrdiff_t difference_type;
 238     typedef T* pointer;
 239     typedef T& reference;
 240
 241     wxArchiveIterator() : m_rep(NULL) { }
 242
 243     wxArchiveIterator(Arc& arc) {
 244         typename Arc::entry_type* entry = arc.GetNextEntry();
 245         m_rep = entry ? new Rep(arc, entry) : NULL;
 246     }
 247
 248     wxArchiveIterator(const wxArchiveIterator& it) : m_rep(it.m_rep) {
 249         if (m_rep)
 250             m_rep->AddRef();
 251     }
 252
 253     ~wxArchiveIterator() {
 254         if (m_rep)
 255             m_rep->UnRef();
 256     }
 257
 258     const T& operator *() const {
 259         return m_rep->GetValue();
 260     }
 261
 262     const T* operator ->() const {
 263         return &**this;
 264     }
 265
 266     wxArchiveIterator& operator =(const wxArchiveIterator& it) {
 267         if (it.m_rep)
 268             it.m_rep.AddRef();
 269         if (m_rep)
 270             m_rep.UnRef();
 271         m_rep = it.m_rep;
 272         return *this;
 273     }
 274
 275     wxArchiveIterator& operator ++() {
 276         m_rep = m_rep->Next();
 277         return *this;
 278     }
 279
 280     wxArchiveIterator operator ++(int) {
 281         wxArchiveIterator it(*this);
 282         ++(*this);
 283         return it;
 284     }
 285
 286     bool operator ==(const wxArchiveIterator& j) {
 287         return (*this).m_rep == j.m_rep;
 288     }
 289
 290     bool operator !=(const wxArchiveIterator& j) {
 291         return !(*this == j);
 292     }
 293
 294 private:
 295     class Rep {
 296         Arc& m_arc;
 297         typename Arc::entry_type* m_entry;
 298         T m_value;
 299         int m_ref;
 300
 301     public:
 302         Rep(Arc& arc, typename Arc::entry_type* entry)
 303             : m_arc(arc), m_entry(entry), m_value(), m_ref(1) { }
 304         ~Rep()
 305             { delete m_entry; }
 306
 307         void AddRef() {
 308             m_ref++;
 309         }
 310
 311         void UnRef() {
 312             if (--m_ref == 0)
 313                 delete this;
 314         }
 315
 316         Rep *Next() {
 317             typename Arc::entry_type* entry = m_arc.GetNextEntry();
 318             if (!entry) {
 319                 UnRef();
 320                 return NULL;
 321             }
 322             if (m_ref > 1) {
 323                 m_ref--;
 324                 return new Rep(m_arc, entry);
 325             }
 326             delete m_entry;
 327             m_entry = entry;
 328             m_value = T();
 329             return this;
 330         }
 331
 332         const T& GetValue() {
 333             if (m_entry) {
 334                 _wxSetArchiveIteratorValue(m_value, m_entry, m_entry);
 335                 m_entry = NULL;
 336             }
 337             return m_value;
 338         }
 339     } *m_rep;
 340 };
 341
 342 typedef wxArchiveIterator<wxArchiveInputStream> wxArchiveIter;
 343 typedef wxArchiveIterator<wxArchiveInputStream,
 344         std::pair<wxString, wxArchiveEntry*> >  wxArchivePairIter;
 345
 346 #endif // wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
 347
 348 #endif // wxUSE_STREAMS
 349
 350 #endif // _WX_ARCHIVE_H__