[wxWidgets.git] / include / wx / archive.h

/////////////////////////////////////////////////////////////////////////////
// Name:        archive.h
// Purpose:     Streams for archive formats
// Author:      Mike Wetherell
// RCS-ID:      $Id$
// Copyright:   (c) 2004 Mike Wetherell
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifndef _WX_ARCHIVE_H__
#define _WX_ARCHIVE_H__

#include "wx/defs.h"

#if wxUSE_STREAMS && wxUSE_ARCHIVE_STREAMS

#include "wx/stream.h"
#include "wx/filename.h"


/////////////////////////////////////////////////////////////////////////////
// wxArchiveNotifier

class WXDLLIMPEXP_BASE wxArchiveNotifier
{
public:
    virtual ~wxArchiveNotifier() { }

    virtual void OnEntryUpdated(class wxArchiveEntry& entry) = 0;
};


/////////////////////////////////////////////////////////////////////////////
// wxArchiveEntry
//
// Holds an entry's meta data, such as filename and timestamp.

class WXDLLIMPEXP_BASE wxArchiveEntry : public wxObject
{
public:
    virtual ~wxArchiveEntry() { }

    virtual wxDateTime   GetDateTime() const = 0;
    virtual wxFileOffset GetSize() const = 0;
    virtual wxFileOffset GetOffset() const = 0;
    virtual bool         IsDir() const = 0;
    virtual bool         IsReadOnly() const = 0;
    virtual wxString     GetInternalName() const = 0;
    virtual wxPathFormat GetInternalFormat() const = 0;
    virtual wxString     GetName(wxPathFormat format = wxPATH_NATIVE) const = 0;

    virtual void SetDateTime(const wxDateTime& dt) = 0;
    virtual void SetSize(wxFileOffset size) = 0;
    virtual void SetIsDir(bool isDir = true) = 0;
    virtual void SetIsReadOnly(bool isReadOnly = true) = 0;
    virtual void SetName(const wxString& name,
                         wxPathFormat format = wxPATH_NATIVE) = 0;
    
    wxArchiveEntry *Clone() const { return DoClone(); }

    void SetNotifier(wxArchiveNotifier& notifier);
    virtual void UnsetNotifier() { m_notifier = NULL; }

protected:
    wxArchiveEntry() : m_notifier(NULL) { }
    wxArchiveEntry(const wxArchiveEntry& e) : wxObject(e), m_notifier(NULL) { }

    virtual void SetOffset(wxFileOffset offset) = 0;
    virtual wxArchiveEntry* DoClone() const = 0;

    wxArchiveNotifier *GetNotifier() const { return m_notifier; }
    wxArchiveEntry& operator=(const wxArchiveEntry& entry);

private:
    wxArchiveNotifier *m_notifier;

    DECLARE_ABSTRACT_CLASS(wxArchiveEntry)
};


/////////////////////////////////////////////////////////////////////////////
// wxArchiveInputStream
//
// GetNextEntry() returns an wxArchiveEntry object containing the meta-data
// for the next entry in the archive (and gives away ownership). Reading from
// the wxArchiveInputStream then returns the entry's data. Eof() becomes true
// after an attempt has been made to read past the end of the entry's data.
//
// When there are no more entries, GetNextEntry() returns NULL and sets Eof().

class WXDLLIMPEXP_BASE wxArchiveInputStream : public wxFilterInputStream
{
public:
    typedef wxArchiveEntry entry_type;

    virtual ~wxArchiveInputStream() { }
    
    virtual bool OpenEntry(wxArchiveEntry& entry) = 0;
    virtual bool CloseEntry() = 0;

    wxArchiveEntry *GetNextEntry()  { return DoGetNextEntry(); }

    virtual char Peek()             { return wxInputStream::Peek(); }
    
protected:
    wxArchiveInputStream(wxInputStream& stream, wxMBConv& conv);
    wxArchiveInputStream(wxInputStream *stream, wxMBConv& conv);

    virtual wxArchiveEntry *DoGetNextEntry() = 0;

    wxMBConv& GetConv() const       { return m_conv; }

private:
    wxMBConv& m_conv;
};


