mn_shared_list.hpp

Go to the documentation of this file.

 
#ifndef __MINILIB_BASIC_SHARED_LIST_H__
#define __MINILIB_BASIC_SHARED_LIST_H__
 
#include "../mn_config.hpp"
 
#include "mn_list.hpp"
 
#include "../mn_autolock.hpp"
#include "../pointer/mn_shared_ptr.hpp"
 
#include <list>
namespace mn {
    namespace container {
        template <typename T, typename TLockType = mn::mutex_t>
        class basic_shared_list : public list< pointer::shared_atomic_ptr<T> > {
            using base_type = list< pointer::shared_atomic_ptr<T> > ;
        public:
            using self_type = basic_shared_list<T, TLockType>;
 
            using lock_type = TLockType;
            using pointer_type = pointer::shared_atomic_ptr<T>;
 
            using value_type = typename base_type::value_type;
            using reference = typename base_type::value_type&;
            using const_reference = const typename base_type::value_type&;
            using pointer = typename base_type::value_type*;
            using const_pointer = const typename base_type::value_type*;
            using allocator_type = typename base_type::allocator_type;
            using size_type = typename base_type::size_type;
            using node_type = typename base_type::node_type;
            using deleter = typename base_type::deleter;
 
            using iterator = typename base_type::iterator;
            using const_iterator = typename base_type::const_iterator;
 
            basic_shared_list(const allocator_type& allocator = allocator_type())
                : base_type(allocator), m_lockObject() { }
 
            basic_shared_list(lock_type& lLock, const allocator_type& allocator = allocator_type()) noexcept
                : base_type(allocator), m_lockObject(lLock) { }
 
            template<class InputIterator>
            basic_shared_list(InputIterator first, InputIterator last,
                              const allocator_type& allocator = allocator_type()) noexcept
                : base_type(first, last, allocator_type), m_lockObject() { }
            basic_shared_list(const basic_shared_list& rhs) noexcept
                : base_type(rhs), m_lockObject(rhs.m_lockObject) { }
 
            iterator begin_save(unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return base_type::begin();
            }
 
            const_iterator begin_save() const  {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return base_type::begin();
            }
 
            iterator end_save(unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return base_type::end();
            }
 
            const_iterator end_save(unsigned long xTicksToWait = portMAX_DELAY) const {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return base_type::end();
            }
 
            const_reference front_save(unsigned long xTicksToWait = portMAX_DELAY) const {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return base_type::front();
            }
 
            reference front_save() {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return base_type::front();
            }
 
            const_reference back_save(unsigned long xTicksToWait = portMAX_DELAY) const {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return base_type::back();
            }
 
            reference back_save(unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return base_type::back();
            }
 
            void push_front_save(pointer pValue, unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                base_type::push_front(pointer_type(pValue));
            }
 
            void push_back_save(pointer pValue, unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
 
                base_type::push_back(pointer_type(pValue));
            }
 
            void push_front_save(pointer_type pValue, unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
 
                base_type::push_front(pointer_type);
            }
 
            void push_back_save(pointer_type pValue, unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
 
                base_type::push_back(pointer_type);
            }
 
            inline void pop_back_save(unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                base_type::pop_back();
            }
 
            inline void pop_front_save(unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                base_type::pop_front();
            }
 
            iterator insert(iterator pos, pointer value, unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return base_type::insert(pos, pointer_type(value) );
            }
 
            iterator insert_save(iterator pos, pointer_type value, unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return base_type::insert(pos, (value) );
            }
 
            iterator erase_save(iterator it, unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return base_type::erase(it);
            }
 
 
            iterator erase_save(iterator first, iterator last, unsigned long xTicksToWait = portMAX_DELAY) {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return base_type::erase(first, last);
            }
 
            base_type& list(unsigned long xTicksToWait = portMAX_DELAY) noexcept {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return *(static_cast<base_type*>(this));
            }
 
            const base_type& list(unsigned long xTicksToWait = portMAX_DELAY) const noexcept {
                basic_autolock<TLockType> _lock(m_lockObject, xTicksToWait);
                return *(static_cast<base_type*>(this));
            }
 
            int lock(unsigned long xTicksToWait = portMAX_DELAY) {
                return m_lockObject.lock(xTicksToWait);
            }
            int unlock() {
                return m_lockObject.unlock();
            }
        protected:
            lock_type m_lockObject;
        };
 
        template <typename T, typename TLockType = mn::mutex_t>
        using shared_ptr_list =  basic_shared_list<T, TLockType>;
    }
}
 
 
#endif // __MINILIB_BASIC_SHARED_LIST_H__