Commit ba7fdc79 authored by Chip Turner's avatar Chip Turner Committed by woo

Revert "[folly::gen] Making 'just()' reference arguments like 'from()'"

Summary: This reverts commit 90da92b05762f8032560d0d6a66237ab2772d7f2.

Test Plan: compiles

Reviewed By: tjackson@fb.com

Subscribers: lins, anca, folly-diffs@, yfeldblum

FB internal diff: D1817376

Tasks: 6118752
parent 173044e4
......@@ -328,32 +328,13 @@ class Empty : public GenImpl<Value, Empty<Value>> {
void foreach(Body&&) const {}
};
template <class Value>
class SingleReference : public GenImpl<Value&, SingleReference<Value>> {
static_assert(!std::is_reference<Value>::value,
"SingleReference requires non-ref types");
Value* ptr_;
public:
explicit SingleReference(Value* ptr) : ptr_(ptr){}
template <class Handler>
bool apply(Handler&& handler) const {
return handler(*ptr_);
}
template <class Body>
void foreach(Body&& body) const {
body(*ptr_);
}
};
template <class Value>
class SingleCopy : public GenImpl<const Value&, SingleCopy<Value>> {
template<class Value>
class Just : public GenImpl<const Value&, Just<Value>> {
static_assert(!std::is_reference<Value>::value,
"SingleCopy requires non-ref types");
Value value_;
"Just requires non-ref types");
const Value value_;
public:
explicit SingleCopy(Value value) : value_(std::forward<Value>(value)) {}
explicit Just(Value value) : value_(std::forward<Value>(value)) {}
template <class Handler>
bool apply(Handler&& handler) const {
......
......@@ -297,10 +297,7 @@ template<class Value>
class Empty;
template<class Value>
class SingleReference;
template<class Value>
class SingleCopy;
class Just;
/*
* Operators
......@@ -485,25 +482,14 @@ Yield generator(Source&& source) {
/*
* empty() - for producing empty sequences.
*/
template <class Value>
template<class Value>
detail::Empty<Value> empty() {
return {};
}
template <class Value, class Just = detail::SingleReference<Value>>
Just just(Value& value) {
return Just(&value);
}
template <class Value, class Just = detail::SingleReference<const Value>>
Just just(const Value& value) {
return Just(&value);
}
template <class Value,
class Just = detail::SingleCopy<typename std::decay<Value>::type>>
Just just(Value&& value) {
return Just(std::move(value));
template<class Value>
detail::Just<Value> just(Value value) {
return detail::Just<Value>(std::move(value));
}
/*
......
......@@ -136,7 +136,7 @@ class Sub : public Operator<Sub<Sink>> {
class Source,
class Result =
decltype(std::declval<Sink>().compose(std::declval<Source>())),
class Just = SingleCopy<typename std::decay<Result>::type>>
class Just = Just<typename std::decay<Result>::type>>
Just compose(const GenImpl<Value, Source>& source) const {
return Just(source | sink_);
}
......
......@@ -1073,31 +1073,6 @@ TEST(Gen, BatchMove) {
EXPECT_EQ(expected, actual);
}
TEST(Gen, Just) {
{
int x = 3;
auto j = just(x);
EXPECT_EQ(&x, j | mapped([](const int& v) { return &v; }) | first);
x = 4;
EXPECT_EQ(4, j | first);
}
{
int x = 3;
const int& cx = x;
auto j = just(cx);
EXPECT_EQ(&x, j | mapped([](const int& v) { return &v; }) | first);
x = 5;
EXPECT_EQ(5, j | first);
}
{
int x = 3;
auto j = just(std::move(x));
EXPECT_NE(&x, j | mapped([](const int& v) { return &v; }) | first);
x = 5;
EXPECT_EQ(3, j | first);
}
}
int main(int argc, char *argv[]) {
testing::InitGoogleTest(&argc, argv);
gflags::ParseCommandLineFlags(&argc, &argv, true);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment