src/common/fs_arc.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        fs_arc.cpp
// Purpose:     wxArchive file system
// Author:      Vaclav Slavik, Mike Wetherell
// Copyright:   (c) 1999 Vaclav Slavik, (c) 2006 Mike Wetherell
// CVS-ID:      $Id: fs_arc.cpp 51495 2008-02-01 16:44:56Z MW $
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#if wxUSE_FS_ARCHIVE

#include "wx/fs_arc.h"

#ifndef WXPRECOMP
    #include "wx/intl.h"
    #include "wx/log.h"
#endif

#if WXWIN_COMPATIBILITY_2_6 && wxUSE_ZIPSTREAM
    #include "wx/zipstrm.h"
#else
    #include "wx/archive.h"
#endif

#include "wx/private/fileback.h"

//---------------------------------------------------------------------------
// wxArchiveFSCacheDataImpl
//
// Holds the catalog of an archive file, and if it is being read from a
// non-seekable stream, a copy of its backing file.
//
// This class is actually the reference counted implementation for the
// wxArchiveFSCacheData class below. It was done that way to allow sharing
// between instances of wxFileSystem, though that's a feature not used in this
// version.
//---------------------------------------------------------------------------

WX_DECLARE_STRING_HASH_MAP(wxArchiveEntry*, wxArchiveFSEntryHash);

struct wxArchiveFSEntry
{
    wxArchiveEntry *entry;
    wxArchiveFSEntry *next;
};

class wxArchiveFSCacheDataImpl
{
public:
    wxArchiveFSCacheDataImpl(const wxArchiveClassFactory& factory,
                             const wxBackingFile& backer);
    wxArchiveFSCacheDataImpl(const wxArchiveClassFactory& factory,
                             wxInputStream *stream);

    ~wxArchiveFSCacheDataImpl();

    void Release() { if (--m_refcount == 0) delete this; }
    wxArchiveFSCacheDataImpl *AddRef() { m_refcount++; return this; }

    wxArchiveEntry *Get(const wxString& name);
    wxInputStream *NewStream() const;

    wxArchiveFSEntry *GetNext(wxArchiveFSEntry *fse);

private:
    wxArchiveFSEntry *AddToCache(wxArchiveEntry *entry);
    void CloseStreams();

    int m_refcount;

    wxArchiveFSEntryHash m_hash;
    wxArchiveFSEntry *m_begin;
    wxArchiveFSEntry **m_endptr;

    wxBackingFile m_backer;
    wxInputStream *m_stream;
    wxArchiveInputStream *m_archive;
};

wxArchiveFSCacheDataImpl::wxArchiveFSCacheDataImpl(
        const wxArchiveClassFactory& factory,
        const wxBackingFile& backer)
 :  m_refcount(1),
    m_begin(NULL),
    m_endptr(&m_begin),
    m_backer(backer),
    m_stream(new wxBackedInputStream(backer)),
    m_archive(factory.NewStream(*m_stream))
{
}

wxArchiveFSCacheDataImpl::wxArchiveFSCacheDataImpl(
        const wxArchiveClassFactory& factory,
        wxInputStream *stream)
 :  m_refcount(1),
    m_begin(NULL),
    m_endptr(&m_begin),
    m_stream(stream),
    m_archive(factory.NewStream(*m_stream))
{
}

wxArchiveFSCacheDataImpl::~wxArchiveFSCacheDataImpl()
{
    WX_CLEAR_HASH_MAP(wxArchiveFSEntryHash, m_hash);

    wxArchiveFSEntry *entry = m_begin;

    while (entry)
    {
        wxArchiveFSEntry *next = entry->next;
        delete entry;
        entry = next;
    }

    CloseStreams();
}

wxArchiveFSEntry *wxArchiveFSCacheDataImpl::AddToCache(wxArchiveEntry *entry)
{
    m_hash[entry->GetName(wxPATH_UNIX)] = entry;
    wxArchiveFSEntry *fse = new wxArchiveFSEntry;
    *m_endptr = fse;
    (*m_endptr)->entry = entry;
    (*m_endptr)->next = NULL;
    m_endptr = &(*m_endptr)->next;
    return fse;
}

void wxArchiveFSCacheDataImpl::CloseStreams()
{
    delete m_archive;
    m_archive = NULL;
    delete m_stream;
    m_stream = NULL;
}

