T& Item(size_t uiIndex) const \
{ wxASSERT( uiIndex < size() ); return (T&)operator[](uiIndex); } \
\
- int Index(T e, bool bFromEnd = FALSE) const; \
+ int Index(T e, bool bFromEnd = false) const; \
int Index(T lItem, CMPFUNC fnCompare) const; \
size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const; \
void Add(T lItem, size_t nInsert = 1) \
void Shrink(); \
\
size_t GetCount() const { return m_nCount; } \
- void SetCount(size_t n, T defval = T(0)); \
+ void SetCount(size_t n, T defval = T()); \
bool IsEmpty() const { return m_nCount == 0; } \
size_t Count() const { return m_nCount; } \
\
{ wxASSERT( uiIndex < m_nCount ); return m_pItems[uiIndex]; } \
T& operator[](size_t uiIndex) const { return Item(uiIndex); } \
\
- int Index(T lItem, bool bFromEnd = FALSE) const; \
+ int Index(T lItem, bool bFromEnd = false) const; \
int Index(T lItem, CMPFUNC fnCompare) const; \
size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const; \
void Add(T lItem, size_t nInsert = 1); \
T& Last() const \
{ return Item(Count() - 1); } \
\
- int Index(T e, bool bFromEnd = FALSE) const \
+ int Index(T e, bool bFromEnd = false) const \
{ return base::Index(e, bFromEnd); } \
\
- void Add(T Item, size_t nInsert = 1) \
- { insert(end(), nInsert, Item); } \
- void Insert(T Item, size_t uiIndex, size_t nInsert = 1) \
- { insert(begin() + uiIndex, nInsert, Item); } \
+ void Add(T lItem, size_t nInsert = 1) \
+ { insert(end(), nInsert, lItem); } \
+ void Insert(T lItem, size_t uiIndex, size_t nInsert = 1) \
+ { insert(begin() + uiIndex, nInsert, lItem); } \
\
void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
{ base::RemoveAt(uiIndex, nRemove); } \
- void Remove(T Item) \
- { int iIndex = Index(Item); \
+ void Remove(T lItem) \
+ { int iIndex = Index(lItem); \
wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
_WX_ERROR_REMOVE); \
RemoveAt((size_t)iIndex); } \
}
#define _WX_DEFINE_TYPEARRAY_PTR(T, name, base, classexp) \
- _WX_DEFINE_TYPEARRAY(T, name, base, classexp)
+ _WX_DEFINE_TYPEARRAY(T, name, base, classexp)
#else // if !wxUSE_STL
T& Last() const \
{ return (T&)(base::operator[](Count() - 1)); } \
\
- int Index(T Item, bool bFromEnd = FALSE) const \
- { return base::Index((base_type)Item, bFromEnd); } \
+ int Index(T lItem, bool bFromEnd = false) const \
+ { return base::Index((base_type)lItem, bFromEnd); } \
\
- void Add(T Item, size_t nInsert = 1) \
- { base::Add((base_type)Item, nInsert); } \
- void Insert(T Item, size_t uiIndex, size_t nInsert = 1) \
- { base::Insert((base_type)Item, uiIndex, nInsert) ; } \
+ void Add(T lItem, size_t nInsert = 1) \
+ { base::Add((base_type)lItem, nInsert); } \
+ void Insert(T lItem, size_t uiIndex, size_t nInsert = 1) \
+ { base::Insert((base_type)lItem, uiIndex, nInsert) ; } \
\
void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
{ base::RemoveAt(uiIndex, nRemove); } \
- void Remove(T Item) \
- { int iIndex = Index(Item); \
+ void Remove(T lItem) \
+ { int iIndex = Index(lItem); \
wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
_WX_ERROR_REMOVE); \
base::RemoveAt((size_t)iIndex); } \
reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } \
reference operator*() const { return *m_ptr; } \
ptrop \
- itor operator++() { --m_ptr; return *this; } \
- itor operator++(int) \
+ itor& operator++() { --m_ptr; return *this; } \
+ const itor operator++(int) \
{ reverse_iterator tmp = *this; --m_ptr; return tmp; } \
- itor operator--() { ++m_ptr; return *this; } \
- itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } \
+ itor& operator--() { ++m_ptr; return *this; } \
+ const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }\
bool operator ==(const itor& it) { return m_ptr == it.m_ptr; } \
bool operator !=(const itor& it) { return m_ptr != it.m_ptr; } \
}; \
const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }\
reference operator*() const { return *m_ptr; } \
ptrop \
- itor operator++() { --m_ptr; return *this; } \
- itor operator++(int) \
+ itor& operator++() { --m_ptr; return *this; } \
+ const itor operator++(int) \
{ itor tmp = *this; --m_ptr; return tmp; } \
- itor operator--() { ++m_ptr; return *this; } \
- itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } \
+ itor& operator--() { ++m_ptr; return *this; } \
+ const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }\
bool operator ==(const itor& it) { return m_ptr == it.m_ptr; } \
bool operator !=(const itor& it) { return m_ptr != it.m_ptr; } \
}; \
\
+ name(size_type n, const_reference v) { assign(n, v); } \
+ name(const_iterator first, const_iterator last) \
+ { assign(first, last); } \
void assign(const_iterator first, const_iterator last) \
{ base::assign((bconst_iterator)first, (bconst_iterator)last); } \
void assign(size_type n, const_reference v) \
T& Last() const \
{ return (T&)(base::operator[](size() - 1)); } \
\
- int Index(T Item) const \
- { return base::Index(Item, (CMPFUNC)m_fnCompare); } \
+ int Index(T lItem) const \
+ { return base::Index(lItem, (CMPFUNC)m_fnCompare); } \
\
- size_t IndexForInsert(T Item) const \
- { return base::IndexForInsert(Item, (CMPFUNC)m_fnCompare); } \
+ size_t IndexForInsert(T lItem) const \
+ { return base::IndexForInsert(lItem, (CMPFUNC)m_fnCompare); } \
\
void AddAt(T item, size_t index) \
{ base::insert(begin() + index, item); } \
\
- size_t Add(T Item) \
- { return base::Add(Item, (CMPFUNC)m_fnCompare); } \
+ size_t Add(T lItem) \
+ { return base::Add(lItem, (CMPFUNC)m_fnCompare); } \
\
void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
{ base::erase(begin() + uiIndex, begin() + uiIndex + nRemove); } \
- void Remove(T Item) \
- { int iIndex = Index(Item); \
+ void Remove(T lItem) \
+ { int iIndex = Index(lItem); \
wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
_WX_ERROR_REMOVE ); \
base::erase(begin() + iIndex); } \
size_t GetCount() const { return base_array::size(); } \
size_t size() const { return base_array::size(); } \
bool IsEmpty() const { return base_array::empty(); } \
+ bool empty() const { return base_array::empty(); } \
size_t Count() const { return base_array::size(); } \
void Shrink() { base::Shrink(); } \
\
T& Last() const \
{ return *(T*)(base::operator[](size() - 1)); } \
\
- int Index(const T& Item, bool bFromEnd = FALSE) const; \
+ int Index(const T& lItem, bool bFromEnd = false) const; \
\
- void Add(const T& Item, size_t nInsert = 1); \
+ void Add(const T& lItem, size_t nInsert = 1); \
void Add(const T* pItem) \
{ base::push_back((T*)pItem); } \
void push_back(const T* pItem) \
{ base::push_back((T*)pItem); } \
- void push_back(const T& Item) \
- { Add(Item); } \
+ void push_back(const T& lItem) \
+ { Add(lItem); } \
\
- void Insert(const T& Item, size_t uiIndex, size_t nInsert = 1); \
+ void Insert(const T& lItem, size_t uiIndex, size_t nInsert = 1); \
void Insert(const T* pItem, size_t uiIndex) \
{ base::insert(begin() + uiIndex, (T*)pItem); } \
\
// same except that they use an additional __declspec(dllexport) or equivalent
// under Windows if needed.
//
-// The first (just EXPORTED) macros do it if wxWindows was compiled as a DLL
+// The first (just EXPORTED) macros do it if wxWidgets was compiled as a DLL
// and so must be used used inside the library. The second kind (USER_EXPORTED)
// allow the user code to do it when it wants. This is needed if you have a dll
// that wants to export a wxArray daubed with your own import/export goo.
#define WX_DECLARE_OBJARRAY_WITH_DECL(T, name, decl) \
typedef T _wxObjArray##name; \
_WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, decl)
-
+
#define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \
WX_DECLARE_OBJARRAY_WITH_DECL(T, name, class expmode)
WX_DECLARE_USER_EXPORTED_BASEARRAY(short, wxBaseArrayShort, WXDLLIMPEXP_BASE);
WX_DECLARE_USER_EXPORTED_BASEARRAY(int, wxBaseArrayInt, WXDLLIMPEXP_BASE);
WX_DECLARE_USER_EXPORTED_BASEARRAY(long, wxBaseArrayLong, WXDLLIMPEXP_BASE);
+WX_DECLARE_USER_EXPORTED_BASEARRAY(size_t, wxBaseArraySizeT, WXDLLIMPEXP_BASE);
WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble, WXDLLIMPEXP_BASE);
// ----------------------------------------------------------------------------
#define WX_DEFINE_USER_EXPORTED_ARRAY_LONG(T, name, expmode) \
WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayLong, expmode)
+#define WX_DEFINE_ARRAY_SIZE_T(T, name) \
+ WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArraySizeT)
+#define WX_DEFINE_EXPORTED_ARRAY_SIZE_T(T, name) \
+ WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArraySizeT)
+#define WX_DEFINE_USER_EXPORTED_ARRAY_SIZE_T(T, name, expmode) \
+ WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArraySizeT, expmode)
+
#define WX_DEFINE_ARRAY_DOUBLE(T, name) \
WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayDouble)
#define WX_DEFINE_EXPORTED_ARRAY_DOUBLE(T, name) \
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_LONG(T, name, expmode) \
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode)
+#define WX_DEFINE_SORTED_ARRAY_SIZE_T(T, name) \
+ WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArraySizeT)
+#define WX_DEFINE_SORTED_EXPORTED_ARRAY_SIZE_T(T, name) \
+ WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArraySizeT)
+#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SIZE_T(T, name, expmode) \
+ WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArraySizeT, expmode)
+
// ----------------------------------------------------------------------------
// Convenience macros to define sorted arrays from base arrays
// ----------------------------------------------------------------------------
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
wxBaseArrayLong, expmode)
+#define WX_DEFINE_SORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, name) \
+ WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArraySizeT)
+#define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, name) \
+ WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArraySizeT)
+#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, \
+ name, expmode) \
+ WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
+ wxBaseArraySizeT, expmode)
+
// ----------------------------------------------------------------------------
// Some commonly used predefined arrays
// ----------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff