Sorry, should be a __UNIX__ test
[wxWidgets.git] / 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_STREAMS && wxUSE_ARCHIVE_STREAMS
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 wxArchiveEntry(const wxArchiveEntry& e) : wxObject(e), m_notifier(NULL) { }
71
72 virtual void SetOffset(wxFileOffset offset) = 0;
73 virtual wxArchiveEntry* DoClone() const = 0;
74
75 wxArchiveNotifier *GetNotifier() const { return m_notifier; }
76 wxArchiveEntry& operator=(const wxArchiveEntry& entry);
77
78 private:
79 wxArchiveNotifier *m_notifier;
80
81 DECLARE_ABSTRACT_CLASS(wxArchiveEntry)
82 };
83
84
85 /////////////////////////////////////////////////////////////////////////////
86 // wxArchiveInputStream
87 //
88 // GetNextEntry() returns an wxArchiveEntry object containing the meta-data
89 // for the next entry in the archive (and gives away ownership). Reading from
90 // the wxArchiveInputStream then returns the entry's data. Eof() becomes true
91 // after an attempt has been made to read past the end of the entry's data.
92 //
93 // When there are no more entries, GetNextEntry() returns NULL and sets Eof().
94
95 class WXDLLIMPEXP_BASE wxArchiveInputStream : public wxFilterInputStream
96 {
97 public:
98 typedef wxArchiveEntry entry_type;
99
100 virtual ~wxArchiveInputStream() { }
101
102 virtual bool OpenEntry(wxArchiveEntry& entry) = 0;
103 virtual bool CloseEntry() = 0;
104
105 wxArchiveEntry *GetNextEntry() { return DoGetNextEntry(); }
106
107 virtual char Peek() { return wxInputStream::Peek(); }
108
109 protected:
110 wxArchiveInputStream(wxInputStream& stream, wxMBConv& conv);
111
112 virtual wxArchiveEntry *DoGetNextEntry() = 0;
113
114 wxMBConv& GetConv() const { return m_conv; }
115
116 private:
117 wxMBConv& m_conv;
118 };
119
120
121 /////////////////////////////////////////////////////////////////////////////
122 // wxArchiveOutputStream
123 //
124 // PutNextEntry is used to create a new entry in the output archive, then
125 // the entry's data is written to the wxArchiveOutputStream.
126 //
127 // Only one entry can be open for output at a time; another call to
128 // PutNextEntry closes the current entry and begins the next.
129 //
130 // The overload 'bool PutNextEntry(wxArchiveEntry *entry)' takes ownership
131 // of the entry object.
132
133 class WXDLLIMPEXP_BASE wxArchiveOutputStream : public wxFilterOutputStream
134 {
135 public:
136 virtual ~wxArchiveOutputStream() { }
137
138 virtual bool PutNextEntry(wxArchiveEntry *entry) = 0;
139
140 virtual bool PutNextEntry(const wxString& name,
141 const wxDateTime& dt = wxDateTime::Now(),
142 wxFileOffset size = wxInvalidOffset) = 0;
143
144 virtual bool PutNextDirEntry(const wxString& name,
145 const wxDateTime& dt = wxDateTime::Now()) = 0;
146
147 virtual bool CopyEntry(wxArchiveEntry *entry,
148 wxArchiveInputStream& stream) = 0;
149
150 virtual bool CopyArchiveMetaData(wxArchiveInputStream& stream) = 0;
151
152 virtual bool CloseEntry() = 0;
153
154 protected:
155 wxArchiveOutputStream(wxOutputStream& stream, wxMBConv& conv);
156
157 wxMBConv& GetConv() const { return m_conv; }
158
159 private:
160 wxMBConv& m_conv;
161 };
162
163
164 /////////////////////////////////////////////////////////////////////////////
165 // wxArchiveIterator
166 //
167 // An input iterator that can be used to transfer an archive's catalog to
168 // a container.
169
170 #if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
171 #include <iterator>
172 #include <utility>
173
174 template <class X, class Y> inline
175 void _wxSetArchiveIteratorValue(
176 X& val, Y entry, void *WXUNUSED(d))
177 {
178 val = X(entry);
179 }
180 template <class X, class Y, class Z> inline
181 void _wxSetArchiveIteratorValue(
182 std::pair<X, Y>& val, Z entry, Z WXUNUSED(d))
183 {
184 val = std::make_pair(X(entry->GetInternalName()), Y(entry));
185 }
186
187 #if defined _MSC_VER && _MSC_VER < 1300
188 template <class Arc, class T = Arc::entry_type*>
189 #else
190 template <class Arc, class T = typename Arc::entry_type*>
191 #endif
192 class wxArchiveIterator
193 {
194 public:
195 typedef std::input_iterator_tag iterator_category;
196 typedef T value_type;
197 typedef ptrdiff_t difference_type;
198 typedef T* pointer;
199 typedef T& reference;
200
201 wxArchiveIterator() : m_rep(NULL) { }
202
203 wxArchiveIterator(Arc& arc) {
204 typename Arc::entry_type* entry = arc.GetNextEntry();
205 m_rep = entry ? new Rep(arc, entry) : NULL;
206 }
207
208 wxArchiveIterator(const wxArchiveIterator& it) : m_rep(it.m_rep) {
209 if (m_rep)
210 m_rep->AddRef();
211 }
212
213 ~wxArchiveIterator() {
214 if (m_rep)
215 m_rep->UnRef();
216 }
217
218 const T& operator *() const {
219 return m_rep->GetValue();
220 }
221
222 const T* operator ->() const {
223 return &**this;
224 }
225
226 wxArchiveIterator& operator =(const wxArchiveIterator& it) {
227 if (it.m_rep)
228 it.m_rep.AddRef();
229 if (m_rep)
230 m_rep.UnRef();
231 m_rep = it.m_rep;
232 return *this;
233 }
234
235 wxArchiveIterator& operator ++() {
236 m_rep = m_rep->Next();
237 return *this;
238 }
239
240 wxArchiveIterator operator ++(int) {
241 wxArchiveIterator it(*this);
242 ++(*this);
243 return it;
244 }
245
246 bool operator ==(const wxArchiveIterator& j) const {
247 return m_rep == j.m_rep;
248 }
249
250 bool operator !=(const wxArchiveIterator& j) const {
251 return !(*this == j);
252 }
253
254 private:
255 class Rep {
256 Arc& m_arc;
257 typename Arc::entry_type* m_entry;
258 T m_value;
259 int m_ref;
260
261 public:
262 Rep(Arc& arc, typename Arc::entry_type* entry)
263 : m_arc(arc), m_entry(entry), m_value(), m_ref(1) { }
264 ~Rep()
265 { delete m_entry; }
266
267 void AddRef() {
268 m_ref++;
269 }
270
271 void UnRef() {
272 if (--m_ref == 0)
273 delete this;
274 }
275
276 Rep *Next() {
277 typename Arc::entry_type* entry = m_arc.GetNextEntry();
278 if (!entry) {
279 UnRef();
280 return NULL;
281 }
282 if (m_ref > 1) {
283 m_ref--;
284 return new Rep(m_arc, entry);
285 }
286 delete m_entry;
287 m_entry = entry;
288 m_value = T();
289 return this;
290 }
291
292 const T& GetValue() {
293 if (m_entry) {
294 _wxSetArchiveIteratorValue(m_value, m_entry, m_entry);
295 m_entry = NULL;
296 }
297 return m_value;
298 }
299 } *m_rep;
300 };
301
302 typedef wxArchiveIterator<wxArchiveInputStream> wxArchiveIter;
303 typedef wxArchiveIterator<wxArchiveInputStream,
304 std::pair<wxString, wxArchiveEntry*> > wxArchivePairIter;
305
306 #endif // wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
307
308
309 /////////////////////////////////////////////////////////////////////////////
310 // wxArchiveClassFactory
311 //
312 // A wxArchiveClassFactory instance for a particular archive type allows
313 // the creation of the other classes that may be needed.
314
315 class WXDLLIMPEXP_BASE wxArchiveClassFactory : public wxObject
316 {
317 public:
318 typedef wxArchiveEntry entry_type;
319 typedef wxArchiveInputStream instream_type;
320 typedef wxArchiveOutputStream outstream_type;
321 typedef wxArchiveNotifier notifier_type;
322 #if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
323 typedef wxArchiveIter iter_type;
324 typedef wxArchivePairIter pairiter_type;
325 #endif
326
327 virtual ~wxArchiveClassFactory() { }
328
329 wxArchiveEntry *NewEntry() const
330 { return DoNewEntry(); }
331 wxArchiveInputStream *NewStream(wxInputStream& stream) const
332 { return DoNewStream(stream); }
333 wxArchiveOutputStream *NewStream(wxOutputStream& stream) const
334 { return DoNewStream(stream); }
335
336 virtual wxString GetInternalName(
337 const wxString& name,
338 wxPathFormat format = wxPATH_NATIVE) const = 0;
339
340 void SetConv(wxMBConv& conv) { m_pConv = &conv; }
341 wxMBConv& GetConv() const { return *m_pConv; }
342
343 protected:
344 virtual wxArchiveEntry *DoNewEntry() const = 0;
345 virtual wxArchiveInputStream *DoNewStream(wxInputStream& stream) const = 0;
346 virtual wxArchiveOutputStream *DoNewStream(wxOutputStream& stream) const = 0;
347
348 wxArchiveClassFactory() : m_pConv(&wxConvLocal) { }
349 wxArchiveClassFactory& operator=(const wxArchiveClassFactory& WXUNUSED(f))
350 { return *this; }
351
352 private:
353 wxMBConv *m_pConv;
354
355 DECLARE_ABSTRACT_CLASS(wxArchiveClassFactory)
356 };
357
358 #endif // wxUSE_STREAMS && wxUSE_ARCHIVE_STREAMS
359
360 #endif // _WX_ARCHIVE_H__