wxArchiveEntry *wxArchiveFSCacheDataImpl::Get(const wxString& name)
{
    wxArchiveFSEntryHash::iterator it = m_hash.find(name);

    if (it != m_hash.end())
        return it->second;

    if (!m_archive)
        return NULL;

    wxArchiveEntry *entry;

    while ((entry = m_archive->GetNextEntry()) != NULL)
    {
        AddToCache(entry);

        if (entry->GetName(wxPATH_UNIX) == name)
            return entry;
    }

    CloseStreams();

    return NULL;
}

wxInputStream* wxArchiveFSCacheDataImpl::NewStream() const
{
    if (m_backer)
        return new wxBackedInputStream(m_backer);
    else
        return NULL;
}

wxArchiveFSEntry *wxArchiveFSCacheDataImpl::GetNext(wxArchiveFSEntry *fse)
{
    wxArchiveFSEntry *next = fse ? fse->next : m_begin;

    if (!next && m_archive)
    {
        wxArchiveEntry *entry = m_archive->GetNextEntry();

        if (entry)
            next = AddToCache(entry);
        else
            CloseStreams();
    }

    return next;
}

//---------------------------------------------------------------------------
// wxArchiveFSCacheData
//
// This is the inteface for wxArchiveFSCacheDataImpl above. Holds the catalog
// of an archive file, and if it is being read from a non-seekable stream, a
// copy of its backing file.
//---------------------------------------------------------------------------

class wxArchiveFSCacheData
{
public:
    wxArchiveFSCacheData() : m_impl(NULL) { }
    wxArchiveFSCacheData(const wxArchiveClassFactory& factory,
                         const wxBackingFile& backer);
    wxArchiveFSCacheData(const wxArchiveClassFactory& factory,
                         wxInputStream *stream);

    wxArchiveFSCacheData(const wxArchiveFSCacheData& data);
    wxArchiveFSCacheData& operator=(const wxArchiveFSCacheData& data);

    ~wxArchiveFSCacheData() { if (m_impl) m_impl->Release(); }

    wxArchiveEntry *Get(const wxString& name) { return m_impl->Get(name); }
    wxInputStream *NewStream() const { return m_impl->NewStream(); }
    wxArchiveFSEntry *GetNext(wxArchiveFSEntry *fse)
        { return m_impl->GetNext(fse); }

private:
    wxArchiveFSCacheDataImpl *m_impl;
};

wxArchiveFSCacheData::wxArchiveFSCacheData(
        const wxArchiveClassFactory& factory,
        const wxBackingFile& backer)
  : m_impl(new wxArchiveFSCacheDataImpl(factory, backer))
{
}

wxArchiveFSCacheData::wxArchiveFSCacheData(
        const wxArchiveClassFactory& factory,
        wxInputStream *stream)
  : m_impl(new wxArchiveFSCacheDataImpl(factory, stream))
{
}

wxArchiveFSCacheData::wxArchiveFSCacheData(const wxArchiveFSCacheData& data)
  : m_impl(data.m_impl ? data.m_impl->AddRef() : NULL)
{
}

wxArchiveFSCacheData& wxArchiveFSCacheData::operator=(
        const wxArchiveFSCacheData& data)
{
    if (data.m_impl != m_impl)
    {
        if (m_impl)
            m_impl->Release();

        m_impl = data.m_impl;

        if (m_impl)
            m_impl->AddRef();
    }

    return *this;
}

//---------------------------------------------------------------------------
// wxArchiveFSCache
//
// wxArchiveFSCacheData caches a single archive, and this class holds a
// collection of them to cache all the archives accessed by this instance
// of wxFileSystem.
//---------------------------------------------------------------------------

WX_DECLARE_STRING_HASH_MAP(wxArchiveFSCacheData, wxArchiveFSCacheDataHash);

class wxArchiveFSCache
{
public:
    wxArchiveFSCache() { }
    ~wxArchiveFSCache() { }

    wxArchiveFSCacheData* Add(const wxString& name,
                              const wxArchiveClassFactory& factory,
                              wxInputStream *stream);

    wxArchiveFSCacheData *Get(const wxString& name);

private:
    wxArchiveFSCacheDataHash m_hash;
};

