| // *********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // 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. |
| // |
| // @@@ END COPYRIGHT @@@ |
| // *********************************************************************** |
| // -*-C++-*- |
| // *********************************************************************** |
| // |
| // File: SharedPtrCollections.h |
| // Description: Provide classes that properly handle SharedPtr classes |
| // within NAList and NAArray collections. Some functions |
| // must be overridden to properly handle the reference |
| // counting mechanism in the SharedPtr class. |
| // |
| // Created: 04/04/07 |
| // Language: C++ |
| // *********************************************************************** |
| #ifndef _SHAREDPTR_COLLECTIONS_H |
| #define _SHAREDPTR_COLLECTIONS_H |
| |
| #include "SharedPtr.h" |
| #include "Collections.h" |
| |
| // Define shared pointer list and array types in a simliar way |
| // to the current LIST and ARRAY. |
| #define SHPTR_LIST(Type) NAShPtrList<Type> |
| #define SHPTR_ARRAY(Type) NAShPtrArray<Type> |
| |
| // *********************************************************************** |
| // NAShPtrList class |
| // Description: A specialization of the NAList (LIST) class . This |
| // class just overrides some of the behavior to work |
| // correctly with shared pointers. |
| // *********************************************************************** |
| template <class T> |
| class NAShPtrList : public NAList<T> { |
| public: |
| NAShPtrList(CollIndex initLen = 0) : NAList<T>(initLen) {} |
| NAShPtrList(CollHeap * heap, CollIndex initLen = 0) |
| : NAList<T>(heap, initLen) {} |
| NAShPtrList(const NAShPtrList<T> &other, CollHeap *heap=0) |
| : NAList<T>(other, heap) {} |
| |
| // The destructor in the Collections base class calls deallocate(), |
| // but will call the Collections deallocate() instead of the |
| // one defined here. It is necessary to call decrAllRefCount() |
| // here to insure the shared pointers decrement their reference |
| // counts. |
| ~NAShPtrList() { decrAllRefCount(); } |
| |
| // Reduce the reference count on all members. |
| void decrAllRefCount() { |
| CollIndex maxSize = NACollection<T>::getSize(); |
| for (CollIndex i = 0; i < maxSize; i++) { |
| if (NACollection<T>::getUsage(i) != UNUSED_COLL_ENTRY) |
| this->usedEntry(i) = 0; |
| } |
| } |
| |
| // Clear the list of smart pointers (but don't deallocate memory). |
| void clear() { |
| decrAllRefCount(); |
| NAList<T>::clear(); |
| } |
| |
| // Deallocate the list of smart pointers. This is not meant to be used |
| // by external users of the NAShPtrList class. |
| virtual void deallocate() { |
| decrAllRefCount(); |
| NACollection<T>::deallocate(); |
| } |
| |
| // Decrement the reference count and remove a particular element |
| // in the list |
| NABoolean removeAt(const CollIndex index) { |
| if (index >= NAList<T>::entries()) |
| return FALSE; |
| |
| (*this)[index] = 0; |
| return NAList<T>::removeAt(index); |
| } |
| }; |
| |
| // *********************************************************************** |
| // NAShPtrArray class |
| // Description: A specialization of the NAArray (ARRAY) class . This |
| // class just overrides some of the behavior to work |
| // correctly with shared pointers. |
| // *********************************************************************** |
| template <class T> |
| class NAShPtrArray : public NAArray<T> { |
| public: |
| NAShPtrArray(CollIndex initLen = 0) : NAArray<T>(initLen) {} |
| NAShPtrArray(CollHeap * heap, CollIndex initLen = 0) |
| : NAArray<T>(heap, initLen) {} |
| NAShPtrArray(const NAShPtrArray<T> &other, CollHeap *heap=0) |
| : NAArray<T>(other, heap) {} |
| |
| // The destructor in the Collections base class calls deallocate(), |
| // but will call the Collections deallocate() instead of the |
| // one defined here. It is necessary to call decrAllRefCount() |
| // here to insure the shared pointers decrement their reference |
| // counts. |
| ~NAShPtrArray() { decrAllRefCount(); } |
| |
| // Reduce the reference count on all members. |
| void decrAllRefCount() { |
| CollIndex maxSize = NACollection<T>::getSize(); |
| for (CollIndex i = 0; i < maxSize; i++) { |
| if (NAArray<T>::used(i)) |
| this->usedEntry(i) = 0; |
| } |
| } |
| |
| // Clear the array of smart pointers (but don't deallocate memory) |
| void clear() { |
| decrAllRefCount(); |
| NAArray<T>::clear(); |
| } |
| |
| // Deallocate the array of smart pointers. This is not meant to be called |
| // by users of the NAShPtrArray class. |
| virtual void deallocate() { |
| decrAllRefCount(); |
| NACollection<T>::deallocate(); |
| } |
| |
| // Remove an entry from the NAShPtrArray object at a particular index. |
| NABoolean remove(CollIndex index) { |
| if (NAArray<T>::used(index)) { |
| this->usedEntry(index) = 0; |
| NACollection<T>::remove(index); |
| return TRUE; |
| } else { |
| return FALSE; |
| } |
| } |
| }; |
| |
| #endif // _SHAREDPTR_COLLECTIONS_H |