TypeHelpers.h

/*
 * Copyright (C) 2022 HERE Europe B.V.
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */
 
#pragma once
 
#include <functional>
#include <type_traits>
#include <vector>
 
#include <olp/core/client/ApiError.h>
#include <olp/core/porting/make_unique.h>
 
namespace olp {
namespace thread {
namespace internal {
 
template <typename Type>
struct RemoveRefAndConstImpl {
  using type =
      typename std::remove_cv<typename std::remove_reference<Type>::type>::type;
};
 
template <typename Type>
using RemoveRefAndConst = typename RemoveRefAndConstImpl<Type>::type;
 
template <typename Type>
struct ReduceVoidVector {
  using type =
      typename std::conditional<std::is_same<Type, std::vector<void>>::value,
                                void, Type>::type;
};
 
template <typename Type>
struct TypeToFunctionInputImpl {
  using type = std::function<void(Type)>;
};
 
template <>
struct TypeToFunctionInputImpl<void> {
  using type = std::function<void()>;
};
 
template <typename Type>
using TypeToFunctionInput = typename TypeToFunctionInputImpl<Type>::type;
 
template <typename Class, typename ExecutionContext, typename Arg>
Arg SecondArgType(void (Class::*)(ExecutionContext, Arg) const);
 
template <typename Class, typename ExecutionContext, typename Arg>
Arg SecondArgType(void (Class::*)(ExecutionContext, Arg));
 
template <typename Class, typename Some, typename ExecutionContext,
          typename Arg>
Arg ThirdArgType(void (Class::*)(Some, ExecutionContext, Arg) const);
 
template <typename Class, typename Some, typename ExecutionContext,
          typename Arg>
Arg ThirdArgType(void (Class::*)(Some, ExecutionContext, Arg));
 
void FuncArgType(std::function<void()>);
 
template <typename Arg>
Arg FuncArgType(std::function<void(Arg)>);
 
template <typename Callable>
struct AsyncResultTypeImpl {
  using FirstArgType =
      RemoveRefAndConst<decltype(SecondArgType(&Callable::operator()))>;
  using type = RemoveRefAndConst<decltype(FuncArgType(FirstArgType()))>;
};
 
template <typename Callable>
using AsyncResultType = typename AsyncResultTypeImpl<Callable>::type;
 
template <typename Callable>
struct DeducedTypeImpl {
  using ThirdArgTypeParam =
      RemoveRefAndConst<decltype(ThirdArgType(&Callable::operator()))>;
  using type = RemoveRefAndConst<decltype(FuncArgType(ThirdArgTypeParam()))>;
};
 
template <typename Callable>
using DeducedType = typename DeducedTypeImpl<Callable>::type;
 
struct UntypedSmartPointer {
  virtual void* Get() const = 0;
  virtual ~UntypedSmartPointer() = default;
};
 
template <typename SmartPointer>
struct TypedSmartPointer : UntypedSmartPointer {
  explicit TypedSmartPointer(SmartPointer&& pointer)
      : pointer_(std::move(pointer)) {}
 
  void* Get() const override { return static_cast<void*>(pointer_.get()); }
 
  SmartPointer pointer_;
};
 
template <typename SmartPointer>
inline std::unique_ptr<UntypedSmartPointer> MakeUntypedUnique(
    SmartPointer&& ptr) {
  return std::make_unique<TypedSmartPointer<SmartPointer>>(std::move(ptr));
}
 
}  // namespace internal
}  // namespace thread
}  // namespace olp