wxArchiveFSCacheData* wxArchiveFSCache::Add(
        const wxString& name,
        const wxArchiveClassFactory& factory,
        wxInputStream *stream)
{
    wxArchiveFSCacheData& data = m_hash[name];

    if (stream->IsSeekable())
        data = wxArchiveFSCacheData(factory, stream);
    else
        data = wxArchiveFSCacheData(factory, wxBackingFile(stream));

    return &data;
}

wxArchiveFSCacheData *wxArchiveFSCache::Get(const wxString& name)
{
    wxArchiveFSCacheDataHash::iterator it;

    if ((it = m_hash.find(name)) != m_hash.end())
        return &it->second;

    return NULL;
}

//----------------------------------------------------------------------------
// wxArchiveFSHandler
//----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxArchiveFSHandler, wxFileSystemHandler)

wxArchiveFSHandler::wxArchiveFSHandler()
 :  wxFileSystemHandler()
{
    m_Archive = NULL;
    m_FindEntry = NULL;
    m_ZipFile = m_Pattern = m_BaseDir = wxEmptyString;
    m_AllowDirs = m_AllowFiles = true;
    m_DirsFound = NULL;
    m_cache = NULL;
}

wxArchiveFSHandler::~wxArchiveFSHandler()
{
    Cleanup();
    delete m_cache;
}

void wxArchiveFSHandler::Cleanup()
{
    wxDELETE(m_DirsFound);
}

bool wxArchiveFSHandler::CanOpen(const wxString& location)
{
    wxString p = GetProtocol(location);
    return wxArchiveClassFactory::Find(p) != NULL;
}

wxFSFile* wxArchiveFSHandler::OpenFile(
        wxFileSystem& WXUNUSED(fs),
        const wxString& location)
{
    wxString right = GetRightLocation(location);
    wxString left = GetLeftLocation(location);
    wxString protocol = GetProtocol(location);
    wxString key = left + wxT("#") + protocol + wxT(":");

    if (right.Contains(wxT("./")))
    {
        if (right.GetChar(0) != wxT('/')) right = wxT('/') + right;
        wxFileName rightPart(right, wxPATH_UNIX);
        rightPart.Normalize(wxPATH_NORM_DOTS, wxT("/"), wxPATH_UNIX);
        right = rightPart.GetFullPath(wxPATH_UNIX);
    }

    if (right.GetChar(0) == wxT('/')) right = right.Mid(1);

    if (!m_cache)
        m_cache = new wxArchiveFSCache;

    const wxArchiveClassFactory *factory;
    factory = wxArchiveClassFactory::Find(protocol);
    if (!factory)
        return NULL;

    wxArchiveFSCacheData *cached = m_cache->Get(key);
    if (!cached)
    {
        wxFSFile *leftFile = m_fs.OpenFile(left);
        if (!leftFile)
            return NULL;
        cached = m_cache->Add(key, *factory, leftFile->DetachStream());
        delete leftFile;
    }

    wxArchiveEntry *entry = cached->Get(right);
    if (!entry)
        return NULL;

    wxInputStream *leftStream = cached->NewStream();
    if (!leftStream)
    {
        wxFSFile *leftFile = m_fs.OpenFile(left);
        if (!leftFile)
            return NULL;
        leftStream = leftFile->DetachStream();
        delete leftFile;
    }

    wxArchiveInputStream *s = factory->NewStream(leftStream);
    s->OpenEntry(*entry);

    if (s && s->IsOk())
    {
#if WXWIN_COMPATIBILITY_2_6 && wxUSE_ZIPSTREAM
        if (factory->IsKindOf(CLASSINFO(wxZipClassFactory)))
            ((wxZipInputStream*)s)->m_allowSeeking = true;
#endif // WXWIN_COMPATIBILITY_2_6

        return new wxFSFile(s,
                            key + right,
                            GetMimeTypeFromExt(location),
                            GetAnchor(location)
#if wxUSE_DATETIME
                            , entry->GetDateTime()
#endif // wxUSE_DATETIME
                            );
    }

    delete s;
    return NULL;
}

