| /* $Id$ |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to you under the Apache License, Version |
| * 2.0 (the "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef __ETCHHASHTABLE_H__ |
| #define __ETCHHASHTABLE_H__ |
| |
| #include "common/EtchObjectHash.h" |
| #include "common/EtchComparator.h" |
| #include "capu/container/HashTable.h" |
| |
| template <class Key, class T, class C = EtchComparator<Key>, class H = EtchObjectHash > |
| class EtchHashTable : public EtchObject { |
| private: |
| capu::HashTable<Key, T, C, H> mHashTable; |
| |
| public: |
| typedef typename capu::HashTable<Key, T, C, H>::HashTableEntry HashTableEntry; |
| class EtchHashTableIterator { |
| public: |
| friend class EtchHashTable; |
| |
| /** |
| * destructor |
| */ |
| ~EtchHashTableIterator(); |
| |
| /** |
| * Check if iterator has next element. |
| * @return false if the next of current node that is pointed, is null otherwise true |
| */ |
| capu::bool_t hasNext(); |
| |
| /** |
| * Shifts the iterator to the next position and returns the element if next != NULL |
| * @param element |
| * @return CAPU_OK if the next element has been gotten |
| * |
| */ |
| status_t next(HashTableEntry *element = 0); |
| |
| private: |
| /** |
| * Constructor |
| */ |
| EtchHashTableIterator(typename capu::HashTable<Key, T, C, H>::Iterator mBeginCapuIterator, typename capu::HashTable<Key, T, C, H>::Iterator endCapuIterator); |
| typename capu::HashTable<Key, T, C, H>::Iterator mBeginCapuIterator; |
| typename capu::HashTable<Key, T, C, H>::Iterator mEndCapuIterator; |
| |
| |
| }; |
| |
| class EtchHashTableConstIterator { |
| public: |
| friend class EtchHashTable; |
| |
| /** |
| * destructor |
| */ |
| ~EtchHashTableConstIterator(); |
| |
| /** |
| * Check if iterator has next element. |
| * @return false if the next of current node that is pointed, is null otherwise true |
| */ |
| capu::bool_t hasNext(); |
| |
| /** |
| * Shifts the iterator to the next position and returns the element if next != NULL |
| * @param element |
| * @return CAPU_OK if the next element has been gotten |
| * |
| */ |
| status_t next(HashTableEntry *element = 0); |
| |
| private: |
| /** |
| * Constructor |
| */ |
| EtchHashTableConstIterator(typename capu::HashTable<Key, T, C, H>::ConstIterator mBeginCapuConstIterator, typename capu::HashTable<Key, T, C, H>::ConstIterator endCapuConstIterator); |
| typename capu::HashTable<Key, T, C, H>::ConstIterator mBeginCapuConstIterator; |
| typename capu::HashTable<Key, T, C, H>::ConstIterator mEndCapuConstIterator; |
| |
| |
| }; |
| |
| typedef typename EtchHashTable<Key, T, C, H>::EtchHashTableIterator Iterator; |
| typedef typename EtchHashTable<Key, T, C, H>::EtchHashTableConstIterator ConstIterator; |
| |
| |
| /** |
| * EtchObjectType for EtchHashTable. |
| */ |
| static const EtchObjectType* TYPE(); |
| |
| /** |
| * Constructs EtchHashTable. |
| */ |
| inline EtchHashTable(); |
| |
| /** |
| * Constructs EtchHashTable. |
| */ |
| inline EtchHashTable(capu::uint32_t size); |
| |
| /** |
| * Copy Constructor |
| */ |
| inline EtchHashTable(const EtchHashTable& other); |
| |
| /** |
| * Destructure. |
| */ |
| inline virtual ~EtchHashTable(); |
| |
| /** |
| * put a new value to the EtchHashTable. |
| * @param key Key value |
| * @param value new value that will be put to hash table |
| * @param value_old buffer which will be used to store value of old element |
| * |
| * @return ETCH_OK if remove is successful |
| * ETCH_EINVAL if value_old is null |
| * |
| */ |
| inline status_t put(const Key &key, T value, T* value_old = NULL); |
| |
| /** |
| * Get value associated with key in the EtchHashTable. |
| * @param key Key |
| * @param value buffer which will be used to return the found element |
| * |
| * @return ETCH_OK if get is successful performed |
| * ETCH_EINVAL if value is null |
| * ETCH_ENOT_EXIST if there is no existing pair with specified key |
| * |
| */ |
| inline status_t get(const Key &key, T* value); |
| |
| /** |
| * Remove value associated with key in the EtchHashTable. |
| * |
| * @param key Key value |
| * @param value_old buffer which will be used to store value of removed element |
| * |
| * @return ETCH_OK if remove is successful |
| * ETCH_EINVAL if value_old is null |
| * ETCH_ERANGE if the pair with specified key does not exist in hash table |
| * |
| */ |
| inline status_t remove(const Key &key, T* value_old); |
| |
| /** |
| * Returns count of the EtchHashTable. |
| * @return number of element in hash table |
| */ |
| inline capu::uint_t count(); |
| |
| /** |
| * Clear all key and values of the EtchHashTable. |
| * |
| * @return ETCH_OK if all elements in list have been deleted |
| */ |
| inline status_t clear(); |
| |
| /** |
| * Return iterator for iterating key value tuples. |
| * @return Const Iterator |
| */ |
| inline ConstIterator begin() const; |
| |
| |
| /** |
| * Return iterator for iterating key value tuples. |
| * @return Iterator |
| */ |
| inline Iterator begin(); |
| |
| |
| }; |
| |
| template <class Key, class T, class C, class H> |
| const EtchObjectType* EtchHashTable<Key, T, C, H>::TYPE() { |
| const static EtchObjectType TYPE(EOTID_HASHTABLE, NULL); |
| return &TYPE; |
| } |
| |
| template <class Key, class T, class C, class H> |
| inline EtchHashTable<Key, T, C, H>::EtchHashTable() |
| : mHashTable(ETCH_DEFAULT_HASH_TABLE_BIT_SIZE) { |
| addObjectType(EtchHashTable<Key, T, C, H>::TYPE()); |
| } |
| |
| template <class Key, class T, class C, class H> |
| inline EtchHashTable<Key, T, C, H>::EtchHashTable(capu::uint32_t size) |
| : mHashTable(size) { |
| addObjectType(EtchHashTable<Key, T, C, H>::TYPE()); |
| } |
| |
| template <class Key, class T, class C, class H> |
| inline EtchHashTable<Key, T, C, H>::EtchHashTable(const EtchHashTable& other) |
| : EtchObject(other), mHashTable(other.mHashTable) { |
| } |
| |
| template <class Key, class T, class C, class H> |
| inline EtchHashTable<Key, T, C, H>::~EtchHashTable() { |
| |
| } |
| |
| template <class Key, class T, class C, class H> |
| inline status_t EtchHashTable<Key, T, C, H>::put(const Key &key, T value, T* value_old) { |
| return mHashTable.put(key, value, value_old); |
| } |
| |
| template <class Key, class T, class C, class H> |
| inline status_t EtchHashTable<Key, T, C, H>::get(const Key &key, T* value) { |
| status_t status = ETCH_EINVAL; |
| if (value != NULL) { |
| *value = mHashTable.at(key,&status); |
| } |
| return status; |
| } |
| |
| template <class Key, class T, class C, class H> |
| inline status_t EtchHashTable<Key, T, C, H>::remove(const Key &key, T* value_old) { |
| return mHashTable.remove(key, value_old); |
| } |
| |
| template <class Key, class T, class C, class H> |
| inline capu::uint_t EtchHashTable<Key, T, C, H>::count() { |
| return mHashTable.count(); |
| } |
| |
| template <class Key, class T, class C, class H> |
| inline status_t EtchHashTable<Key, T, C, H>::clear() { |
| mHashTable.clear(); |
| return ETCH_OK; |
| } |
| |
| template <class Key, class T, class C, class H> |
| inline typename EtchHashTable<Key, T, C, H>::ConstIterator EtchHashTable<Key, T, C, H>::begin() const { |
| EtchHashTableConstIterator it(mHashTable.begin(),mHashTable.end()); |
| return it; |
| } |
| |
| template <class Key, class T, class C, class H> |
| inline typename EtchHashTable<Key, T, C, H>::Iterator EtchHashTable<Key, T, C, H>::begin() { |
| EtchHashTableIterator it(mHashTable.begin(),mHashTable.end()); |
| return it; |
| } |
| |
| template<class Key, class T, class C, class H> |
| EtchHashTable<Key, T, C, H>::EtchHashTableIterator::EtchHashTableIterator(typename capu::HashTable<Key, T, C, H>::Iterator beginCapuIterator, typename capu::HashTable<Key, T, C, H>::Iterator endCapuIterator) : |
| mBeginCapuIterator(beginCapuIterator), mEndCapuIterator(endCapuIterator) { |
| |
| } |
| |
| template<class Key, class T, class C, class H> |
| EtchHashTable<Key, T, C, H>::EtchHashTableConstIterator::EtchHashTableConstIterator(typename capu::HashTable<Key, T, C, H>::ConstIterator beginCapuConstIterator, typename capu::HashTable<Key, T, C, H>::ConstIterator endCapuConstIterator) : |
| mBeginCapuConstIterator(beginCapuConstIterator), mEndCapuConstIterator(endCapuConstIterator) { |
| |
| } |
| |
| template<class Key, class T, class C, class H> |
| EtchHashTable<Key, T, C, H>::EtchHashTableIterator::~EtchHashTableIterator() { |
| |
| } |
| |
| template<class Key, class T, class C, class H> |
| EtchHashTable<Key, T, C, H>::EtchHashTableConstIterator::~EtchHashTableConstIterator() { |
| |
| } |
| |
| template<class Key, class T, class C, class H> |
| capu::bool_t EtchHashTable<Key, T, C, H>::EtchHashTableIterator::hasNext() { |
| return mBeginCapuIterator != mEndCapuIterator; |
| } |
| |
| template<class Key, class T, class C, class H> |
| capu::bool_t EtchHashTable<Key, T, C, H>::EtchHashTableConstIterator::hasNext() { |
| return mBeginCapuConstIterator != mEndCapuConstIterator; |
| } |
| |
| template<class Key, class T, class C, class H> |
| status_t EtchHashTable<Key, T, C, H>::EtchHashTableIterator::next(HashTableEntry *element) { |
| if (!hasNext()) { |
| return ETCH_ERANGE; |
| } |
| |
| if (element != NULL) { |
| *element = *mBeginCapuIterator; |
| } |
| mBeginCapuIterator++; |
| |
| return ETCH_OK; |
| } |
| |
| template<class Key, class T, class C, class H> |
| status_t EtchHashTable<Key, T, C, H>::EtchHashTableConstIterator::next(HashTableEntry *element) { |
| if (!hasNext()) { |
| return ETCH_ERANGE; |
| } |
| |
| if (element != NULL) { |
| *element = *mBeginCapuConstIterator; |
| } |
| mBeginCapuConstIterator++; |
| |
| return ETCH_OK; |
| } |
| |
| typedef capu::SmartPointer<EtchHashTable<EtchObjectPtr, EtchObjectPtr> > EtchHashTablePtr; |
| |
| #endif |