663 lines
25 KiB
C++
663 lines
25 KiB
C++
/****************************************************************************
|
|
**
|
|
** https://www.qxorm.com/
|
|
** Copyright (C) 2013 XDL Team (ic-east.com)
|
|
**
|
|
** This file is part of the QxOrm library
|
|
**
|
|
** This software is provided 'as-is', without any express or implied
|
|
** warranty. In no event will the authors be held liable for any
|
|
** damages arising from the use of this software
|
|
**
|
|
** Commercial Usage
|
|
** Licensees holding valid commercial QxOrm licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and XDL Team
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3.0 as published by the Free Software
|
|
** Foundation and appearing in the file 'license.gpl3.txt' included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU General Public License version 3.0 requirements will be
|
|
** met : http://www.gnu.org/copyleft/gpl.html
|
|
**
|
|
** If you are unsure which license is appropriate for your use, or
|
|
** if you have questions regarding the use of this file, please contact :
|
|
** ic-east.com
|
|
**
|
|
****************************************************************************/
|
|
|
|
#ifndef _QX_GENERIC_CONTAINER_H_
|
|
#define _QX_GENERIC_CONTAINER_H_
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma once
|
|
#endif
|
|
|
|
/*!
|
|
* \file generic_container.h
|
|
* \author XDL Team
|
|
* \ingroup QxTraits
|
|
* \brief qx::trait::generic_container<T> : provide some tools to manage all containers without knowing its type
|
|
*/
|
|
|
|
#include <QxTraits/is_smart_ptr.h>
|
|
#include <QxTraits/remove_attr.h>
|
|
#include <QxTraits/remove_smart_ptr.h>
|
|
#include <QxTraits/construct_ptr.h>
|
|
|
|
namespace qx
|
|
{
|
|
namespace trait
|
|
{
|
|
|
|
class no_type
|
|
{
|
|
private:
|
|
void dummy() const { ; }
|
|
};
|
|
|
|
/*!
|
|
* \ingroup QxTraits
|
|
* \brief qx::trait::generic_container<T> : provide some tools to manage all containers without knowing its type
|
|
*/
|
|
template <class T>
|
|
struct generic_container
|
|
{
|
|
typedef no_type type_item;
|
|
typedef no_type type_key;
|
|
typedef no_type type_value;
|
|
typedef no_type type_value_qx;
|
|
typedef no_type type_iterator;
|
|
};
|
|
|
|
template <typename Key, typename Value>
|
|
struct generic_container_item
|
|
{
|
|
|
|
typedef Key type_key;
|
|
typedef Value type_value;
|
|
typedef typename qx::trait::remove_attr<Value>::type type_value_qx_tmp;
|
|
typedef typename qx::trait::remove_smart_ptr<type_value_qx_tmp>::type type_value_qx;
|
|
|
|
enum
|
|
{
|
|
is_key_pointer = (std::is_pointer<type_key>::value || qx::trait::is_smart_ptr<type_key>::value)
|
|
};
|
|
enum
|
|
{
|
|
is_value_pointer = (std::is_pointer<type_value>::value || qx::trait::is_smart_ptr<type_value>::value)
|
|
};
|
|
|
|
private:
|
|
std::pair<type_key, type_value> m_pair;
|
|
|
|
public:
|
|
generic_container_item() { ; }
|
|
generic_container_item(const Key &key, const Value &value) { m_pair = std::make_pair(key, value); }
|
|
~generic_container_item() { ; }
|
|
|
|
inline type_key &key() { return m_pair.first; }
|
|
inline type_value &value() { return m_pair.second; }
|
|
inline const type_key &key() const { return m_pair.first; }
|
|
inline const type_value &value() const { return m_pair.second; }
|
|
inline type_value_qx &value_qx() { return value_qx_Helper<is_value_pointer, type_value, type_value_qx, 0>::get(m_pair.second); }
|
|
inline const type_value_qx &value_qx() const { return value_qx_Helper<is_value_pointer, type_value, type_value_qx, 0>::get(m_pair.second); }
|
|
|
|
inline void key(const Key &key) { m_pair.first = key; }
|
|
inline void value(const Value &value) { m_pair.second = value; }
|
|
|
|
static inline type_key newKey() { return new_Helper<is_key_pointer, type_key, 0>::get(); }
|
|
static inline type_value newValue() { return new_Helper<is_value_pointer, type_value, 0>::get(); }
|
|
|
|
private:
|
|
template <bool bIsPointer /* = true */, typename T, int dummy>
|
|
struct new_Helper
|
|
{
|
|
static inline T get()
|
|
{
|
|
T t;
|
|
qx::trait::construct_ptr<T>::get(t);
|
|
return t;
|
|
}
|
|
};
|
|
|
|
template <typename T, int dummy>
|
|
struct new_Helper<false, T, dummy>
|
|
{
|
|
static inline T get() { return T(); }
|
|
};
|
|
|
|
template <bool bIsPointer /* = true */, typename T, typename U, int dummy>
|
|
struct value_qx_Helper
|
|
{
|
|
static inline U &get(T &t) { return (*t); }
|
|
};
|
|
|
|
template <typename T, typename U, int dummy>
|
|
struct value_qx_Helper<false, T, U, dummy>
|
|
{
|
|
static inline U &get(T &t) { return t; }
|
|
};
|
|
};
|
|
|
|
} // namespace trait
|
|
} // namespace qx
|
|
|
|
#define QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(TypeContainer, TypeKey, TypeValue) \
|
|
typedef qx::trait::generic_container_item<TypeKey, TypeValue> type_item; \
|
|
typedef typename type_item::type_key type_key; \
|
|
typedef typename type_item::type_value type_value; \
|
|
typedef typename type_item::type_value_qx type_value_qx; \
|
|
typedef typename TypeContainer::iterator type_iterator;
|
|
|
|
namespace qx
|
|
{
|
|
namespace trait
|
|
{
|
|
namespace detail
|
|
{
|
|
|
|
template <typename Container, typename Item>
|
|
struct generic_container_base
|
|
{
|
|
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(Container, qx::trait::no_type, Item)
|
|
|
|
static inline long size(const Container &t) { return static_cast<long>(t.size()); }
|
|
static inline void clear(Container &t) { t.clear(); }
|
|
static inline void reserve(Container &t, long l) { t.reserve(l); }
|
|
static inline type_item createItem() { return type_item(type_item::newKey(), type_item::newValue()); }
|
|
static inline Item *insertItem(Container &t, type_item &item)
|
|
{
|
|
t.push_back(item.value());
|
|
return (&t.back());
|
|
}
|
|
static inline type_iterator end(Container &t) { return t.end(); }
|
|
|
|
static inline type_iterator begin(Container &t, type_item &item)
|
|
{
|
|
if (t.size() <= 0)
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*t.begin());
|
|
return t.begin();
|
|
}
|
|
|
|
static inline type_iterator next(Container &t, type_iterator itr, type_item &item)
|
|
{
|
|
itr++;
|
|
if (itr == t.end())
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*itr);
|
|
return itr;
|
|
}
|
|
};
|
|
|
|
template <typename Container, typename Item>
|
|
struct generic_container_base_without_reserve
|
|
{
|
|
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(Container, qx::trait::no_type, Item)
|
|
|
|
static inline long size(const Container &t) { return static_cast<long>(t.size()); }
|
|
static inline void clear(Container &t) { t.clear(); }
|
|
static inline void reserve(Container &t, long l)
|
|
{
|
|
Q_UNUSED(t);
|
|
Q_UNUSED(l);
|
|
}
|
|
static inline type_item createItem() { return type_item(type_item::newKey(), type_item::newValue()); }
|
|
static inline Item *insertItem(Container &t, type_item &item)
|
|
{
|
|
t.push_back(item.value());
|
|
return (&t.back());
|
|
}
|
|
static inline type_iterator end(Container &t) { return t.end(); }
|
|
|
|
static inline type_iterator begin(Container &t, type_item &item)
|
|
{
|
|
if (t.size() <= 0)
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*t.begin());
|
|
return t.begin();
|
|
}
|
|
|
|
static inline type_iterator next(Container &t, type_iterator itr, type_item &item)
|
|
{
|
|
itr++;
|
|
if (itr == t.end())
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*itr);
|
|
return itr;
|
|
}
|
|
};
|
|
|
|
template <typename Container, typename Item>
|
|
struct generic_container_base_set
|
|
{
|
|
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(Container, qx::trait::no_type, Item)
|
|
|
|
static inline long size(const Container &t) { return static_cast<long>(t.size()); }
|
|
static inline void clear(Container &t) { t.clear(); }
|
|
static inline void reserve(Container &t, long l)
|
|
{
|
|
Q_UNUSED(t);
|
|
Q_UNUSED(l);
|
|
}
|
|
static inline type_item createItem() { return type_item(type_item::newKey(), type_item::newValue()); }
|
|
static inline Item *insertItem(Container &t, type_item &item) { return const_cast<Item *>(&(*(t.insert(item.value()).first))); }
|
|
static inline type_iterator end(Container &t) { return t.end(); }
|
|
|
|
static inline type_iterator begin(Container &t, type_item &item)
|
|
{
|
|
if (t.size() <= 0)
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*t.begin());
|
|
return t.begin();
|
|
}
|
|
|
|
static inline type_iterator next(Container &t, type_iterator itr, type_item &item)
|
|
{
|
|
itr++;
|
|
if (itr == t.end())
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*itr);
|
|
return itr;
|
|
}
|
|
};
|
|
|
|
template <typename Container, typename Item>
|
|
struct generic_container_base_multi_set
|
|
{
|
|
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(Container, qx::trait::no_type, Item)
|
|
|
|
static inline long size(const Container &t) { return static_cast<long>(t.size()); }
|
|
static inline void clear(Container &t) { t.clear(); }
|
|
static inline void reserve(Container &t, long l)
|
|
{
|
|
Q_UNUSED(t);
|
|
Q_UNUSED(l);
|
|
}
|
|
static inline type_item createItem() { return type_item(type_item::newKey(), type_item::newValue()); }
|
|
static inline Item *insertItem(Container &t, type_item &item) { return const_cast<Item *>(&(*(t.insert(item.value())))); }
|
|
static inline type_iterator end(Container &t) { return t.end(); }
|
|
|
|
static inline type_iterator begin(Container &t, type_item &item)
|
|
{
|
|
if (t.size() <= 0)
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*t.begin());
|
|
return t.begin();
|
|
}
|
|
|
|
static inline type_iterator next(Container &t, type_iterator itr, type_item &item)
|
|
{
|
|
itr++;
|
|
if (itr == t.end())
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*itr);
|
|
return itr;
|
|
}
|
|
};
|
|
|
|
template <typename Container, typename Key, typename Value>
|
|
struct generic_container_base_key_value_std_style
|
|
{
|
|
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(Container, Key, Value)
|
|
|
|
static inline long size(const Container &t) { return static_cast<long>(t.size()); }
|
|
static inline void clear(Container &t) { t.clear(); }
|
|
static inline void reserve(Container &t, long l) { t.reserve(l); }
|
|
static inline type_item createItem() { return type_item(type_item::newKey(), type_item::newValue()); }
|
|
static inline Value *insertItem(Container &t, type_item &item) { return (&(t.insert(std::make_pair(item.key(), item.value())).first->second)); }
|
|
static inline type_iterator end(Container &t) { return t.end(); }
|
|
|
|
static inline type_iterator begin(Container &t, type_item &item)
|
|
{
|
|
if (t.size() <= 0)
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*t.begin().second);
|
|
item.key(*t.begin().first);
|
|
return t.begin();
|
|
}
|
|
|
|
static inline type_iterator next(Container &t, type_iterator itr, type_item &item)
|
|
{
|
|
itr++;
|
|
if (itr == t.end())
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*itr.second);
|
|
item.key(*itr.first);
|
|
return itr;
|
|
}
|
|
};
|
|
|
|
template <typename Container, typename Key, typename Value>
|
|
struct generic_container_base_key_value_without_reserve
|
|
{
|
|
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(Container, Key, Value)
|
|
|
|
static inline long size(const Container &t) { return static_cast<long>(t.size()); }
|
|
static inline void clear(Container &t) { t.clear(); }
|
|
static inline void reserve(Container &t, long l)
|
|
{
|
|
Q_UNUSED(t);
|
|
Q_UNUSED(l);
|
|
}
|
|
static inline type_item createItem() { return type_item(type_item::newKey(), type_item::newValue()); }
|
|
static inline Value *insertItem(Container &t, type_item &item) { return (&(t.insert(std::make_pair(item.key(), item.value())).first->second)); }
|
|
static inline type_iterator end(Container &t) { return t.end(); }
|
|
|
|
static inline type_iterator begin(Container &t, type_item &item)
|
|
{
|
|
if (t.size() <= 0)
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*t.begin().second);
|
|
item.key(*t.begin().first);
|
|
return t.begin();
|
|
}
|
|
|
|
static inline type_iterator next(Container &t, type_iterator itr, type_item &item)
|
|
{
|
|
itr++;
|
|
if (itr == t.end())
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*itr.second);
|
|
item.key(*itr.first);
|
|
return itr;
|
|
}
|
|
};
|
|
|
|
template <typename Container, typename Key, typename Value>
|
|
struct generic_container_base_key_value_multi_std_style
|
|
{
|
|
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(Container, Key, Value)
|
|
|
|
static inline long size(const Container &t) { return static_cast<long>(t.size()); }
|
|
static inline void clear(Container &t) { t.clear(); }
|
|
static inline void reserve(Container &t, long l) { t.reserve(l); }
|
|
static inline type_item createItem() { return type_item(type_item::newKey(), type_item::newValue()); }
|
|
static inline Value *insertItem(Container &t, type_item &item) { return (&(t.insert(std::make_pair(item.key(), item.value()))->second)); }
|
|
static inline type_iterator end(Container &t) { return t.end(); }
|
|
|
|
static inline type_iterator begin(Container &t, type_item &item)
|
|
{
|
|
if (t.size() <= 0)
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*t.begin().second);
|
|
item.key(*t.begin().first);
|
|
return t.begin();
|
|
}
|
|
|
|
static inline type_iterator next(Container &t, type_iterator itr, type_item &item)
|
|
{
|
|
itr++;
|
|
if (itr == t.end())
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*itr.second);
|
|
item.key(*itr.first);
|
|
return itr;
|
|
}
|
|
};
|
|
|
|
template <typename Container, typename Key, typename Value>
|
|
struct generic_container_base_key_value_qt_style
|
|
{
|
|
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(Container, Key, Value)
|
|
|
|
static inline long size(const Container &t) { return static_cast<long>(t.size()); }
|
|
static inline void clear(Container &t) { t.clear(); }
|
|
static inline void reserve(Container &t, long l) { t.reserve(l); }
|
|
static inline type_item createItem() { return type_item(type_item::newKey(), type_item::newValue()); }
|
|
static inline Value *insertItem(Container &t, type_item &item) { return (&(t.insert(item.key(), item.value()).value())); }
|
|
static inline type_iterator end(Container &t) { return t.end(); }
|
|
|
|
static inline type_iterator begin(Container &t, type_item &item)
|
|
{
|
|
if (t.size() <= 0)
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*t.begin().value());
|
|
item.key(*t.begin().key());
|
|
return t.begin();
|
|
}
|
|
|
|
static inline type_iterator next(Container &t, type_iterator itr, type_item &item)
|
|
{
|
|
itr++;
|
|
if (itr == t.end())
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(*itr.value());
|
|
item.key(*itr.key());
|
|
return itr;
|
|
}
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
template <typename T>
|
|
struct generic_container<std::vector<T>> : public qx::trait::detail::generic_container_base<std::vector<T>, T>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1(std::vector, T), qx::trait::no_type, T)
|
|
};
|
|
|
|
template <typename T>
|
|
struct generic_container<std::list<T>> : public qx::trait::detail::generic_container_base_without_reserve<std::list<T>, T>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1(std::list, T), qx::trait::no_type, T)
|
|
};
|
|
|
|
template <typename T>
|
|
struct generic_container<std::set<T>> : public qx::trait::detail::generic_container_base_set<std::set<T>, T>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1(std::set, T), qx::trait::no_type, T)
|
|
};
|
|
|
|
template <typename Key, typename Value>
|
|
struct generic_container<std::map<Key, Value>> : public qx::trait::detail::generic_container_base_key_value_without_reserve<std::map<Key, Value>, Key, Value>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1_P2(std::map, Key, Value), Key, Value)
|
|
};
|
|
|
|
#ifdef _QX_ENABLE_BOOST
|
|
|
|
template <typename T>
|
|
struct generic_container<boost::unordered_set<T>> : public qx::trait::detail::generic_container_base_set<boost::unordered_set<T>, T>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1(boost::unordered_set, T), qx::trait::no_type, T)
|
|
};
|
|
|
|
template <typename T>
|
|
struct generic_container<boost::unordered_multiset<T>> : public qx::trait::detail::generic_container_base_multi_set<boost::unordered_multiset<T>, T>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1(boost::unordered_multiset, T), qx::trait::no_type, T)
|
|
};
|
|
|
|
template <typename Key, typename Value>
|
|
struct generic_container<boost::unordered_map<Key, Value>> : public qx::trait::detail::generic_container_base_key_value_std_style<boost::unordered_map<Key, Value>, Key, Value>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1_P2(boost::unordered_map, Key, Value), Key, Value)
|
|
};
|
|
|
|
template <typename Key, typename Value>
|
|
struct generic_container<boost::unordered_multimap<Key, Value>> : public qx::trait::detail::generic_container_base_key_value_multi_std_style<boost::unordered_multimap<Key, Value>, Key, Value>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1_P2(boost::unordered_multimap, Key, Value), Key, Value)
|
|
};
|
|
|
|
#endif // _QX_ENABLE_BOOST
|
|
|
|
template <typename T>
|
|
struct generic_container<std::unordered_set<T>> : public qx::trait::detail::generic_container_base_set<std::unordered_set<T>, T>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1(std::unordered_set, T), qx::trait::no_type, T)
|
|
};
|
|
|
|
template <typename T>
|
|
struct generic_container<std::unordered_multiset<T>> : public qx::trait::detail::generic_container_base_multi_set<std::unordered_multiset<T>, T>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1(std::unordered_multiset, T), qx::trait::no_type, T)
|
|
};
|
|
|
|
template <typename Key, typename Value>
|
|
struct generic_container<std::unordered_map<Key, Value>> : public qx::trait::detail::generic_container_base_key_value_std_style<std::unordered_map<Key, Value>, Key, Value>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1_P2(std::unordered_map, Key, Value), Key, Value)
|
|
};
|
|
|
|
template <typename Key, typename Value>
|
|
struct generic_container<std::unordered_multimap<Key, Value>> : public qx::trait::detail::generic_container_base_key_value_multi_std_style<std::unordered_multimap<Key, Value>, Key, Value>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1_P2(std::unordered_multimap, Key, Value), Key, Value)
|
|
};
|
|
|
|
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
|
|
template <typename T>
|
|
struct generic_container<QVector<T>> : public qx::trait::detail::generic_container_base<QVector<T>, T>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1(QVector, T), qx::trait::no_type, T)
|
|
};
|
|
#endif // (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
|
|
|
|
#if (QT_VERSION >= QT_VERSION_CHECK(4, 7, 0))
|
|
|
|
template <typename T>
|
|
struct generic_container<QList<T>> : public qx::trait::detail::generic_container_base<QList<T>, T>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1(QList, T), qx::trait::no_type, T)
|
|
};
|
|
|
|
#else // (QT_VERSION >= QT_VERSION_CHECK(4, 7, 0))
|
|
|
|
template <typename T>
|
|
struct generic_container<QList<T>> : public qx::trait::detail::generic_container_base_without_reserve<QList<T>, T>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1(QList, T), qx::trait::no_type, T)
|
|
};
|
|
|
|
#endif // (QT_VERSION >= QT_VERSION_CHECK(4, 7, 0))
|
|
|
|
#if (QT_VERSION < QT_VERSION_CHECK(5, 15, 0))
|
|
template <typename T>
|
|
struct generic_container<QLinkedList<T>> : public qx::trait::detail::generic_container_base_without_reserve<QLinkedList<T>, T>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1(QLinkedList, T), qx::trait::no_type, T)
|
|
};
|
|
#endif // (QT_VERSION < QT_VERSION_CHECK(5, 15, 0))
|
|
|
|
template <typename T>
|
|
struct generic_container<QSet<T>> : public qx::trait::detail::generic_container_base_multi_set<QSet<T>, T>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1(QSet, T), qx::trait::no_type, T)
|
|
};
|
|
|
|
template <typename Key, typename Value>
|
|
struct generic_container<QMap<Key, Value>> : public qx::trait::detail::generic_container_base_key_value_qt_style<QMap<Key, Value>, Key, Value>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1_P2(QMap, Key, Value), Key, Value)
|
|
};
|
|
|
|
template <typename Key, typename Value>
|
|
struct generic_container<QMultiMap<Key, Value>> : public qx::trait::detail::generic_container_base_key_value_qt_style<QMultiMap<Key, Value>, Key, Value>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1_P2(QMultiMap, Key, Value), Key, Value)
|
|
};
|
|
|
|
template <typename Key, typename Value>
|
|
struct generic_container<QHash<Key, Value>> : public qx::trait::detail::generic_container_base_key_value_qt_style<QHash<Key, Value>, Key, Value>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1_P2(QHash, Key, Value), Key, Value)
|
|
};
|
|
|
|
template <typename Key, typename Value>
|
|
struct generic_container<QMultiHash<Key, Value>> : public qx::trait::detail::generic_container_base_key_value_qt_style<QMultiHash<Key, Value>, Key, Value>
|
|
{
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1_P2(QMultiHash, Key, Value), Key, Value)
|
|
};
|
|
|
|
template <typename Key, typename Value>
|
|
struct generic_container<qx::QxCollection<Key, Value>>
|
|
{
|
|
|
|
QX_TRAIT_GENERIC_CONTAINER_TYPEDEF(QX_TEMPLATE_T_P1_P2(qx::QxCollection, Key, Value), Key, Value)
|
|
|
|
static inline long size(const qx::QxCollection<Key, Value> &t) { return static_cast<long>(t.size()); }
|
|
static inline void clear(qx::QxCollection<Key, Value> &t) { t.clear(); }
|
|
static inline void reserve(qx::QxCollection<Key, Value> &t, long l) { t.reserve(l); }
|
|
static inline type_item createItem() { return type_item(type_item::newKey(), type_item::newValue()); }
|
|
static inline Value *insertItem(qx::QxCollection<Key, Value> &t, type_item &item)
|
|
{
|
|
t.insert(item.key(), item.value());
|
|
return const_cast<Value *>(&t.getByKey(item.key()));
|
|
}
|
|
static inline type_iterator end(qx::QxCollection<Key, Value> &t) { return t.end(); }
|
|
|
|
static inline type_iterator begin(qx::QxCollection<Key, Value> &t, type_item &item)
|
|
{
|
|
if (t.size() <= 0)
|
|
{
|
|
return t.end();
|
|
};
|
|
item.value(t.getByIndex(0));
|
|
item.key(t.getKeyByIndex(0));
|
|
return t.begin();
|
|
}
|
|
|
|
static inline type_iterator next(qx::QxCollection<Key, Value> &t, type_iterator itr, type_item &item)
|
|
{
|
|
itr++;
|
|
if (itr == t.end())
|
|
{
|
|
return t.end();
|
|
};
|
|
long l = (itr - t.begin());
|
|
item.value(t.getByIndex(l));
|
|
item.key(t.getKeyByIndex(l));
|
|
return itr;
|
|
}
|
|
};
|
|
|
|
} // namespace trait
|
|
} // namespace qx
|
|
|
|
#endif // _QX_GENERIC_CONTAINER_H_
|