Copyright 2013 -> 2014
[folly.git] / folly / MoveWrapper.h
1 /*
2  * Copyright 2014 Facebook, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *   http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #pragma once
18
19 #include <memory>
20
21 namespace folly {
22
23 /** C++11 closures don't support move-in capture. Nor does std::bind.
24     facepalm.
25
26     http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3610.html
27
28     "[...] a work-around that should make people's stomach crawl:
29     write a wrapper that performs move-on-copy, much like the deprecated
30     auto_ptr"
31
32     Unlike auto_ptr, this doesn't require a heap allocation.
33     */
34 template <class T>
35 class MoveWrapper {
36  public:
37   /** If value can be default-constructed, why not?
38       Then we don't have to move it in */
39   MoveWrapper() = default;
40
41   /// Move a value in.
42   explicit
43   MoveWrapper(T&& t) : value(std::move(t)) {}
44
45   /// copy is move
46   MoveWrapper(const MoveWrapper& other) : value(std::move(other.value)) {}
47
48   /// move is also move
49   MoveWrapper(MoveWrapper&& other) : value(std::move(other.value)) {}
50
51   const T& operator*() const { return value; }
52         T& operator*()       { return value; }
53
54   const T* operator->() const { return &value; }
55         T* operator->()       { return &value; }
56
57   // If you want these you're probably doing it wrong, though they'd be
58   // easy enough to implement
59   MoveWrapper& operator=(MoveWrapper const&) = delete;
60   MoveWrapper& operator=(MoveWrapper&&) = delete;
61
62  private:
63   mutable T value;
64 };
65
66 template <class T>
67 MoveWrapper<T> makeMoveWrapper(T&& t) {
68     return MoveWrapper<T>(std::forward<T>(t));
69 }
70
71 } // namespace