| /* |
| * Copyright 2015 Twitter, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef HERON_CALLBACK1_H_ |
| #define HERON_CALLBACK1_H_ |
| |
| #include <functional> |
| |
| // |
| // Sometimes we might want to pass some status or data to the functions being invoked. |
| // In that case we create CallBack1 instead of a CallBack and do something like this |
| // void Routine(int arg, int arg2, CallBack1<int>* cb) { |
| // ... some code ... |
| // cb->Run(arg2); |
| // } |
| // This way Routine can pass status/data to the CallBack cb without having to worry abt |
| // its signature or its associated arguments. |
| // Users can invoke Routine in the following manner |
| // CallBack1<int>* cb = CreateCallback(void (*func)(int)); |
| // or |
| // CallBack1<int> cb = CreateCallback(void (*func)(int, char), 'c'); |
| // Routine(arg, arg2, cb); |
| |
| template <typename C> |
| class CallBack1 { |
| public: |
| // Constructor. Users should use the CreateCallback functions detailed below. |
| CallBack1(bool persist, std::function<void(C)> f) |
| : persistent_(persist), bind_(f) {} |
| |
| virtual ~CallBack1() {} |
| |
| // The main exported function |
| void Run(C c) { |
| // In case of persistent callbacks, the RunCallback might delete itself. |
| // In that case after RunCallback returns it is not safe to access |
| // the class member persistent_. So make a copy now. |
| bool persist = persistent_; |
| bind_(c); |
| if (!persist) { |
| delete this; |
| } |
| } |
| |
| // Return whether the callback is temporary or permanent. |
| bool isPersistent() const { return persistent_; } |
| |
| private: |
| bool persistent_; |
| std::function<void(C)> bind_; |
| }; |
| |
| template <typename C, typename... T> |
| CallBack1<C>* CreateCallback(void (*cb)(C, T...), T... args) { |
| return new CallBack1<C>(false, std::bind(cb, std::placeholders::_1, args...)); |
| } |
| |
| #endif // HERON_CLASS_CALLBACK1_H_ |