inline_borrowable.h

// Copyright 2022 The Pigweed Authors
//
// 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
//
//     https://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 <tuple>
#include <utility>
 
#include "pw_sync/borrow.h"
#include "pw_sync/internal/borrowable_storage.h"
#include "pw_sync/mutex.h"
#include "pw_sync/virtual_basic_lockable.h"
 
namespace pw::sync {
 
 
template <typename GuardedType,
          typename Lock = pw::sync::VirtualMutex,
          typename LockInterface = Lock>
class InlineBorrowable : private internal::BorrowableStorage<GuardedType, Lock>,
                         public Borrowable<GuardedType, LockInterface> {
  using Storage = internal::BorrowableStorage<GuardedType, Lock>;
  using Base = Borrowable<GuardedType, LockInterface>;
 
 public:
  constexpr InlineBorrowable()
      : Storage(std::in_place), Base(Storage::object_, Storage::lock_) {}
 
  template <typename... Args>
  constexpr explicit InlineBorrowable(std::in_place_t, Args&&... args)
      : Storage(std::in_place, std::forward<Args>(args)...),
        Base(Storage::object_, Storage::lock_) {}
 
  template <typename... ObjectArgs, typename... LockArgs>
  constexpr explicit InlineBorrowable(
      std::tuple<ObjectArgs...>&& object_args,
      std::tuple<LockArgs...>&& lock_args = std::make_tuple())
      : Storage(std::forward<std::tuple<ObjectArgs...>>(object_args),
                std::forward<std::tuple<LockArgs...>>(lock_args)),
        Base(Storage::object_, Storage::lock_) {}
 
  template <
      typename ObjectConstructor,
      typename LockConstructor = Lock (*)(),
      typename = std::enable_if_t<
          std::is_invocable_r_v<GuardedType, ObjectConstructor>>,
      typename = std::enable_if_t<std::is_invocable_r_v<Lock, LockConstructor>>>
  constexpr explicit InlineBorrowable(
      const ObjectConstructor& object_ctor,
      const LockConstructor& lock_ctor = internal::DefaultConstruct<Lock>)
      : Storage(object_ctor, lock_ctor),
        Base(Storage::object_, Storage::lock_) {}
 
  template <
      typename ObjectConstructor,
      typename LockConstructor = Lock (*)(),
      typename = std::enable_if_t<
          std::is_invocable_r_v<GuardedType, ObjectConstructor>>,
      typename = std::enable_if_t<std::is_invocable_r_v<Lock, LockConstructor>>>
  constexpr explicit InlineBorrowable(
      ObjectConstructor& object_ctor,
      const LockConstructor& lock_ctor = internal::DefaultConstruct<Lock>)
      : Storage(object_ctor, lock_ctor),
        Base(Storage::object_, Storage::lock_) {}
 
  template <
      typename ObjectConstructor,
      typename LockConstructor = Lock (*)(),
      typename = std::enable_if_t<
          std::is_invocable_r_v<GuardedType, ObjectConstructor>>,
      typename = std::enable_if_t<std::is_invocable_r_v<Lock, LockConstructor>>>
  constexpr explicit InlineBorrowable(const ObjectConstructor& object_ctor,
                                      LockConstructor& lock_ctor)
      : Storage(object_ctor, lock_ctor),
        Base(Storage::object_, Storage::lock_) {}
 
  template <
      typename ObjectConstructor,
      typename LockConstructor = Lock (*)(),
      typename = std::enable_if_t<
          std::is_invocable_r_v<GuardedType, ObjectConstructor>>,
      typename = std::enable_if_t<std::is_invocable_r_v<Lock, LockConstructor>>>
  constexpr explicit InlineBorrowable(ObjectConstructor& object_ctor,
                                      LockConstructor& lock_ctor)
      : Storage(object_ctor, lock_ctor),
        Base(Storage::object_, Storage::lock_) {}
};
 
 
}  // namespace pw::sync