/////////////////////////////////////////////////////////////////////////////
// wxArchiveOutputStream
//
// PutNextEntry is used to create a new entry in the output archive, then
// the entry's data is written to the wxArchiveOutputStream.
//
// Only one entry can be open for output at a time; another call to
// PutNextEntry closes the current entry and begins the next.
// 
// The overload 'bool PutNextEntry(wxArchiveEntry *entry)' takes ownership
// of the entry object.

class WXDLLIMPEXP_BASE wxArchiveOutputStream : public wxFilterOutputStream
{
public:
    virtual ~wxArchiveOutputStream() { }

    virtual bool PutNextEntry(wxArchiveEntry *entry) = 0;

    virtual bool PutNextEntry(const wxString& name,
                              const wxDateTime& dt = wxDateTime::Now(),
                              wxFileOffset size = wxInvalidOffset) = 0;

    virtual bool PutNextDirEntry(const wxString& name,
                                 const wxDateTime& dt = wxDateTime::Now()) = 0;

    virtual bool CopyEntry(wxArchiveEntry *entry,
                           wxArchiveInputStream& stream) = 0;

    virtual bool CopyArchiveMetaData(wxArchiveInputStream& stream) = 0;

    virtual bool CloseEntry() = 0;

protected:
    wxArchiveOutputStream(wxOutputStream& stream, wxMBConv& conv);
    wxArchiveOutputStream(wxOutputStream *stream, wxMBConv& conv);

    wxMBConv& GetConv() const { return m_conv; }

private:
    wxMBConv& m_conv;
};


/////////////////////////////////////////////////////////////////////////////
// wxArchiveIterator
//
// An input iterator that can be used to transfer an archive's catalog to
// a container.

#if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
#include <iterator>
#include <utility>

template <class X, class Y> inline
void _wxSetArchiveIteratorValue(
    X& val, Y entry, void *WXUNUSED(d))
{
    val = X(entry);
}
template <class X, class Y, class Z> inline
void _wxSetArchiveIteratorValue(
    std::pair<X, Y>& val, Z entry, Z WXUNUSED(d))
{
    val = std::make_pair(X(entry->GetInternalName()), Y(entry));
}

#if defined _MSC_VER && _MSC_VER < 1300
template <class Arc, class T = Arc::entry_type*>
#else
template <class Arc, class T = typename Arc::entry_type*>
#endif
class wxArchiveIterator
{
public:
    typedef std::input_iterator_tag iterator_category;
    typedef T value_type;
    typedef ptrdiff_t difference_type;
    typedef T* pointer;
    typedef T& reference;

    wxArchiveIterator() : m_rep(NULL) { }

    wxArchiveIterator(Arc& arc) {
        typename Arc::entry_type* entry = arc.GetNextEntry();
        m_rep = entry ? new Rep(arc, entry) : NULL;
    }

    wxArchiveIterator(const wxArchiveIterator& it) : m_rep(it.m_rep) {
        if (m_rep)
            m_rep->AddRef();
    }
    
    ~wxArchiveIterator() {
        if (m_rep)
            m_rep->UnRef();
    }

    const T& operator *() const {
        return m_rep->GetValue();
    }

    const T* operator ->() const {
        return &**this;
    }

    wxArchiveIterator& operator =(const wxArchiveIterator& it) {
        if (it.m_rep)
            it.m_rep.AddRef();
        if (m_rep)
            m_rep.UnRef();
        m_rep = it.m_rep;
        return *this;
    }

    wxArchiveIterator& operator ++() {
        m_rep = m_rep->Next();
        return *this;
    }

    wxArchiveIterator operator ++(int) {
        wxArchiveIterator it(*this);
        ++(*this);
        return it;
    }

    bool operator ==(const wxArchiveIterator& j) const {
        return m_rep == j.m_rep;
    }

    bool operator !=(const wxArchiveIterator& j) const {
        return !(*this == j);
    }

private:
    class Rep {
        Arc& m_arc;
        typename Arc::entry_type* m_entry;
        T m_value;
        int m_ref;
        
    public:
        Rep(Arc& arc, typename Arc::entry_type* entry)
            : m_arc(arc), m_entry(entry), m_value(), m_ref(1) { }
        ~Rep()
            { delete m_entry; }
        
