]> git.saurik.com Git - wxWidgets.git/blob - src/common/fs_arc.cpp
Remove all lines containing cvs/svn "$Id$" keyword.
[wxWidgets.git] / src / common / fs_arc.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/fs_arc.cpp
3 // Purpose: wxArchive file system
4 // Author: Vaclav Slavik, Mike Wetherell
5 // Copyright: (c) 1999 Vaclav Slavik, (c) 2006 Mike Wetherell
6 // Licence: wxWindows licence
7 /////////////////////////////////////////////////////////////////////////////
8
9 #include "wx/wxprec.h"
10
11 #ifdef __BORLANDC__
12 #pragma hdrstop
13 #endif
14
15 #if wxUSE_FS_ARCHIVE
16
17 #include "wx/fs_arc.h"
18
19 #ifndef WX_PRECOMP
20 #include "wx/intl.h"
21 #include "wx/log.h"
22 #endif
23
24 #if WXWIN_COMPATIBILITY_2_6 && wxUSE_ZIPSTREAM
25 #include "wx/zipstrm.h"
26 #else
27 #include "wx/archive.h"
28 #endif
29
30 #include "wx/private/fileback.h"
31
32 //---------------------------------------------------------------------------
33 // wxArchiveFSCacheDataImpl
34 //
35 // Holds the catalog of an archive file, and if it is being read from a
36 // non-seekable stream, a copy of its backing file.
37 //
38 // This class is actually the reference counted implementation for the
39 // wxArchiveFSCacheData class below. It was done that way to allow sharing
40 // between instances of wxFileSystem, though that's a feature not used in this
41 // version.
42 //---------------------------------------------------------------------------
43
44 WX_DECLARE_STRING_HASH_MAP(wxArchiveEntry*, wxArchiveFSEntryHash);
45
46 struct wxArchiveFSEntry
47 {
48 wxArchiveEntry *entry;
49 wxArchiveFSEntry *next;
50 };
51
52 class wxArchiveFSCacheDataImpl
53 {
54 public:
55 wxArchiveFSCacheDataImpl(const wxArchiveClassFactory& factory,
56 const wxBackingFile& backer);
57 wxArchiveFSCacheDataImpl(const wxArchiveClassFactory& factory,
58 wxInputStream *stream);
59
60 ~wxArchiveFSCacheDataImpl();
61
62 void Release() { if (--m_refcount == 0) delete this; }
63 wxArchiveFSCacheDataImpl *AddRef() { m_refcount++; return this; }
64
65 wxArchiveEntry *Get(const wxString& name);
66 wxInputStream *NewStream() const;
67
68 wxArchiveFSEntry *GetNext(wxArchiveFSEntry *fse);
69
70 private:
71 wxArchiveFSEntry *AddToCache(wxArchiveEntry *entry);
72 void CloseStreams();
73
74 int m_refcount;
75
76 wxArchiveFSEntryHash m_hash;
77 wxArchiveFSEntry *m_begin;
78 wxArchiveFSEntry **m_endptr;
79
80 wxBackingFile m_backer;
81 wxInputStream *m_stream;
82 wxArchiveInputStream *m_archive;
83 };
84
85 wxArchiveFSCacheDataImpl::wxArchiveFSCacheDataImpl(
86 const wxArchiveClassFactory& factory,
87 const wxBackingFile& backer)
88 : m_refcount(1),
89 m_begin(NULL),
90 m_endptr(&m_begin),
91 m_backer(backer),
92 m_stream(new wxBackedInputStream(backer)),
93 m_archive(factory.NewStream(*m_stream))
94 {
95 }
96
97 wxArchiveFSCacheDataImpl::wxArchiveFSCacheDataImpl(
98 const wxArchiveClassFactory& factory,
99 wxInputStream *stream)
100 : m_refcount(1),
101 m_begin(NULL),
102 m_endptr(&m_begin),
103 m_stream(stream),
104 m_archive(factory.NewStream(*m_stream))
105 {
106 }
107
108 wxArchiveFSCacheDataImpl::~wxArchiveFSCacheDataImpl()
109 {
110 WX_CLEAR_HASH_MAP(wxArchiveFSEntryHash, m_hash);
111
112 wxArchiveFSEntry *entry = m_begin;
113
114 while (entry)
115 {
116 wxArchiveFSEntry *next = entry->next;
117 delete entry;
118 entry = next;
119 }
120
121 CloseStreams();
122 }
123
124 wxArchiveFSEntry *wxArchiveFSCacheDataImpl::AddToCache(wxArchiveEntry *entry)
125 {
126 m_hash[entry->GetName(wxPATH_UNIX)] = entry;
127 wxArchiveFSEntry *fse = new wxArchiveFSEntry;
128 *m_endptr = fse;
129 (*m_endptr)->entry = entry;
130 (*m_endptr)->next = NULL;
131 m_endptr = &(*m_endptr)->next;
132 return fse;
133 }
134
135 void wxArchiveFSCacheDataImpl::CloseStreams()
136 {
137 wxDELETE(m_archive);
138 wxDELETE(m_stream);
139 }
140
141 wxArchiveEntry *wxArchiveFSCacheDataImpl::Get(const wxString& name)
142 {
143 wxArchiveFSEntryHash::iterator it = m_hash.find(name);
144
145 if (it != m_hash.end())
146 return it->second;
147
148 if (!m_archive)
149 return NULL;
150
151 wxArchiveEntry *entry;
152
153 while ((entry = m_archive->GetNextEntry()) != NULL)
154 {
155 AddToCache(entry);
156
157 if (entry->GetName(wxPATH_UNIX) == name)
158 return entry;
159 }
160
161 CloseStreams();
162
163 return NULL;
164 }
165
166 wxInputStream* wxArchiveFSCacheDataImpl::NewStream() const
167 {
168 if (m_backer)
169 return new wxBackedInputStream(m_backer);
170 else
171 return NULL;
172 }
173
174 wxArchiveFSEntry *wxArchiveFSCacheDataImpl::GetNext(wxArchiveFSEntry *fse)
175 {
176 wxArchiveFSEntry *next = fse ? fse->next : m_begin;
177
178 if (!next && m_archive)
179 {
180 wxArchiveEntry *entry = m_archive->GetNextEntry();
181
182 if (entry)
183 next = AddToCache(entry);
184 else
185 CloseStreams();
186 }
187
188 return next;
189 }
190
191 //---------------------------------------------------------------------------
192 // wxArchiveFSCacheData
193 //
194 // This is the inteface for wxArchiveFSCacheDataImpl above. Holds the catalog
195 // of an archive file, and if it is being read from a non-seekable stream, a
196 // copy of its backing file.
197 //---------------------------------------------------------------------------
198
199 class wxArchiveFSCacheData
200 {
201 public:
202 wxArchiveFSCacheData() : m_impl(NULL) { }
203 wxArchiveFSCacheData(const wxArchiveClassFactory& factory,
204 const wxBackingFile& backer);
205 wxArchiveFSCacheData(const wxArchiveClassFactory& factory,
206 wxInputStream *stream);
207
208 wxArchiveFSCacheData(const wxArchiveFSCacheData& data);
209 wxArchiveFSCacheData& operator=(const wxArchiveFSCacheData& data);
210
211 ~wxArchiveFSCacheData() { if (m_impl) m_impl->Release(); }
212
213 wxArchiveEntry *Get(const wxString& name) { return m_impl->Get(name); }
214 wxInputStream *NewStream() const { return m_impl->NewStream(); }
215 wxArchiveFSEntry *GetNext(wxArchiveFSEntry *fse)
216 { return m_impl->GetNext(fse); }
217
218 private:
219 wxArchiveFSCacheDataImpl *m_impl;
220 };
221
222 wxArchiveFSCacheData::wxArchiveFSCacheData(
223 const wxArchiveClassFactory& factory,
224 const wxBackingFile& backer)
225 : m_impl(new wxArchiveFSCacheDataImpl(factory, backer))
226 {
227 }
228
229 wxArchiveFSCacheData::wxArchiveFSCacheData(
230 const wxArchiveClassFactory& factory,
231 wxInputStream *stream)
232 : m_impl(new wxArchiveFSCacheDataImpl(factory, stream))
233 {
234 }
235
236 wxArchiveFSCacheData::wxArchiveFSCacheData(const wxArchiveFSCacheData& data)
237 : m_impl(data.m_impl ? data.m_impl->AddRef() : NULL)
238 {
239 }
240
241 wxArchiveFSCacheData& wxArchiveFSCacheData::operator=(
242 const wxArchiveFSCacheData& data)
243 {
244 if (data.m_impl != m_impl)
245 {
246 if (m_impl)
247 m_impl->Release();
248
249 m_impl = data.m_impl;
250
251 if (m_impl)
252 m_impl->AddRef();
253 }
254
255 return *this;
256 }
257
258 //---------------------------------------------------------------------------
259 // wxArchiveFSCache
260 //
261 // wxArchiveFSCacheData caches a single archive, and this class holds a
262 // collection of them to cache all the archives accessed by this instance
263 // of wxFileSystem.
264 //---------------------------------------------------------------------------
265
266 WX_DECLARE_STRING_HASH_MAP(wxArchiveFSCacheData, wxArchiveFSCacheDataHash);
267
268 class wxArchiveFSCache
269 {
270 public:
271 wxArchiveFSCache() { }
272 ~wxArchiveFSCache() { }
273
274 wxArchiveFSCacheData* Add(const wxString& name,
275 const wxArchiveClassFactory& factory,
276 wxInputStream *stream);
277
278 wxArchiveFSCacheData *Get(const wxString& name);
279
280 private:
281 wxArchiveFSCacheDataHash m_hash;
282 };
283
284 wxArchiveFSCacheData* wxArchiveFSCache::Add(
285 const wxString& name,
286 const wxArchiveClassFactory& factory,
287 wxInputStream *stream)
288 {
289 wxArchiveFSCacheData& data = m_hash[name];
290
291 if (stream->IsSeekable())
292 data = wxArchiveFSCacheData(factory, stream);
293 else
294 data = wxArchiveFSCacheData(factory, wxBackingFile(stream));
295
296 return &data;
297 }
298
299 wxArchiveFSCacheData *wxArchiveFSCache::Get(const wxString& name)
300 {
301 wxArchiveFSCacheDataHash::iterator it;
302
303 if ((it = m_hash.find(name)) != m_hash.end())
304 return &it->second;
305
306 return NULL;
307 }
308
309 //----------------------------------------------------------------------------
310 // wxArchiveFSHandler
311 //----------------------------------------------------------------------------
312
313 IMPLEMENT_DYNAMIC_CLASS(wxArchiveFSHandler, wxFileSystemHandler)
314
315 wxArchiveFSHandler::wxArchiveFSHandler()
316 : wxFileSystemHandler()
317 {
318 m_Archive = NULL;
319 m_FindEntry = NULL;
320 m_ZipFile = m_Pattern = m_BaseDir = wxEmptyString;
321 m_AllowDirs = m_AllowFiles = true;
322 m_DirsFound = NULL;
323 m_cache = NULL;
324 }
325
326 wxArchiveFSHandler::~wxArchiveFSHandler()
327 {
328 Cleanup();
329 delete m_cache;
330 }
331
332 void wxArchiveFSHandler::Cleanup()
333 {
334 wxDELETE(m_DirsFound);
335 }
336
337 bool wxArchiveFSHandler::CanOpen(const wxString& location)
338 {
339 wxString p = GetProtocol(location);
340 return wxArchiveClassFactory::Find(p) != NULL;
341 }
342
343 wxFSFile* wxArchiveFSHandler::OpenFile(
344 wxFileSystem& WXUNUSED(fs),
345 const wxString& location)
346 {
347 wxString right = GetRightLocation(location);
348 wxString left = GetLeftLocation(location);
349 wxString protocol = GetProtocol(location);
350 wxString key = left + wxT("#") + protocol + wxT(":");
351
352 if (right.Contains(wxT("./")))
353 {
354 if (right.GetChar(0) != wxT('/')) right = wxT('/') + right;
355 wxFileName rightPart(right, wxPATH_UNIX);
356 rightPart.Normalize(wxPATH_NORM_DOTS, wxT("/"), wxPATH_UNIX);
357 right = rightPart.GetFullPath(wxPATH_UNIX);
358 }
359
360 if (!right.empty() && right.GetChar(0) == wxT('/')) right = right.Mid(1);
361
362 if (!m_cache)
363 m_cache = new wxArchiveFSCache;
364
365 const wxArchiveClassFactory *factory;
366 factory = wxArchiveClassFactory::Find(protocol);
367 if (!factory)
368 return NULL;
369
370 wxArchiveFSCacheData *cached = m_cache->Get(key);
371 if (!cached)
372 {
373 wxFSFile *leftFile = m_fs.OpenFile(left);
374 if (!leftFile)
375 return NULL;
376 cached = m_cache->Add(key, *factory, leftFile->DetachStream());
377 delete leftFile;
378 }
379
380 wxArchiveEntry *entry = cached->Get(right);
381 if (!entry)
382 return NULL;
383
384 wxInputStream *leftStream = cached->NewStream();
385 if (!leftStream)
386 {
387 wxFSFile *leftFile = m_fs.OpenFile(left);
388 if (!leftFile)
389 return NULL;
390 leftStream = leftFile->DetachStream();
391 delete leftFile;
392 }
393
394 wxArchiveInputStream *s = factory->NewStream(leftStream);
395 if ( !s )
396 return NULL;
397
398 s->OpenEntry(*entry);
399
400 if (!s->IsOk())
401 {
402 delete s;
403 return NULL;
404 }
405
406 #if WXWIN_COMPATIBILITY_2_6 && wxUSE_ZIPSTREAM
407 if (wxDynamicCast(factory, wxZipClassFactory))
408 ((wxZipInputStream*)s)->m_allowSeeking = true;
409 #endif // WXWIN_COMPATIBILITY_2_6
410
411 return new wxFSFile(s,
412 key + right,
413 wxEmptyString,
414 GetAnchor(location)
415 #if wxUSE_DATETIME
416 , entry->GetDateTime()
417 #endif // wxUSE_DATETIME
418 );
419 }
420
421 wxString wxArchiveFSHandler::FindFirst(const wxString& spec, int flags)
422 {
423 wxString right = GetRightLocation(spec);
424 wxString left = GetLeftLocation(spec);
425 wxString protocol = GetProtocol(spec);
426 wxString key = left + wxT("#") + protocol + wxT(":");
427
428 if (!right.empty() && right.Last() == wxT('/')) right.RemoveLast();
429
430 if (!m_cache)
431 m_cache = new wxArchiveFSCache;
432
433 const wxArchiveClassFactory *factory;
434 factory = wxArchiveClassFactory::Find(protocol);
435 if (!factory)
436 return wxEmptyString;
437
438 m_Archive = m_cache->Get(key);
439 if (!m_Archive)
440 {
441 wxFSFile *leftFile = m_fs.OpenFile(left);
442 if (!leftFile)
443 return wxEmptyString;
444 m_Archive = m_cache->Add(key, *factory, leftFile->DetachStream());
445 delete leftFile;
446 }
447
448 m_FindEntry = NULL;
449
450 switch (flags)
451 {
452 case wxFILE:
453 m_AllowDirs = false, m_AllowFiles = true; break;
454 case wxDIR:
455 m_AllowDirs = true, m_AllowFiles = false; break;
456 default:
457 m_AllowDirs = m_AllowFiles = true; break;
458 }
459
460 m_ZipFile = key;
461
462 m_Pattern = right.AfterLast(wxT('/'));
463 m_BaseDir = right.BeforeLast(wxT('/'));
464 if (m_BaseDir.StartsWith(wxT("/")))
465 m_BaseDir = m_BaseDir.Mid(1);
466
467 if (m_Archive)
468 {
469 if (m_AllowDirs)
470 {
471 delete m_DirsFound;
472 m_DirsFound = new wxArchiveFilenameHashMap();
473 if (right.empty()) // allow "/" to match the archive root
474 return spec;
475 }
476 return DoFind();
477 }
478 return wxEmptyString;
479 }
480
481 wxString wxArchiveFSHandler::FindNext()
482 {
483 if (!m_Archive) return wxEmptyString;
484 return DoFind();
485 }
486
487 wxString wxArchiveFSHandler::DoFind()
488 {
489 wxString namestr, dir, filename;
490 wxString match = wxEmptyString;
491
492 while (match == wxEmptyString)
493 {
494 m_FindEntry = m_Archive->GetNext(m_FindEntry);
495
496 if (!m_FindEntry)
497 {
498 m_Archive = NULL;
499 m_FindEntry = NULL;
500 break;
501 }
502 namestr = m_FindEntry->entry->GetName(wxPATH_UNIX);
503
504 if (m_AllowDirs)
505 {
506 dir = namestr.BeforeLast(wxT('/'));
507 while (!dir.empty())
508 {
509 if( m_DirsFound->find(dir) == m_DirsFound->end() )
510 {
511 (*m_DirsFound)[dir] = 1;
512 filename = dir.AfterLast(wxT('/'));
513 dir = dir.BeforeLast(wxT('/'));
514 if (!filename.empty() && m_BaseDir == dir &&
515 wxMatchWild(m_Pattern, filename, false))
516 match = m_ZipFile + dir + wxT("/") + filename;
517 }
518 else
519 break; // already tranversed
520 }
521 }
522
523 filename = namestr.AfterLast(wxT('/'));
524 dir = namestr.BeforeLast(wxT('/'));
525 if (m_AllowFiles && !filename.empty() && m_BaseDir == dir &&
526 wxMatchWild(m_Pattern, filename, false))
527 match = m_ZipFile + namestr;
528 }
529
530 return match;
531 }
532
533 #endif // wxUSE_FS_ARCHIVE