include/amino/sync_list.h

Go to the documentation of this file.

/*
 * (c) Copyright 2008, IBM Corporation.
 * Licensed 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 SYNC_LIST_H_
#define SYNC_LIST_H_

#include "lock.h"
#include "mutex.h"
#include <list>
#include <algorithm>

namespace amino {
template<class T, class Sequence = std::list<T> >
class SyncList {
private:
        Sequence internalList;
        mutex lock;

public:
        typedef typename Sequence::iterator iterator;
        typedef typename Sequence::const_iterator const_iterator;
        typedef typename Sequence::size_type size_type;
        typedef typename Sequence::reference reference;
        typedef typename Sequence::const_reference const_reference;
        typedef typename Sequence::value_type value_type;

        bool empty() {
                unique_lock<mutex> common_lock(lock);
                return internalList.empty();
        }

        size_type size() {
                unique_lock<mutex> common_lock(lock);
                return internalList.size();
        }

        bool front(reference ret) {
                unique_lock<mutex> common_lock(lock);
                ret = internalList.front();
                return true;
        }

        T& operator[](int index) {
                unique_lock<mutex> common_lock(lock);
        }

        T& at(int index) {
                unique_lock<mutex> common_lock(lock);
        }

        bool insert(int index, const T& e) {
                unique_lock<mutex> common_lock(lock);
                iterator ite = internalList.begin();
                for(int i = 0; i < index; ++i) {
                        if(ite == internalList.end()) {
                                break;
                        }
                        ite++;
                }

                if(ite != internalList.end()) {
                        internalList.insert(ite, e);
                        return true;
                } else {
                        return false;
                }
        }

        bool push_front(const T& x) {
                unique_lock<mutex> common_lock(lock);
                internalList.push_front(x);
                return true;
        }

        bool push_back(const T& x) {
                unique_lock<mutex> common_lock(lock);
                internalList.push_back(x);
                return true;
        }

        void pop_front() {
                unique_lock<mutex> common_lock(lock);
                internalList.pop_front();
        }

        void pop_back() {
                unique_lock<mutex> common_lock(lock);
                internalList.pop_back();
        }

        void clear() {
                unique_lock<mutex> common_lock(lock);
                internalList.clear();
        }

        bool remove(const T& value) {
                unique_lock<mutex> common_lock(lock);
                iterator ite = find(internalList.begin(), internalList.end(), value);
                if(ite != internalList.end()) {
                        internalList.erase(ite);
                        return true;
                } else {
                        return false;
                }
        }

        void unique() {
                unique_lock<mutex> common_lock(lock);
                internalList.unique();
        }

        void merge(Sequence& x) {
                unique_lock<mutex> common_lock(lock);
                internalList.merge(x);
        }

        void reverse() {
                unique_lock<mutex> common_lock(lock);
                internalList.reverse();
        }

        void sort() {
                unique_lock<mutex> common_lock(lock);
                internalList.reverse();
        }

        iterator begin() {
                return internalList.begin();
        }

        iterator end() {
                return internalList.begin();
        }

        const_iterator begin() const {
                return internalList.begin();
        }

        const_iterator end() const {
                return internalList.begin();
        }

};

};
#endif /* SYNC_LIST_H_ */

---