        void AddRef() {
            m_ref++;
        }

        void UnRef() {
            if (--m_ref == 0)
                delete this;
        }

        Rep *Next() {
            typename Arc::entry_type* entry = m_arc.GetNextEntry();
            if (!entry) {
                UnRef();
                return NULL;
            }
            if (m_ref > 1) {
                m_ref--; 
                return new Rep(m_arc, entry);
            }
            delete m_entry;
            m_entry = entry;
            m_value = T();
            return this;
        }

        const T& GetValue() {
            if (m_entry) {
                _wxSetArchiveIteratorValue(m_value, m_entry, m_entry);
                m_entry = NULL;
            }
            return m_value;
        }
    } *m_rep;
};

typedef wxArchiveIterator<wxArchiveInputStream> wxArchiveIter;
typedef wxArchiveIterator<wxArchiveInputStream,
        std::pair<wxString, wxArchiveEntry*> >  wxArchivePairIter;

#endif // wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR


/////////////////////////////////////////////////////////////////////////////
// wxArchiveClassFactory
//
// A wxArchiveClassFactory instance for a particular archive type allows
// the creation of the other classes that may be needed.

void WXDLLIMPEXP_BASE wxUseArchiveClasses();

class WXDLLIMPEXP_BASE wxArchiveClassFactory : public wxFilterClassFactoryBase
{
public:
    typedef wxArchiveEntry        entry_type;
    typedef wxArchiveInputStream  instream_type;
    typedef wxArchiveOutputStream outstream_type;
    typedef wxArchiveNotifier     notifier_type;
#if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
    typedef wxArchiveIter         iter_type;
    typedef wxArchivePairIter     pairiter_type;
#endif

    virtual ~wxArchiveClassFactory() { }

    wxArchiveEntry *NewEntry() const
        { return DoNewEntry(); }
    wxArchiveInputStream *NewStream(wxInputStream& stream) const
        { return DoNewStream(stream); }
    wxArchiveOutputStream *NewStream(wxOutputStream& stream) const
        { return DoNewStream(stream); }
    wxArchiveInputStream *NewStream(wxInputStream *stream) const
        { return DoNewStream(stream); }
    wxArchiveOutputStream *NewStream(wxOutputStream *stream) const
        { return DoNewStream(stream); }

    virtual wxString GetInternalName(
        const wxString& name,
        wxPathFormat format = wxPATH_NATIVE) const = 0;

    void SetConv(wxMBConv& conv) { m_pConv = &conv; }
    wxMBConv& GetConv() const { return *m_pConv; }

    static const wxArchiveClassFactory *Find(const wxChar *protocol,
                                             wxStreamProtocolType type
                                             = wxSTREAM_PROTOCOL);

    static const wxArchiveClassFactory *GetFirst();
    const wxArchiveClassFactory *GetNext() const { return m_next; }

    void PushFront() { Remove(); m_next = sm_first; sm_first = this; }
    void Remove();

protected:
    // old compilers don't support covarient returns, so 'Do' methods are
    // used to simulate them
    virtual wxArchiveEntry        *DoNewEntry() const = 0;
    virtual wxArchiveInputStream  *DoNewStream(wxInputStream& stream) const = 0;
    virtual wxArchiveOutputStream *DoNewStream(wxOutputStream& stream) const = 0;
    virtual wxArchiveInputStream  *DoNewStream(wxInputStream *stream) const = 0;
    virtual wxArchiveOutputStream *DoNewStream(wxOutputStream *stream) const = 0;

    wxArchiveClassFactory() : m_pConv(&wxConvLocal), m_next(this) { }
    wxArchiveClassFactory& operator=(const wxArchiveClassFactory& WXUNUSED(f))
        { return *this; }

private:
    wxMBConv *m_pConv;
    static wxArchiveClassFactory *sm_first;
    wxArchiveClassFactory *m_next;

    DECLARE_ABSTRACT_CLASS(wxArchiveClassFactory)
};

#endif // wxUSE_STREAMS && wxUSE_ARCHIVE_STREAMS

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