wxString wxArchiveFSHandler::FindFirst(const wxString& spec, int flags)
{
    wxString right = GetRightLocation(spec);
    wxString left = GetLeftLocation(spec);
    wxString protocol = GetProtocol(spec);
    wxString key = left + wxT("#") + protocol + wxT(":");

    if (!right.empty() && right.Last() == wxT('/')) right.RemoveLast();

    if (!m_cache)
        m_cache = new wxArchiveFSCache;

    const wxArchiveClassFactory *factory;
    factory = wxArchiveClassFactory::Find(protocol);
    if (!factory)
        return wxEmptyString;

    m_Archive = m_cache->Get(key);
    if (!m_Archive)
    {
        wxFSFile *leftFile = m_fs.OpenFile(left);
        if (!leftFile)
            return wxEmptyString;
        m_Archive = m_cache->Add(key, *factory, leftFile->DetachStream());
        delete leftFile;
    }

    m_FindEntry = NULL;

    switch (flags)
    {
        case wxFILE:
            m_AllowDirs = false, m_AllowFiles = true; break;
        case wxDIR:
            m_AllowDirs = true, m_AllowFiles = false; break;
        default:
            m_AllowDirs = m_AllowFiles = true; break;
    }

    m_ZipFile = key;

    m_Pattern = right.AfterLast(wxT('/'));
    m_BaseDir = right.BeforeLast(wxT('/'));
    if (m_BaseDir.StartsWith(wxT("/")))
        m_BaseDir = m_BaseDir.Mid(1);

    if (m_Archive)
    {
        if (m_AllowDirs)
        {
            delete m_DirsFound;
            m_DirsFound = new wxArchiveFilenameHashMap();
            if (right.empty())  // allow "/" to match the archive root
                return spec;
        }
        return DoFind();
    }
    return wxEmptyString;
}

wxString wxArchiveFSHandler::FindNext()
{
    if (!m_Archive) return wxEmptyString;
    return DoFind();
}

wxString wxArchiveFSHandler::DoFind()
{
    wxString namestr, dir, filename;
    wxString match = wxEmptyString;

    while (match == wxEmptyString)
    {
        m_FindEntry = m_Archive->GetNext(m_FindEntry);

        if (!m_FindEntry)
        {
            m_Archive = NULL;
            m_FindEntry = NULL;
            break;
        }
        namestr = m_FindEntry->entry->GetName(wxPATH_UNIX);

        if (m_AllowDirs)
        {
            dir = namestr.BeforeLast(wxT('/'));
            while (!dir.empty())
            {
                if( m_DirsFound->find(dir) == m_DirsFound->end() )
                {
                    (*m_DirsFound)[dir] = 1;
                    filename = dir.AfterLast(wxT('/'));
                    dir = dir.BeforeLast(wxT('/'));
                    if (!filename.empty() && m_BaseDir == dir &&
                                wxMatchWild(m_Pattern, filename, false))
                        match = m_ZipFile + dir + wxT("/") + filename;
                }
                else
                    break; // already tranversed
            }
        }

        filename = namestr.AfterLast(wxT('/'));
        dir = namestr.BeforeLast(wxT('/'));
        if (m_AllowFiles && !filename.empty() && m_BaseDir == dir &&
                            wxMatchWild(m_Pattern, filename, false))
            match = m_ZipFile + namestr;
    }

    return match;
}

