Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 392a4936 authored by Zach Johnson's avatar Zach Johnson Committed by Gerrit Code Review
Browse files

Merge changes I980a3c28,I4f686d13 

* changes:
  Add ContextualCallback and start using for hci events
  Create ContextualOnceCallback, to bind together a context and a callback
parents 717697eb c599487a

system/gd/common/bind.h

+2 −1
Original line number Diff line number Diff line
@@ -25,13 +25,14 @@ using base::Bind; 
using base::BindOnce;

using base::ConstRef;

using base::IgnoreResult;

using base::MakeUnboundRunType;

using base::Owned;

using base::Passed;

using base::RetainedRef;

using base::Unretained;



template <typename T, typename Functor, typename... Args>

inline base::Callback<base::MakeUnboundRunType<Functor, T, Args...>> BindOn(T* obj, Functor&& functor, Args&&... args) {

inline base::Callback<MakeUnboundRunType<Functor, T, Args...>> BindOn(T* obj, Functor&& functor, Args&&... args) {

  return common::Bind(std::forward<Functor>(functor), common::Unretained(obj), std::forward<Args>(args)...);

}

system/gd/common/contextual_callback.h

0 → 100644
+84 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2019 The Android Open Source Project

 *

 * 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.

 */



#pragma once



#include "common/bind.h"

#include "common/callback.h"



namespace bluetooth {

namespace common {



class IPostableContext {

 public:

  virtual ~IPostableContext(){};

  virtual void Post(OnceClosure closure) = 0;

};



template <typename R, typename... Args>

class ContextualOnceCallback;



// A callback bound to an execution context that can be invoked only once.

template <typename R, typename... Args>

class ContextualOnceCallback<R(Args...)> {

 public:

  ContextualOnceCallback(common::OnceCallback<R(Args...)>&& callback, IPostableContext* context)

      : callback_(std::move(callback)), context_(context) {}



  constexpr ContextualOnceCallback() = default;



  DISALLOW_COPY_AND_ASSIGN(ContextualOnceCallback);



  ContextualOnceCallback(ContextualOnceCallback&&) noexcept = default;

  ContextualOnceCallback& operator=(ContextualOnceCallback&&) noexcept = default;



  void Invoke(Args... args) {

    context_->Post(common::BindOnce(std::move(callback_), std::forward<Args>(args)...));

  }



 private:

  common::OnceCallback<R(Args...)> callback_;

  IPostableContext* context_;

};



template <typename R, typename... Args>

class ContextualCallback;



// A callback bound to an execution context that can be invoked multiple times.

template <typename R, typename... Args>

class ContextualCallback<R(Args...)> {

 public:

  ContextualCallback(common::Callback<R(Args...)>&& callback, IPostableContext* context)

      : callback_(std::move(callback)), context_(context) {}



  constexpr ContextualCallback() = default;



  ContextualCallback(const ContextualCallback&) = default;

  ContextualCallback& operator=(const ContextualCallback&) = default;

  ContextualCallback(ContextualCallback&&) noexcept = default;

  ContextualCallback& operator=(ContextualCallback&&) noexcept = default;



  void Invoke(Args... args) {

    context_->Post(common::BindOnce(callback_, std::forward<Args>(args)...));

  }



 private:

  common::Callback<R(Args...)> callback_;

  IPostableContext* context_;

};



}  // namespace common

}  // namespace bluetooth