DataSet.h

Go to the documentation of this file.

/*  YAP - Yet another PWA toolkit
    Copyright 2015, Technische Universitaet Muenchen,
    Authors: Daniel Greenwald, Johannes Rauch

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef yap_DataSet_h
#define yap_DataSet_h

#include "fwd/DataPoint.h"
#include "fwd/FourVector.h"
#include "fwd/Model.h"
#include "fwd/StatusManager.h"

#include "DataPartition.h"

#include <vector>

namespace yap {

class DataSet : public DataPartitionBlock
{
public:

    DataSet(const Model& m);

    bool consistent(const DataPoint& d) const;

    void addEmptyDataPoints(size_t n);

    using value_type = std::vector<FourVector<double> >;

    const DataPoint createDataPoint(const std::vector<FourVector<double> >& P, StatusManager& sm);

    const DataPoint createDataPoint(const std::vector<FourVector<double> >& P)
    { return createDataPoint(P, *this); }

    void push_back(const std::vector<FourVector<double> >& P)
    { DataPoints_.push_back(createDataPoint(P)); }

    void push_back(const DataPoint& d);

    void push_back(DataPoint&& d);

    DataIterator insert(DataIterator pos, const std::vector<FourVector<double> >& P)
    { return dataIterator(DataPoints_.insert(rawIterator(pos), createDataPoint(P)), pos.partition()); }

    DataIterator insert(const DataIterator& pos, const DataPoint& d);

    DataIterator insert(const DataIterator& pos, DataPoint&& d);

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

    void pop_back()
    { DataPoints_.pop_back(); }

    DataIterator erase(const DataIterator& pos)
    { return dataIterator(DataPoints_.erase(rawIterator(pos)), pos.partition()); }

    DataIterator erase(const DataIterator& first, const DataIterator& last);

    const DataIterator& begin() const override
    { return const_cast<DataSet*>(this)->setBegin(const_cast<DataPointVector*>(&DataPoints_)->begin()); }

    const DataIterator& end() const override
    { return const_cast<DataSet*>(this)->setEnd(const_cast<DataPointVector*>(&DataPoints_)->end()); }

    DataPoint& operator[](size_t i)
    { return DataPoints_[i]; }

    DataPoint& at(size_t i)
    { return DataPoints_.at(i); }

    const DataPoint& front() const
    { return DataPoints_.front(); }

    const DataPoint& back() const
    { return DataPoints_.back(); }

    const unsigned bytes() const;

    const size_t size() const override
    { return DataPoints_.size(); }

    const size_t max_size() const
    { return DataPoints_.max_size(); }

    const size_t capacity() const
    { return DataPoints_.capacity(); }

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

    void reserve(size_t n)
    { DataPoints_.reserve(n); }

    void shrink_to_fit()
    { DataPoints_.shrink_to_fit(); }

    const Model* model() const
    { return Model_; }

    friend DataPartition;

protected:

    DataPointVector& dataPoints()
    { return DataPoints_; }

private:
    DataPointVector DataPoints_;

    const Model* Model_;

};

}

#endif