fluent.hpp

/*
  ANCH Framework: ANother C++ Hack is a C++ framework based on C++11 standard
  Copyright (C) 2012 Vincent Lachenal
 
  This file is part of ANCH Framework.
 
  ANCH Framework is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  ANCH Framework 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 ANCH Framework.  If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
 
#include <vector>
#include <functional>
#include <limits>
#include <cstdint>
 
 
namespace anch {

  template<typename T, template<typename> typename C>
  class Fluent {
    // Attributes +
  private:
    C<T>* _internalValues;

    C<T>& _values;

    std::vector<std::function<bool(const T&)>> _filters;

    uint64_t _skip;

    uint64_t _limit;

    uint64_t _index;

    uint64_t _treated;

    Fluent<T,C>* _next;
    // Attributes -
 
    // Constructors +
  public:
    Fluent() = delete;

    Fluent(C<T>& container);

    Fluent(const Fluent& other);

    Fluent(Fluent&& other);
    // Constructors -
 
    // Destructor +
  public:
    virtual ~Fluent();
    // Destructor -
 
    // Methods +
  public:
    Fluent& filter(std::function<bool(const T&)> predicate);

    Fluent& skip(uint64_t skip);

    Fluent& limit(uint64_t limit);

    Fluent& concat(Fluent<T,C>& other) noexcept;

    bool allMatch(std::function<bool(const T&)> predicate);

    bool anyMatch(std::function<bool(const T&)> predicate);

    bool noneMatch(std::function<bool(const T&)> predicate);

    void forEach(std::function<void(T&)> action);

    template<typename U>
    Fluent<U,std::vector> map(std::function<U(const T&)> mapper);

    template<typename D>
    void collect(D& container, std::function<void(D&,const T&)> collector);

    template<typename D>
    D collect(std::function<void(D&,const T&)> collector);

    template<typename D, typename R>
    void collect(D& container, R(D::*collector)(const T&));

    template<typename D, typename R>
    D collect(R(D::*collector)(const T&));
 
  private:
    void forEach(std::function<void(T&)> action, const std::vector<std::function<bool(const T&)>>& filters);

    bool allMatch(std::function<bool(const T&)> predicate, const std::vector<std::function<bool(const T&)>>& filters);

    bool anyMatch(std::function<bool(const T&)> predicate, const std::vector<std::function<bool(const T&)>>& filters);

    bool noneMatch(std::function<bool(const T&)> predicate, const std::vector<std::function<bool(const T&)>>& filters);

    bool limitReached() const;
    // Methods -
 
  };
 
}
 
#include "impl/fluent.hpp"