lfVector.h

/* Copyright (c) 2011-2015, EPFL/Blue Brain Project
 *                          Stefan Eilemann <stefan.eilemann@epfl.ch>
 *
 * This file is part of Lunchbox <https://github.com/Eyescale/Lunchbox>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 3.0 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef LUNCHBOX_LFVECTOR_H
#define LUNCHBOX_LFVECTOR_H

#include <algorithm>               // used inline
#include <lunchbox/bitOperation.h> // used inline
#include <lunchbox/debug.h>        // used inline
#include <lunchbox/os.h>           // bzero()
#include <lunchbox/scopedMutex.h>  // member
#include <lunchbox/serializable.h>
#include <lunchbox/spinLock.h> // member
#include <stdexcept>

namespace lunchbox
{
template <class T, int32_t nSlots = 32>
class LFVector
{
public:
    using ScopedWrite = std::unique_lock<SpinLock>;
    typedef T value_type;

    LFVector();

    explicit LFVector(const size_t n);

    LFVector(const size_t n, const T& t);

    explicit LFVector(const LFVector& from);

    template <int32_t fromSlots>
    explicit LFVector(const LFVector<T, fromSlots>& from);

    ~LFVector();

    LFVector& operator=(const LFVector& from);

    bool operator==(const LFVector& rhs) const;

    bool operator!=(const LFVector& rhs) const { return !(*this == rhs); }
    bool empty() const { return size_ == 0; } 
    size_t size() const { return size_; }     

    T& operator[](size_t i);

    const T& operator[](size_t i) const;

    T& front();

    T& back();

    typedef LFVectorIterator<LFVector<T, nSlots>, T> iterator;

    typedef LFVectorIterator<const LFVector<T, nSlots>, const T> const_iterator;

    const_iterator begin() const; 
    const_iterator end() const;   
    iterator begin();             
    iterator end();               

    void expand(const size_t newSize, const T& item = T());

    void push_back(const T& item, bool lock = true);

    void pop_back();

    bool pop_back(T& element);

    iterator erase(typename LFVector<T, nSlots>::iterator pos);

    iterator erase(const T& element);

    void resize(const size_t size, const T& value = T());

    void clear();

    ScopedWrite getWriteLock();

private:
    LB_SERIALIZABLE

    T* slots_[nSlots];
    size_t size_;
    mutable SpinLock lock_;

    template <int32_t fromSlots>
    void assign_(const LFVector<T, fromSlots>& from);

    void push_back_unlocked_(const T& item);

    void trim_();
};

template <class T>
std::ostream& operator<<(std::ostream& os, const LFVector<T>& v);
}

#include "lfVector.ipp" // template implementation

#endif // LUNCHBOX_LFVECTOR_H