| /* $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 __ETCHLIST_H__ |
| #define __ETCHLIST_H__ |
| |
| #include "capu/container/List.h" |
| #include "common/EtchComparator.h" |
| |
| template <class T, class C = EtchComparator<T> > |
| class EtchList : public EtchObject { |
| private: |
| capu::List<T, C> mList; |
| |
| public: |
| |
| typedef typename capu::List<T, C>::Iterator Iterator; |
| |
| /** |
| * EtchObjectType for EtchList. |
| */ |
| static const EtchObjectType* TYPE(); |
| |
| /** |
| * Default Constructor |
| */ |
| EtchList(); |
| |
| /** |
| * Copy Constructor |
| */ |
| EtchList(const EtchList& other); |
| |
| /** |
| * Destructor |
| */ |
| ~EtchList(); |
| |
| /** |
| * Add element to the end of list |
| * @param element element that will be added |
| * @return ETCH_ENO_MEMORY if allocation of element is failed |
| * ETCH_OK if the element is successfully added |
| */ |
| status_t add(const T &element); |
| |
| /** |
| * It will insert new element to specified position only the element at specified index with given element |
| * |
| * @param index index of element which will be inserted |
| * @param element new value that will replace the old value |
| * |
| * @return ETCH_EINVAL if given index is invalid. |
| * ETCH_ENO_MEMORY if allocation of element is failed |
| * ETCH_OK if the element is successfully added |
| * ETCH_ERROR otherwise |
| */ |
| status_t add(capu::int32_t index, const T &element); |
| |
| /** |
| * remove the element in the specified index and if the element_old |
| * parameter is not NULL, the removed element will be put to element_old |
| * @param index index of element that will be removed |
| * @param elementOld the buffer which will keep the copy of the removed element |
| * @return ETCH_EINVAL invalid index |
| * ETCH_OK if the element is successfully removed |
| */ |
| status_t removeAt(capu::int32_t index, T* elementOld = NULL); |
| |
| /** |
| * get a single element on specified index |
| * @param index index of element that will be get |
| * @param result the buffer that the retrieved element will be stored |
| * @return ETCH_EINVAL invalid index |
| * ETCH_OK otherwise |
| */ |
| status_t get(capu::int32_t index, T* result); |
| |
| /** |
| * return size of list |
| * @return return the size of list |
| */ |
| capu::int32_t size(); |
| |
| /** |
| * check the list is empty or not |
| * @return true if empty |
| * false otherwise |
| */ |
| capu::bool_t isEmpty() const; |
| |
| /** |
| * returns an iterator pointing to the beginning of list |
| * @return iterator |
| */ |
| Iterator begin() const; |
| |
| /** |
| * finds the index of given element in the link list |
| * if you are using an object you need to overload == operator |
| * |
| * @param element the value that will be searched |
| * @return -1 if the value either does not exist or given value is NULL |
| * otherwise index of value on linked list |
| */ |
| capu::int32_t find(const T &element) const; |
| |
| /** |
| * |
| * @param index the index of element that will be replaced |
| * @param element element that will be overwritten to existing place |
| * @param elementOld the buffer to keep the existing |
| * @return ETCH_EINVAL if the index is not valid |
| * ETCH_OK otherwise |
| */ |
| status_t set(capu::int32_t index, const T &element, T* elementOld = NULL); |
| |
| /** |
| * check that if the list contains the given parameter or not |
| * if you are using an object you need to overload == operator |
| * @param element element that will be checked |
| * @return true list contains it |
| * false otherwise |
| */ |
| capu::bool_t contains(const T &element); |
| |
| /** |
| * removes all elements from linked list |
| * |
| * @return ETCH_OK if all of the elements are deleted |
| * |
| */ |
| status_t clear(); |
| |
| }; |
| |
| template<class T, class C> |
| const EtchObjectType* EtchList<T, C>::TYPE() { |
| const static EtchObjectType TYPE(EOTID_LIST, NULL); |
| return &TYPE; |
| } |
| |
| template<class T, class C> |
| EtchList<T, C>::EtchList() { |
| addObjectType(EtchList<T, C>::TYPE()); |
| } |
| |
| template<class T, class C> |
| EtchList<T, C>::EtchList(const EtchList& other) |
| : EtchObject(other), mList(other.mList) { |
| } |
| |
| |
| template<class T, class C> |
| EtchList<T, C>::~EtchList() { |
| |
| } |
| |
| template<class T, class C> |
| status_t EtchList<T, C>::add(const T &element) { |
| return mList.add(element); |
| } |
| |
| template<class T, class C> |
| status_t EtchList<T, C>::add(capu::int32_t index, const T &element) { |
| return mList.add(index, element); |
| } |
| |
| template<class T, class C> |
| typename EtchList<T, C>::Iterator EtchList<T, C>::begin() const { |
| return mList.begin(); |
| } |
| |
| template<class T, class C> |
| status_t EtchList<T, C>::clear() { |
| return mList.clear(); |
| } |
| |
| template<class T, class C> |
| capu::bool_t EtchList<T, C>::contains(const T &element) { |
| return mList.contains(element); |
| } |
| |
| template<class T, class C> |
| capu::int32_t EtchList<T, C>::find(const T &element) const { |
| return mList.find(element); |
| } |
| |
| template<class T, class C> |
| status_t EtchList<T, C>::get(capu::int32_t index, T* result) { |
| return mList.get(index, result); |
| } |
| |
| template<class T, class C> |
| capu::bool_t EtchList<T, C>::isEmpty() const { |
| return mList.isEmpty(); |
| } |
| |
| template<class T, class C> |
| status_t EtchList<T, C>::removeAt(capu::int32_t index, T* elementOld) { |
| return mList.removeAt(index, elementOld); |
| } |
| |
| template<class T, class C> |
| capu::int32_t EtchList<T, C>::size() { |
| return mList.size(); |
| } |
| |
| template<class T, class C> |
| capu::int32_t EtchList<T, C>::set(capu::int32_t index, const T &element, T* elementOld) { |
| return mList.set(index, element, elementOld); |
| } |
| |
| typedef capu::SmartPointer<EtchList<EtchObjectPtr> > EtchListPtr; |
| |
| #endif /* ETCHDOUBLELINKEDLIST_H */ |
| |