/*
- * Copyright 2012 Facebook, Inc.
+ * Copyright 2013 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
template<class Body>
void foreach(Body&& body) const {
- this->self().apply([&](Value value) {
+ this->self().apply([&](Value value) -> bool {
body(std::forward<Value>(value));
return true;
});
public GenImpl<Result, Generator<Value, Source, Result>> {
Source source_;
Predicate pred_;
- public:
+ public:
explicit Generator(Source source, const Predicate& pred)
: source_(std::move(source)), pred_(pred) {}
*/
class Take : public Operator<Take> {
size_t count_;
-public:
+ public:
explicit Take(size_t count)
: count_(count) {}
*/
class Skip : public Operator<Skip> {
size_t count_;
-public:
+ public:
explicit Skip(size_t count)
: count_(count) {}
public GenImpl<Value, Generator<Value, Source>> {
Source source_;
size_t count_;
- public:
+ public:
explicit Generator(Source source, size_t count)
: source_(std::move(source)) , count_(count) {}
Selector selector_;
Comparer comparer_;
public:
- Order(const Selector& selector = Selector(),
- const Comparer& comparer = Comparer())
+ explicit Order(const Selector& selector = Selector(),
+ const Comparer& comparer = Comparer())
: selector_(selector) , comparer_(comparer) {}
template<class Value,
class Composed : public Operator<Composed<First, Second>> {
First first_;
Second second_;
- public:
- Composed() {}
- Composed(First first, Second second)
- : first_(std::move(first))
- , second_(std::move(second)) {}
+ public:
+ Composed() {}
+ Composed(First first, Second second)
+ : first_(std::move(first))
+ , second_(std::move(second)) {}
template<class Source,
class Value,
*/
class First : public Operator<First> {
public:
+ First() { }
+
template<class Source,
class Value,
class StorageType = typename std::decay<Value>::type>
*/
class Any : public Operator<Any> {
public:
+ Any() { }
+
template<class Source,
class Value>
bool compose(const GenImpl<Value, Source>& source) const {
class Reduce : public Operator<Reduce<Reducer>> {
Reducer reducer_;
public:
- Reduce(const Reducer& reducer)
+ explicit Reduce(const Reducer& reducer)
: reducer_(reducer)
{}
*/
class Count : public Operator<Count> {
public:
+ Count() { }
+
template<class Source,
class Value>
size_t compose(const GenImpl<Value, Source>& source) const {
*/
class Sum : public Operator<Sum> {
public:
+ Sum() { }
+
template<class Source,
class Value,
class StorageType = typename std::decay<Value>::type>
Selector selector_;
Comparer comparer_;
public:
- Min(const Selector& selector = Selector(),
- const Comparer& comparer = Comparer())
+ explicit Min(const Selector& selector = Selector(),
+ const Comparer& comparer = Comparer())
: selector_(selector)
, comparer_(comparer)
{}
template<class Collection>
class Collect : public Operator<Collect<Collection>> {
public:
+ Collect() { }
+
template<class Value,
class Source,
class StorageType = typename std::decay<Value>::type>
template<class> class Allocator>
class CollectTemplate : public Operator<CollectTemplate<Container, Allocator>> {
public:
+ CollectTemplate() { }
+
template<class Value,
class Source,
class StorageType = typename std::decay<Value>::type,
return collection;
}
};
+
/**
* Concat - For flattening generators of generators.
*
* | as<std::set>();
*/
class Concat : public Operator<Concat> {
-public:
+ public:
+ Concat() { }
+
template<class Inner,
class Source,
class InnerValue = typename std::decay<Inner>::type::ValueType>
class Generator :
public GenImpl<InnerValue, Generator<Inner, Source, InnerValue>> {
Source source_;
- public:
+ public:
explicit Generator(Source source)
: source_(std::move(source)) {}
* | as<std::set>();
*/
class RangeConcat : public Operator<RangeConcat> {
-public:
+ public:
+ RangeConcat() { }
+
template<class Source,
class Range,
class InnerValue = typename ValueTypeOfRange<Range>::RefType>
template<class Handler>
bool apply(Handler&& handler) const {
- return source_.apply([&](Range range) {
+ return source_.apply([&](Range range) -> bool {
for (auto& value : range) {
if (!handler(value)) {
return false;