#ifndef QHASH_H
#define QHASH_H 
#include <QtCore/qatomic.h>
#include <QtCore/qchar.h>
#include <QtCore/qiterator.h>
#include <QtCore/qlist.h>
#undef QT_QHASH_DEBUG

typedef enum QtValidLicenseForCoreModule QtCoreModule;
inline uint qHash(char key);
inline uint qHash(uchar key);
inline uint qHash(signed char key);
inline uint qHash(ushort key);
inline uint qHash(short int key);
inline uint qHash(uint key);
inline uint qHash(int key);
inline uint qHash(ulong key);
inline uint qHash(long int key);
inline uint qHash(quint64 key);
inline uint qHash(qint64 key);
inline uint qHash(class QChar key);
uint qHash(struct QByteArray const & key);
uint qHash(struct QString const & key);
template < typename T > inline uint qHash(T const * key);
struct QHashData{
   public: struct Node{
      public: struct QHashData::Node* next;
      public: uint h;
   };
   public: struct QHashData::Node* fakeNext;
   public: struct QHashData::Node* * buckets;
   public: struct QBasicAtomic ref;
   public: int size;
   public: int nodeSize;
   public: short int userNumBits;
   public: short int numBits;
   public: int numBuckets;
   public: unsigned int sharable:1;
   public: void* allocateNode();
   public: void freeNode(void* node);
   public: struct QHashData* detach_helper(void (* node_duplicate)(struct QHashData::Node*, void*), int nodeSize);
   public: void rehash(int hint);
   public: void destroyAndFree();
   public: static struct QHashData::Node* nextNode(struct QHashData::Node* node);
   public: static struct QHashData::Node* previousNode(struct QHashData::Node* node);
   public: static struct QHashData shared_null;
   public: inline void mightGrow();
   public: inline void hasShrunk();
   public: inline struct QHashData::Node* firstNode();
};
struct QHashDummyValue{
   
};
inline bool operator ==(struct QHashDummyValue const &, struct QHashDummyValue const &);
template < > class QTypeInfo < struct QHashDummyValue >{
   public: static inline char const * name();
   public: enum /*anonymous*/{
      isComplex = 1,
      isStatic = 0,
      isLarge = 0,
      isPointer = 0,
      isDummy = 1,
   };
};
template < typename Key, typename T > struct QHashDummyNode{
   public: struct QHashDummyNode* next;
   public: uint h;
   public: Key key;
   public: inline QHashDummyNode(Key const & key0);
};
template < typename Key, typename T > struct QHashNode{
   public: struct QHashNode* next;
   public: uint h;
   public: Key key;
   public: T value;
   public: inline QHashNode(Key const & key0);
   public: inline QHashNode(Key const & key0, T const & value0);
   public: inline bool same_key(uint h0, Key const & key0);
};
#ifndef QT_NO_PARTIAL_TEMPLATE_SPECIALIZATION
#define Q_HASH_DECLARE_INT_NODES(key_type) template <class T> struct QHashDummyNode<key_type, T> { QHashDummyNode *next; union { uint h; key_type key; }; inline QHashDummyNode(key_type ) {} }; template <class T> struct QHashNode<key_type, T> { QHashNode *next; union { uint h; key_type key; }; T value; inline QHashNode(key_type ) {} inline QHashNode(key_type , const T &value0) : value(value0) {} inline bool same_key(uint h0, key_type) { return h0 == h; } }

template < typename T > struct QHashNode < short int, T >{
   /* This entity specializes QHashNode */
   public: class QHashNode < short int, T >* next;
   public: inline QHashNode(short int);
   public: inline QHashNode(short int, T const & value0);
   public: T value;
   public: inline bool same_key(uint h0, short int);
   public: union /*anonymous*/{
      uint h;
      short int key;
   };
};
template < typename T > struct QHashDummyNode < short int, T >{
   /* This entity specializes QHashDummyNode */
   public: class QHashDummyNode < short int, T >* next;
   public: inline QHashDummyNode(short int);
   public: union /*anonymous*/{
      uint h;
      short int key;
   };
};
template < typename T > struct QHashNode < short unsigned int, T >{
   /* This entity specializes QHashNode */
   public: class QHashNode < short unsigned int, T >* next;
   public: inline QHashNode(ushort);
   public: inline QHashNode(ushort, T const & value0);
   public: T value;
   public: inline bool same_key(uint h0, ushort);
   public: union /*anonymous*/{
      uint h;
      ushort key;
   };
};
template < typename T > struct QHashDummyNode < short unsigned int, T >{
   /* This entity specializes QHashDummyNode */
   public: class QHashDummyNode < short unsigned int, T >* next;
   public: inline QHashDummyNode(ushort);
   public: union /*anonymous*/{
      uint h;
      ushort key;
   };
};
#endif
template < typename T > struct QHashNode < int, T >{
   /* This entity specializes QHashNode */
   public: class QHashNode < int, T >* next;
   public: inline QHashNode(int);
   public: inline QHashNode(int, T const & value0);
   public: T value;
   public: inline bool same_key(uint h0, int);
   public: union /*anonymous*/{
      uint h;
      int key;
   };
};
template < typename T > struct QHashDummyNode < int, T >{
   /* This entity specializes QHashDummyNode */
   public: class QHashDummyNode < int, T >* next;
   public: inline QHashDummyNode(int);
   public: union /*anonymous*/{
      uint h;
      int key;
   };
};
template < typename T > struct QHashNode < unsigned int, T >{
   /* This entity specializes QHashNode */
   public: class QHashNode < unsigned int, T >* next;
   public: inline QHashNode(uint);
   public: inline QHashNode(uint, T const & value0);
   public: T value;
   public: inline bool same_key(uint h0, uint);
   public: union /*anonymous*/{
      uint h;
      uint key;
   };
};
template < typename T > struct QHashDummyNode < unsigned int, T >{
   /* This entity specializes QHashDummyNode */
   public: class QHashDummyNode < unsigned int, T >* next;
   public: inline QHashDummyNode(uint);
   public: union /*anonymous*/{
      uint h;
      uint key;
   };
};
#undef Q_HASH_DECLARE_INT_NODES

