Sequence.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2017.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#ifndef __FWATOMS_SEQUENCE_HPP__
#define __FWATOMS_SEQUENCE_HPP__

#include "fwAtoms/Base.hpp"
#include "fwAtoms/config.hpp"
#include "fwAtoms/factory/new.hpp"

#include <vector>

namespace fwAtoms
{
class FWATOMS_CLASS_API Sequence : public Base
{
public:
    fwCoreClassDefinitionsWithFactoryMacro( (Sequence)(::fwAtoms::Base), (()), ::fwAtoms::factory::New< Sequence > );

    typedef std::vector<Base::sptr> SequenceType;

    typedef SequenceType::value_type ValueType;
    typedef SequenceType::reference ReferenceType;
    typedef SequenceType::const_reference ConstReferenceType;
    typedef SequenceType::iterator IteratorType;
    typedef SequenceType::const_iterator ConstIteratorType;
    typedef SequenceType::reverse_iterator ReverseIteratorType;
    typedef SequenceType::const_reverse_iterator ConstReverseIteratorType;
    typedef SequenceType::size_type SizeType;

    typedef SequenceType::value_type value_type;
    typedef SequenceType::reference reference;
    typedef SequenceType::const_reference const_reference;
    typedef SequenceType::iterator iterator;
    typedef SequenceType::const_iterator const_iterator;
    typedef SequenceType::reverse_iterator reverse_iterator;
    typedef SequenceType::const_reverse_iterator const_reverse_iterator;
    typedef SequenceType::size_type size_type;

    Sequence(::fwAtoms::Base::Key key)
    {
    }

    virtual ~Sequence()
    {
    }

    void push_back(const Base::sptr& value)
    {
        m_value.push_back(value);
    }

    IteratorType  begin()
    {
        return m_value.begin();
    }

    IteratorType  end()
    {
        return m_value.end();
    }

    ConstIteratorType begin() const
    {
        return m_value.begin();
    }

    ConstIteratorType end() const
    {
        return m_value.end();
    }

    size_type size() const
    {
        return m_value.size();
    }

    void  clear()
    {
        m_value.clear();
    }

    bool empty() const
    {
        return m_value.empty();
    }

    const SequenceType& getValue() const
    {
        return m_value;
    }

    Base::sptr& operator[](unsigned int index)
    {
        return m_value[index];
    }
    //------------------------------------------------------------------------------

    const Base::sptr& operator[](unsigned int index) const
    {
        return m_value[index];
    }

    FWATOMS_API virtual Base::sptr clone() const override;

    ::fwAtoms::Base::AtomType type() const override
    {
        return ::fwAtoms::Base::SEQUENCE;
    }

protected:
    SequenceType m_value;
};

}
#endif //__FWATOMS_SEQUENCE_HPP__