#endif // wxUSE_FS_ARCHIVE
1	william	31	/////////////////////////////////////////////////////////////////////////////
2			// Name: 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			// CVS-ID: $Id: fs_arc.cpp 51495 2008-02-01 16:44:56Z MW $
7			// Licence: wxWindows licence
8			/////////////////////////////////////////////////////////////////////////////
9
10			#include "wx/wxprec.h"
11
12			#ifdef __BORLANDC__
13			#pragma hdrstop
14			#endif
15
16			#if wxUSE_FS_ARCHIVE
17
18			#include "wx/fs_arc.h"
19
20			#ifndef WXPRECOMP
21			#include "wx/intl.h"
22			#include "wx/log.h"
23			#endif
24
25			#if WXWIN_COMPATIBILITY_2_6 && wxUSE_ZIPSTREAM
26			#include "wx/zipstrm.h"
27			#else
28			#include "wx/archive.h"
29			#endif
30
31			#include "wx/private/fileback.h"
32
33			//---------------------------------------------------------------------------
34			// wxArchiveFSCacheDataImpl
35			//
36			// Holds the catalog of an archive file, and if it is being read from a
37			// non-seekable stream, a copy of its backing file.
38			//
39			// This class is actually the reference counted implementation for the
40			// wxArchiveFSCacheData class below. It was done that way to allow sharing
41			// between instances of wxFileSystem, though that's a feature not used in this
42			// version.
43			//---------------------------------------------------------------------------
44
45			WX_DECLARE_STRING_HASH_MAP(wxArchiveEntry*, wxArchiveFSEntryHash);
46
47			struct wxArchiveFSEntry
48			{
49			wxArchiveEntry *entry;
50			wxArchiveFSEntry *next;
51			};
52
53			class wxArchiveFSCacheDataImpl
54			{
55			public:
56			wxArchiveFSCacheDataImpl(const wxArchiveClassFactory& factory,
57			const wxBackingFile& backer);
58			wxArchiveFSCacheDataImpl(const wxArchiveClassFactory& factory,
59			wxInputStream *stream);
60
61			~wxArchiveFSCacheDataImpl();
62
63			void Release() { if (--m_refcount == 0) delete this; }
64			wxArchiveFSCacheDataImpl *AddRef() { m_refcount++; return this; }
65
66			wxArchiveEntry *Get(const wxString& name);
67			wxInputStream *NewStream() const;
68
69			wxArchiveFSEntry GetNext(wxArchiveFSEntry fse);
70
71			private:
72			wxArchiveFSEntry AddToCache(wxArchiveEntry entry);
73			void CloseStreams();
74
75			int m_refcount;
76
77			wxArchiveFSEntryHash m_hash;
78			wxArchiveFSEntry *m_begin;
79			wxArchiveFSEntry **m_endptr;
80
81			wxBackingFile m_backer;
82			wxInputStream *m_stream;
83			wxArchiveInputStream *m_archive;
84			};
85
86			wxArchiveFSCacheDataImpl::wxArchiveFSCacheDataImpl(
87			const wxArchiveClassFactory& factory,
88			const wxBackingFile& backer)
89			: m_refcount(1),
90			m_begin(NULL),
91			m_endptr(&m_begin),
92			m_backer(backer),
93			m_stream(new wxBackedInputStream(backer)),
94			m_archive(factory.NewStream(*m_stream))
95			{
96			}
97
98			wxArchiveFSCacheDataImpl::wxArchiveFSCacheDataImpl(
99			const wxArchiveClassFactory& factory,
100			wxInputStream *stream)
101			: m_refcount(1),
102			m_begin(NULL),
103			m_endptr(&m_begin),
104			m_stream(stream),
105			m_archive(factory.NewStream(*m_stream))
106			{
107			}
108
109			wxArchiveFSCacheDataImpl::~wxArchiveFSCacheDataImpl()
110			{
111			WX_CLEAR_HASH_MAP(wxArchiveFSEntryHash, m_hash);
112
113			wxArchiveFSEntry *entry = m_begin;
114
115			while (entry)
116			{
117			wxArchiveFSEntry *next = entry->next;
118			delete entry;
119			entry = next;
120			}
121
122			CloseStreams();
123			}
124
125			wxArchiveFSEntry wxArchiveFSCacheDataImpl::AddToCache(wxArchiveEntry entry)
126			{
127			m_hash[entry->GetName(wxPATH_UNIX)] = entry;
128			wxArchiveFSEntry *fse = new wxArchiveFSEntry;
129			*m_endptr = fse;
130			(*m_endptr)->entry = entry;
131			(*m_endptr)->next = NULL;
132			m_endptr = &(*m_endptr)->next;
133			return fse;
134			}
135
136			void wxArchiveFSCacheDataImpl::CloseStreams()
137			{
138			delete m_archive;
139			m_archive = NULL;
140			delete m_stream;
141			m_stream = NULL;
142			}
143
144			wxArchiveEntry *wxArchiveFSCacheDataImpl::Get(const wxString& name)
145			{
146			wxArchiveFSEntryHash::iterator it = m_hash.find(name);
147
148			if (it != m_hash.end())
149			return it->second;
150
151			if (!m_archive)
152			return NULL;
153
154			wxArchiveEntry *entry;
155
156			while ((entry = m_archive->GetNextEntry()) != NULL)
157			{
158			AddToCache(entry);
159
160			if (entry->GetName(wxPATH_UNIX) == name)
161			return entry;
162			}
163
164			CloseStreams();
165
166			return NULL;
167			}
168
169			wxInputStream* wxArchiveFSCacheDataImpl::NewStream() const
170			{
171			if (m_backer)
172			return new wxBackedInputStream(m_backer);
173			else
174			return NULL;
175			}
176
177			wxArchiveFSEntry wxArchiveFSCacheDataImpl::GetNext(wxArchiveFSEntry fse)
178			{
179			wxArchiveFSEntry *next = fse ? fse->next : m_begin;
180
181			if (!next && m_archive)
182			{
183			wxArchiveEntry *entry = m_archive->GetNextEntry();
184
185			if (entry)
186			next = AddToCache(entry);
187			else
188			CloseStreams();
189			}
190
191			return next;
192			}
193
194			//---------------------------------------------------------------------------
195			// wxArchiveFSCacheData
196			//
197			// This is the inteface for wxArchiveFSCacheDataImpl above. Holds the catalog
198			// of an archive file, and if it is being read from a non-seekable stream, a
199			// copy of its backing file.
200			//---------------------------------------------------------------------------
201
202			class wxArchiveFSCacheData
203			{
204			public:
205			wxArchiveFSCacheData() : m_impl(NULL) { }
206			wxArchiveFSCacheData(const wxArchiveClassFactory& factory,
207			const wxBackingFile& backer);
208			wxArchiveFSCacheData(const wxArchiveClassFactory& factory,
209			wxInputStream *stream);
210
211			wxArchiveFSCacheData(const wxArchiveFSCacheData& data);
212			wxArchiveFSCacheData& operator=(const wxArchiveFSCacheData& data);
213
214			~wxArchiveFSCacheData() { if (m_impl) m_impl->Release(); }
215
216			wxArchiveEntry *Get(const wxString& name) { return m_impl->Get(name); }
217			wxInputStream *NewStream() const { return m_impl->NewStream(); }
218			wxArchiveFSEntry GetNext(wxArchiveFSEntry fse)
219			{ return m_impl->GetNext(fse); }
220
221			private:
222			wxArchiveFSCacheDataImpl *m_impl;
223			};
224
225			wxArchiveFSCacheData::wxArchiveFSCacheData(
226			const wxArchiveClassFactory& factory,
227			const wxBackingFile& backer)
228			: m_impl(new wxArchiveFSCacheDataImpl(factory, backer))
229			{
230			}
231
232			wxArchiveFSCacheData::wxArchiveFSCacheData(
233			const wxArchiveClassFactory& factory,
234			wxInputStream *stream)
235			: m_impl(new wxArchiveFSCacheDataImpl(factory, stream))
236			{
237			}
238
239			wxArchiveFSCacheData::wxArchiveFSCacheData(const wxArchiveFSCacheData& data)
240			: m_impl(data.m_impl ? data.m_impl->AddRef() : NULL)
241			{
242			}
243
244			wxArchiveFSCacheData& wxArchiveFSCacheData::operator=(
245			const wxArchiveFSCacheData& data)
246			{
247			if (data.m_impl != m_impl)
248			{
249			if (m_impl)
250			m_impl->Release();
251
252			m_impl = data.m_impl;
253
254			if (m_impl)
255			m_impl->AddRef();
256			}
257
258			return *this;
259			}
260
261			//---------------------------------------------------------------------------
262			// wxArchiveFSCache
263			//
264			// wxArchiveFSCacheData caches a single archive, and this class holds a
265			// collection of them to cache all the archives accessed by this instance
266			// of wxFileSystem.
267			//---------------------------------------------------------------------------
268
269			WX_DECLARE_STRING_HASH_MAP(wxArchiveFSCacheData, wxArchiveFSCacheDataHash);
270
271			class wxArchiveFSCache
272			{
273			public:
274			wxArchiveFSCache() { }
275			~wxArchiveFSCache() { }
276
277			wxArchiveFSCacheData* Add(const wxString& name,
278			const wxArchiveClassFactory& factory,
279			wxInputStream *stream);
280
281			wxArchiveFSCacheData *Get(const wxString& name);
282
283			private:
284			wxArchiveFSCacheDataHash m_hash;
285			};
286
287			wxArchiveFSCacheData* wxArchiveFSCache::Add(
288			const wxString& name,
289			const wxArchiveClassFactory& factory,
290			wxInputStream *stream)
291			{
292			wxArchiveFSCacheData& data = m_hash[name];
293
294			if (stream->IsSeekable())
295			data = wxArchiveFSCacheData(factory, stream);
296			else
297			data = wxArchiveFSCacheData(factory, wxBackingFile(stream));
298
299			return &data;
300			}
301
302			wxArchiveFSCacheData *wxArchiveFSCache::Get(const wxString& name)
303			{
304			wxArchiveFSCacheDataHash::iterator it;
305
306			if ((it = m_hash.find(name)) != m_hash.end())
307			return &it->second;
308
309			return NULL;
310			}
311
312			//----------------------------------------------------------------------------
313			// wxArchiveFSHandler
314			//----------------------------------------------------------------------------
315
316			IMPLEMENT_DYNAMIC_CLASS(wxArchiveFSHandler, wxFileSystemHandler)
317
318			wxArchiveFSHandler::wxArchiveFSHandler()
319			: wxFileSystemHandler()
320			{
321			m_Archive = NULL;
322			m_FindEntry = NULL;
323			m_ZipFile = m_Pattern = m_BaseDir = wxEmptyString;
324			m_AllowDirs = m_AllowFiles = true;
325			m_DirsFound = NULL;
326			m_cache = NULL;
327			}
328
329			wxArchiveFSHandler::~wxArchiveFSHandler()
330			{
331			Cleanup();
332			delete m_cache;
333			}
334
335			void wxArchiveFSHandler::Cleanup()
336			{
337			wxDELETE(m_DirsFound);
338			}
339
340			bool wxArchiveFSHandler::CanOpen(const wxString& location)
341			{
342			wxString p = GetProtocol(location);
343			return wxArchiveClassFactory::Find(p) != NULL;
344			}
345
346			wxFSFile* wxArchiveFSHandler::OpenFile(
347			wxFileSystem& WXUNUSED(fs),
348			const wxString& location)
349			{
350			wxString right = GetRightLocation(location);
351			wxString left = GetLeftLocation(location);
352			wxString protocol = GetProtocol(location);
353			wxString key = left + wxT("#") + protocol + wxT(":");
354
355			if (right.Contains(wxT("./")))
356			{
357			if (right.GetChar(0) != wxT('/')) right = wxT('/') + right;
358			wxFileName rightPart(right, wxPATH_UNIX);
359			rightPart.Normalize(wxPATH_NORM_DOTS, wxT("/"), wxPATH_UNIX);
360			right = rightPart.GetFullPath(wxPATH_UNIX);
361			}
362
363			if (right.GetChar(0) == wxT('/')) right = right.Mid(1);
364
365			if (!m_cache)
366			m_cache = new wxArchiveFSCache;
367
368			const wxArchiveClassFactory *factory;
369			factory = wxArchiveClassFactory::Find(protocol);
370			if (!factory)
371			return NULL;
372
373			wxArchiveFSCacheData *cached = m_cache->Get(key);
374			if (!cached)
375			{
376			wxFSFile *leftFile = m_fs.OpenFile(left);
377			if (!leftFile)
378			return NULL;
379			cached = m_cache->Add(key, *factory, leftFile->DetachStream());
380			delete leftFile;
381			}
382
383			wxArchiveEntry *entry = cached->Get(right);
384			if (!entry)
385			return NULL;
386
387			wxInputStream *leftStream = cached->NewStream();
388			if (!leftStream)
389			{
390			wxFSFile *leftFile = m_fs.OpenFile(left);
391			if (!leftFile)
392			return NULL;
393			leftStream = leftFile->DetachStream();
394			delete leftFile;
395			}
396
397			wxArchiveInputStream *s = factory->NewStream(leftStream);
398			s->OpenEntry(*entry);
399
400			if (s && s->IsOk())
401			{
402			#if WXWIN_COMPATIBILITY_2_6 && wxUSE_ZIPSTREAM
403			if (factory->IsKindOf(CLASSINFO(wxZipClassFactory)))
404			((wxZipInputStream*)s)->m_allowSeeking = true;
405			#endif // WXWIN_COMPATIBILITY_2_6
406
407			return new wxFSFile(s,
408			key + right,
409			GetMimeTypeFromExt(location),
410			GetAnchor(location)
411			#if wxUSE_DATETIME
412			, entry->GetDateTime()
413			#endif // wxUSE_DATETIME
414			);
415			}
416
417			delete s;
418			return NULL;
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