Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added --use-stl to cnfigure, wxUSE_STL to setup0.h

Browse Source 
Moved wx/datetime.inl contents to wx/datetime.h and removed
inline redefinition hack.
  Implemented STL-like interface on top of wxList/wxArray, when wxUSE_STL=0.
  Implemented wxList-like and wxArray interfaces on top of std::list and
std::vector, when wxUSE_STL=1.
  Added arrstr.h, moved wxArrayString declaration there; string.h
#includes arrstr.h only if WXWIN_COMPATIBILITY_2_4 is enabled.
  Added WX_CLEAR_HASH_MAP, WX_CLEAR_HASH_TABLE, WX_CLEAR_LIST macros,
to clear a wxHashMap, wxHashTable, wxList containing pointers: deletes
pointers and makes container zero-sized.
  When wxUSE_STL=1, wxStringList works like a std::list<wxString>.
  Made wxBase compile when wxUSE_STL=1.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@21768 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Mattia Barbon
2003-07-08 19:52:35 +00:00
parent 0598fd99db
commit df5168c427
57 changed files with 2732 additions and 535 deletions
Download Patch File Download Diff File Expand all files Collapse all files

307
include/wx/hash.h
View File

@@ -16,8 +16,16 @@
#pragma interface "hash.h"
#endif
#include "wx/list.h"
#include "wx/dynarray.h"
#include "wx/defs.h"
#if !wxUSE_STL
#include "wx/list.h"
#endif
#if WXWIN_COMPATIBILITY_2_4
#include "wx/dynarray.h"
#endif
class WXDLLIMPEXP_BASE wxObject;
// the default size of the hash
#define wxHASH_SIZE_DEFAULT (1000)
@@ -34,6 +42,8 @@
// pointers to objects
// ----------------------------------------------------------------------------
#if !wxUSE_STL
class WXDLLIMPEXP_BASE wxHashTableBase : public wxObject
{
public:
@@ -72,6 +82,164 @@ private:
DECLARE_NO_COPY_CLASS(wxHashTableBase)
};
#else
#include "wx/hashmap.h"
#if !defined(wxENUM_KEY_TYPE_DEFINED)
#define wxENUM_KEY_TYPE_DEFINED
enum wxKeyType
{
wxKEY_NONE,
wxKEY_INTEGER,
wxKEY_STRING
};
#endif
union wxHashKeyValue
{
long integer;
wxChar *string;
};
struct WXDLLIMPEXP_BASE wxHashTableHash
{
wxHashTableHash() { }
wxHashTableHash( wxKeyType keyType ) : m_keyType( keyType ) { }
wxKeyType m_keyType;
unsigned long operator ()( const wxHashKeyValue& k ) const
{
if( m_keyType == wxKEY_STRING )
return wxStringHash::wxCharStringHash( k.string );
else
return (unsigned long)k.integer;
}
};
struct WXDLLIMPEXP_BASE wxHashTableEqual
{
wxHashTableEqual() { }
wxHashTableEqual( wxKeyType keyType ) : m_keyType( keyType ) { }
wxKeyType m_keyType;
bool operator ()( const wxHashKeyValue& k1, const wxHashKeyValue& k2 ) const
{
if( m_keyType == wxKEY_STRING )
return wxStrcmp( k1.string, k2.string ) == 0;
else
return k1.integer == k2.integer;
}
};
WX_DECLARE_EXPORTED_HASH_MAP( wxHashKeyValue,
void*,
wxHashTableHash,
wxHashTableEqual,
wxHashTableBaseBase );
class WXDLLIMPEXP_BASE wxHashTableBase
{
public:
wxHashTableBase( wxKeyType keyType = wxKEY_INTEGER,
size_t size = wxHASH_SIZE_DEFAULT )
: m_map( size, wxHashTableHash( keyType ),
wxHashTableEqual( keyType ) ),
m_keyType( keyType ) { }
~wxHashTableBase()
{
if( m_keyType == wxKEY_STRING )
{
for( wxHashTableBaseBase::iterator it = m_map.begin(),
en = m_map.end();
it != en; )
{
wxChar* tmp = it->first.string;
++it;
delete[] tmp; // used in operator++
}
}
}
size_t GetCount() const { return m_map.size(); }
protected:
void DoPut( long key, void* data )
{
wxHashKeyValue k; k.integer = key;
m_map[k] = data;
}
void DoPut( const wxChar* key, void* data )
{
wxHashKeyValue k;
k.string = new wxChar[wxStrlen(key) + 1];
wxStrcpy(k.string, key);
m_map[k] = data;
}
void* DoGet( long key ) const
{
wxHashKeyValue k; k.integer = key;
wxHashTableBaseBase::const_iterator it = m_map.find( k );
return it != m_map.end() ? it->second : NULL;
}
void* DoGet( const wxChar* key ) const
{
wxHashKeyValue k; k.string = (wxChar*)key;
wxHashTableBaseBase::const_iterator it = m_map.find( k );
return it != m_map.end() ? it->second : NULL;
}
void* DoDelete( long key )
{
wxHashKeyValue k; k.integer = key;
wxHashTableBaseBase::iterator it = m_map.find( k );
if( it != m_map.end() )
{
void* data = it->second;
m_map.erase( it );
return data;
}
return NULL;
}
void* DoDelete( const wxChar* key )
{
wxHashKeyValue k; k.string = (wxChar*)key;
wxHashTableBaseBase::iterator it = m_map.find( k );
if( it != m_map.end() )
{
void* data = it->second;
wxChar* k = it->first.string;
m_map.erase( it );
delete[] k;
return data;
}
return NULL;
}
wxHashTableBaseBase m_map;
wxKeyType m_keyType;
};
#endif // !wxUSE_STL
#if !wxUSE_STL
#if WXWIN_COMPATIBILITY_2_4
// ----------------------------------------------------------------------------
@@ -145,12 +313,110 @@ private:
DECLARE_NO_COPY_CLASS(wxStringHashTable)
};
#endif
#endif // WXWIN_COMPATIBILITY_2_4
#endif // !wxUSE_STL
// ----------------------------------------------------------------------------
// for compatibility only
// ----------------------------------------------------------------------------
#if wxUSE_STL
class WXDLLIMPEXP_BASE wxHashTable : protected wxHashTableBase
{
typedef wxHashTableBaseBase hash;
public:
class dummy;
struct compatibility_iterator
{
hash::iterator m_iter;
hash* m_hash;
operator bool() const { return m_iter != m_hash->end(); }
bool operator !() const { return m_iter == m_hash->end(); }
compatibility_iterator( hash* li, hash::iterator it )
: m_iter( it ), m_hash( li ) {}
compatibility_iterator() { }
dummy* operator->() { return (dummy*)this; }
};
typedef class compatibility_iterator citer;
class dummy
{
typedef hash::iterator it;
typedef compatibility_iterator citer;
public:
wxObject* GetData() const
{
citer* i = (citer*)this;
return (wxObject*)i->m_iter->second;
}
citer GetNext() const
{
citer* i = (citer*)this;
it lit = i->m_iter;
return citer( i->m_hash, ++lit );
}
citer GetPrevious() const
{
citer* i = (citer*)this;
it lit = i->m_iter;
return citer( i->m_hash, ++lit );
}
void SetData( wxObject* e )
{
citer* i = (citer*)this;
i->m_iter->second = e;
}
private:
dummy();
};
public:
wxHashTable( wxKeyType keyType = wxKEY_INTEGER,
size_t size = wxHASH_SIZE_DEFAULT )
: wxHashTableBase( keyType, size ) { }
void Destroy() { Clear(); }
// key and value are the same
void Put(long value, wxObject *object) { DoPut( value, object ); }
void Put(const wxChar *value, wxObject *object) { DoPut( value, object ); }
// key and value are the same
wxObject *Get(long value) const { return (wxObject*)DoGet( value ); }
wxObject *Get(const wxChar *value) const { return (wxObject*)DoGet( value ); }
// Deletes entry and returns data if found
wxObject *Delete(long key) { return (wxObject*)DoGet( key ); }
wxObject *Delete(const wxChar *key) { return (wxObject*)DoGet( key ); }
#if 0
// Construct your own integer key from a string, e.g. in case
// you need to combine it with something
long MakeKey(const wxChar *string) const;
#endif
// Way of iterating through whole hash table (e.g. to delete everything)
// Not necessary, of course, if you're only storing pointers to
// objects maintained separately
void BeginFind() { m_iter = citer( &this->m_map, this->m_map.begin() ); }
compatibility_iterator Next()
{
compatibility_iterator it = m_iter;
if( m_iter )
m_iter = m_iter->GetNext();
return it;
}
void Clear() { m_map.clear(); }
private:
compatibility_iterator m_iter;
};
#else // if !wxUSE_STL
class WXDLLIMPEXP_BASE wxHashTable : public wxObject
{
public:
@@ -230,6 +496,7 @@ public:
// Returns number of nodes
size_t GetCount() const { return m_count; }
typedef wxNode* compatibility_iterator;
private:
size_t m_count; // number of elements in the hashtable
bool m_deleteContents;
@@ -237,8 +504,30 @@ private:
DECLARE_DYNAMIC_CLASS(wxHashTable)
};
#endif
#if wxUSE_STL
// defines a new type safe hash table which stores the elements of type eltype
// in lists of class listclass
#define _WX_DECLARE_HASH(eltype, dummy, hashclass, classexp) \
classexp hashclass : public wxHashTableBase \
{ \
public: \
hashclass(wxKeyType keyType = wxKEY_INTEGER, \
size_t size = wxHASH_SIZE_DEFAULT) \
: wxHashTableBase(keyType, size) { } \
\
~hashclass() { Destroy(); } \
\
void Destroy() { m_map.clear(); } \
void Put(long key, eltype *data) { DoPut(key, (void*)data); } \
eltype *Get(long key) const { return (eltype*)DoGet(key); } \
eltype *Delete(long key) { return (eltype*)DoDelete(key); } \
}
#else // if !wxUSE_STL
#define _WX_DECLARE_HASH(eltype, listclass, hashclass, classexp) \
classexp hashclass : public wxHashTableBase \
{ \
@@ -297,6 +586,8 @@ private:
} \
}
#endif
// this macro is to be used in the user code
#define WX_DECLARE_HASH(el, list, hash) \
_WX_DECLARE_HASH(el, list, hash, class)
@@ -315,16 +606,16 @@ private:
// place where you use this macro, otherwise the proper destructor may not
// be called (a decent compiler should give a warning about it, but don't
// count on it)!
#define WX_CLEAR_HASH_TABLE(array) \
#define WX_CLEAR_HASH_TABLE(hash) \
{ \
(array).BeginFind(); \
wxNode* it = (array).Next(); \
(hash).BeginFind(); \
wxHashTable::compatibility_iterator it = (hash).Next(); \
while( it ) \
{ \
delete it->GetData(); \
it = (array).Next(); \
it = (hash).Next(); \
} \
(array).Clear(); \
(hash).Clear(); \
}
#endif