DataPartition.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_DataPartition_h
#define yap_DataPartition_h

#include "fwd/DataPartition.h"

#include "fwd/DataPoint.h"
#include "fwd/DataSet.h"

#include "StatusManager.h"

#include <iterator>

namespace yap {

class DataIterator : public std::iterator<std::random_access_iterator_tag, DataPoint>
{
protected:

    DataIterator(const DataPartition& p)
        : Partition_(&p) {}

    DataIterator(const DataPartition& p, DataPointVector::iterator it)
        : Partition_(&p), Iterator_(it) {}

public:

    const DataPartition* partition() const
    { return Partition_; }

    DataIterator& operator+=(DataIterator::difference_type n);

    DataIterator& operator++()
    { return (*this += 1); }

    DataIterator operator++(int)
    { DataIterator it(*this); ++(*this); return it; }

    DataIterator& operator--()
    { return (*this += -1); }

    const DataIterator operator--(int)
    { DataIterator it(*this); --(*this); return it; }

    DataIterator& operator-=(DataIterator::difference_type n)
    { return (*this += -n); }

    friend const DataIterator::difference_type operator-(const DataIterator& lhs, const DataIterator& rhs);

    DataPoint& operator*()
    { return *Iterator_; }

    const DataPoint& operator*() const
    { return *Iterator_; }

    DataPoint operator->()
    { return *(this->Iterator_).operator->(); }

    bool ownedBy(const DataPartition& dp) const
    { return Partition_ == &dp; }

    friend const bool operator<(const DataIterator& lhs, const DataIterator& rhs)
    { return lhs.Iterator_ < rhs.Iterator_; }

    friend const bool operator>(const DataIterator& lhs, const DataIterator& rhs)
    { return lhs.Iterator_ > rhs.Iterator_; }

    friend const bool operator==(const DataIterator& lhs, const DataIterator& rhs)
    { return lhs.Iterator_ == rhs.Iterator_; }

    DataPoint operator[](DataIterator::difference_type n) const
    { return *(Iterator_ + n); }

    friend DataPartition;

private:

    const DataPartition* Partition_;

    DataPointVector::iterator Iterator_;

};

inline const DataIterator operator+(DataIterator lhs, DataIterator::difference_type n)
{ return (lhs += n); }

inline const DataIterator operator+(DataIterator::difference_type n, const DataIterator& rhs)
{ return (rhs + n); }

inline const DataIterator operator-(const DataIterator& lhs, DataIterator::difference_type n)
{ return (lhs + (-n)); }

inline const bool operator<=(const DataIterator& lhs, const DataIterator& rhs)
{ return !(lhs > rhs); }

inline const bool operator>=(const DataIterator& lhs, const DataIterator& rhs)
{ return !(lhs < rhs); }

inline const bool operator!=(const DataIterator& lhs, const DataIterator& rhs)
{ return !(lhs == rhs); }

class DataPartition : public StatusManager
{
protected:

    DataPartition(const StatusManager& sm, DataPointVector::iterator begin, DataPointVector::iterator end)
        : StatusManager(sm), Begin_(*this, begin), End_(*this, end) {}

    DataPartition(const DataAccessorSet& sDA)
        : StatusManager(sDA), Begin_(*this), End_(*this) {}

public:

    virtual ~DataPartition() = default;

    DataPartition(const DataPartition&) = default;

    DataPartition(DataPartition&&) = default;

    DataPartition& operator=(const DataPartition&) = default;

    DataPartition& operator=(DataPartition&&) = default;

    virtual const DataIterator& begin() const
    { return Begin_; }

    virtual const DataIterator& end() const
    { return End_; }

    virtual const size_t size() const
    { return difference(end().Iterator_, begin().Iterator_); }

    virtual const DataIterator::difference_type difference(const DataPointVector::iterator& lhs, const DataPointVector::iterator& rhs) const = 0;

    friend DataIterator;

    friend class Model;

protected:

    virtual DataIterator& increment(DataIterator& it, DataIterator::difference_type n) const = 0;

    DataPointVector::iterator& rawIterator(DataIterator& it) const
    { return it.Iterator_; }

    const DataPointVector::iterator& rawIterator(const DataIterator& it) const
    { return it.Iterator_; }

    DataIterator dataIterator(DataPointVector::iterator it, const DataPartition* part) const
    { return (part) ? DataIterator(*part, it) : DataIterator(*this, it); }

    const DataIterator& setBegin(DataPointVector::iterator it)
    { Begin_ = DataIterator(*this, it); return Begin_; }

    const DataIterator& setEnd(DataPointVector::iterator it)
    { End_ = DataIterator(*this, it); return End_; }

    static DataPointVector::iterator begin(DataSet& ds);

    static DataPointVector::iterator end(DataSet& ds);

private:

    DataIterator Begin_;

    DataIterator End_;

};

class DataPartitionWeave : public DataPartition
{
public:

    DataPartitionWeave(const StatusManager& sm, DataPointVector::iterator begin, DataPointVector::iterator end, unsigned spacing)
        : DataPartition(sm, begin, end), Spacing_(spacing) {}

    static DataPartitionVector create(DataSet& dataSet, unsigned n);

    virtual const DataIterator::difference_type difference(const DataPointVector::iterator& lhs, const DataPointVector::iterator& rhs) const override
    { return DataPartition::difference(lhs, rhs) / Spacing_; }

protected:

    DataPartitionWeave(const DataAccessorSet& sDA, unsigned spacing)
        : DataPartition(sDA), Spacing_(spacing) {}

    virtual DataIterator& increment(DataIterator& it, DataIterator::difference_type n) const override;

    unsigned Spacing_;
};

class DataPartitionBlock : public DataPartitionWeave
{
public:

    static DataPartitionVector create(DataSet& dataSet, unsigned n);

    static DataPartitionVector createBySize(DataSet& dataSet, size_t s);

protected:

    DataPartitionBlock(const StatusManager& sm, DataPointVector::iterator begin, DataPointVector::iterator end)
        : DataPartitionWeave(sm, begin, end, 1) {}

    DataPartitionBlock(const DataAccessorSet& sDA)
        : DataPartitionWeave(sDA, 1) {}

};

}

#endif