#endif // QT_NO_PARTIAL_TEMPLATE_SPECIALIZATION
template < typename Key, typename T > class QHash{
   private: typedef class QHashDummyNode < Key, T > DummyNode;
   private: typedef class QHashNode < Key, T > Node;
   private: union /*anonymous*/{
      struct QHashData* d;
      class QHashNode < Key, T >* e;
   };
   private: static inline class QHashNode < Key, T >* concrete(struct QHashData::Node* node);
   public: inline QHash();
   public: inline QHash(class QHash const & other);
   public: inline ~QHash();
   public: inline bool operator !=(class QHash const & other) const
   public: inline int size() const
   public: inline bool isEmpty() const
   public: inline int capacity() const
   public: inline void squeeze();
   public: inline void detach();
   public: inline bool isDetached() const
   public: inline void setSharable(bool sharable);
   public: class iterator{
      private: struct QHashData::Node* i;
      public: typedef struct std::bidirectional_iterator_tag iterator_category;
      public: typedef ptrdiff_t difference_type;
      public: typedef T value_type;
      public: typedef T* pointer;
      public: typedef T& reference;
      public: inline operator class QHashNode < Key, T >* () const
      public: inline iterator();
      public: explicit inline iterator(void* node);
      public: inline Key const & key() const
      public: inline T& value() const
      public: inline T& operator *() const
      public: inline T* operator ->() const
      public: inline bool operator ==(class QHash::iterator const & o) const
      public: inline bool operator !=(class QHash::iterator const & o) const
      public: inline class QHash::iterator& operator ++();
      public: inline class QHash::iterator operator ++(int);
      public: inline class QHash::iterator& operator --();
      public: inline class QHash::iterator operator --(int);
      public: inline class QHash::iterator operator +(int j) const
      public: inline class QHash::iterator operator -(int j) const
      public: inline class QHash::iterator& operator +=(int j);
      public: inline class QHash::iterator& operator -=(int j);
      public: inline bool operator ==(class QHash::const_iterator const & o) const
      public: inline bool operator !=(class QHash::const_iterator const & o) const
      private: inline operator bool () const
   };
   public: class const_iterator{
      private: struct QHashData::Node* i;
      public: typedef struct std::bidirectional_iterator_tag iterator_category;
      public: typedef ptrdiff_t difference_type;
      public: typedef T value_type;
      public: typedef T const * pointer;
      public: typedef T& reference;
      public: inline operator class QHashNode < Key, T >* () const
      public: inline const_iterator();
      public: explicit inline const_iterator(void* node);
#ifdef QT_STRICT_ITERATORS
#else
      public: inline const_iterator(class QHash::iterator const & o);
#endif
      public: inline Key const & key() const
      public: inline T& value() const
      public: inline T& operator *() const
      public: inline T const * operator ->() const
      public: inline bool operator ==(class QHash::const_iterator const & o) const
      public: inline bool operator !=(class QHash::const_iterator const & o) const
      public: inline class QHash::const_iterator& operator ++();
      public: inline class QHash::const_iterator operator ++(int);
      public: inline class QHash::const_iterator& operator --();
      public: inline class QHash::const_iterator operator --(int);
      public: inline class QHash::const_iterator operator +(int j) const
      public: inline class QHash::const_iterator operator -(int j) const
      public: inline class QHash::const_iterator& operator +=(int j);
      public: inline class QHash::const_iterator& operator -=(int j);
      private: inline operator bool () const
   };
   public: inline class QHash::iterator begin();
   public: inline class QHash::const_iterator begin() const
   public: inline class QHash::const_iterator constBegin() const
   public: inline class QHash::iterator end();
   public: inline class QHash::const_iterator end() const
   public: inline class QHash::const_iterator constEnd() const
   public: typedef class QHash::iterator Iterator;
   public: typedef class QHash::const_iterator ConstIterator;
   public: inline int count() const
   public: typedef T mapped_type;
   public: typedef Key key_type;
   public: typedef ptrdiff_t difference_type;
   public: typedef int size_type;
   public: inline bool empty() const
   private: inline void deleteNode(class QHashNode < Key, T >* node);
   private: static inline void duplicateNode(struct QHashData::Node* node, void* newNode);
   private: inline typename QHash::Node* createNode(uint ah, Key const & akey, T const & avalue, class QHashNode < Key, T >* * anextNode);
   public: inline class QHash < Key, T >& unite(class QHash const & other);
   private: void freeData(struct QHashData* x);
   public: inline void clear();
   private: void detach_helper();
   public: inline class QHash < Key, T >& operator =(class QHash const & other);
   public: inline T const value(Key const & akey) const
   public: inline T const value(Key const & akey, T& adefaultValue) const
   public: class QList < T > uniqueKeys() const
   public: class QList < T > keys() const
   public: class QList < T > keys(T const & avalue) const
   public: Key const key(T const & avalue) const
   public: class QList < T > values() const
   public: class QList < T > values(Key const & akey) const
   public: int count(Key const & akey) const
   public: inline T const operator [](Key const & akey) const
   public: inline T& operator [](Key const & akey);
   public: inline typename QHash::iterator insert(Key const & akey, T const & avalue);
   public: inline typename QHash::iterator insertMulti(Key const & akey, T const & avalue);
   public: int remove(Key const & akey);
   public: T take(Key const & akey);
   public: typename QHash::iterator erase(class QHash::iterator it);
   public: inline void reserve(int asize);
   public: inline typename QHash::const_iterator find(Key const & akey) const
   public: inline typename QHash::const_iterator constFind(Key const & akey) const
   public: inline typename QHash::iterator find(Key const & akey);
   public: inline bool contains(Key const & akey) const
   private: typename QHash::Node* * findNode(Key const & akey, uint* ahp = 0) const
   public: bool operator ==(class QHash const & other) const
   friend class iterator;
   friend class const_iterator;
};
template < typename Key, typename T > class QMultiHash: public QHash < Key, T >{
   public: inline QMultiHash();
   public: inline QMultiHash(class QHash < Key, T > const & other);
   public: inline class QMultiHash& operator +=(class QMultiHash const & other);
   public: inline class QMultiHash operator +(class QMultiHash const & other) const
   private: T& operator [](Key const & key);
   private: T const operator [](Key const & key) const
   public: inline typename QHash::iterator replace(Key const & akey, T const & avalue);
   public: inline typename QHash::iterator insert(Key const & akey, T const & avalue);
};
template < typename Key, typename T > class QHashIterator{
   private: class QHash < Key, T > c;
   private: inline bool item_exists() const
   private: typename QHash < Key, T >::const_iterator i;
   public: inline QHashIterator(class QHash < Key, T > const & container);
   private: typename QHash < Key, T >::const_iterator n;
   public: inline class QHashIterator& operator =(class QHash < Key, T > const & container);
   public: inline void toFront();
   private: typedef typename QHash < Key, T >::const_iterator const_iterator;
   public: inline void toBack();
   private: typedef typename QHash < Key, T >::const_iterator Item;
   public: inline bool hasNext() const
   public: inline typename QHash < Key, T >::const_iterator next();
   public: inline typename QHash < Key, T >::const_iterator peekNext() const
   public: inline bool hasPrevious() const
   public: inline typename QHash < Key, T >::const_iterator previous();
   public: inline typename QHash < Key, T >::const_iterator peekPrevious() const
   public: inline T const & value() const
   public: inline Key const & key() const
   public: inline bool findNext(T const & t);
   public: inline bool findPrevious(T const & t);
};
template < typename Key, typename T > class QMutableHashIterator{
   private: QHash < Key, T >* c;
   private: inline bool item_exists() const
   private: typename QHash < Key, T >::iterator i;
   public: inline QMutableHashIterator(class QHash < Key, T >& container);
   private: typename QHash < Key, T >::iterator n;
   public: inline ~QMutableHashIterator();
   public: inline class QMutableHashIterator& operator =(class QHash < Key, T >& container);
   private: typedef typename QHash < Key, T >::iterator iterator;
   public: inline void toFront();
   private: typedef typename QHash < Key, T >::const_iterator const_iterator;
   public: inline void toBack();
   private: typedef typename QHash < Key, T >::iterator Item;
   public: inline bool hasNext() const
   public: inline typename QHash < Key, T >::iterator next();
   public: inline typename QHash < Key, T >::iterator peekNext() const
   public: inline bool hasPrevious() const
   public: inline typename QHash < Key, T >::iterator previous();
   public: inline typename QHash < Key, T >::iterator peekPrevious() const
   public: inline void remove();
   public: inline void setValue(T const & t);
   public: inline T& value();
   public: inline T const & value() const
   public: inline Key const & key() const
   public: inline bool findNext(T const & t);
   public: inline bool findPrevious(T const & t);
};
#endif // QHASH_H