/usr/local/lib64/python3.6/site-packages/pyarrow/include/arrow/util
Edit: /usr/local/lib64/python3.6/site-packages/pyarrow/include/arrow/util/functional.h (5612B)
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you 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
#include
#include
#include "arrow/result.h"
#include "arrow/util/macros.h"
namespace arrow {
namespace internal {
struct Empty {
static Result ToResult(Status s) {
if (ARROW_PREDICT_TRUE(s.ok())) {
return Empty{};
}
return s;
}
};
/// Helper struct for examining lambdas and other callables.
/// TODO(ARROW-12655) support function pointers
struct call_traits {
public:
template
static std::false_type is_overloaded_impl(R(A...));
template
static std::false_type is_overloaded_impl(decltype(&F::operator())*);
template
static std::true_type is_overloaded_impl(...);
template
static R return_type_impl(R (F::*)(A...));
template
static R return_type_impl(R (F::*)(A...) const);
template
static typename std::tuple_element>::type argument_type_impl(
R (F::*)(A...));
template
static typename std::tuple_element>::type argument_type_impl(
R (F::*)(A...) const);
template
static typename std::tuple_element>::type argument_type_impl(
R (F::*)(A...) &&);
template
static std::integral_constant argument_count_impl(R (F::*)(A...));
template
static std::integral_constant argument_count_impl(R (F::*)(A...)
const);
template
static std::integral_constant argument_count_impl(R (F::*)(A...) &&);
/// bool constant indicating whether F is a callable with more than one possible
/// signature. Will be true_type for objects which define multiple operator() or which
/// define a template operator()
template
using is_overloaded =
decltype(is_overloaded_impl::type>(NULLPTR));
template
using enable_if_overloaded = typename std::enable_if::value, T>::type;
template
using disable_if_overloaded =
typename std::enable_if::value, T>::type;
/// If F is not overloaded, the argument types of its call operator can be
/// extracted via call_traits::argument_type
template
using argument_type = decltype(argument_type_impl(&std::decay::type::operator()));
template
using argument_count = decltype(argument_count_impl(&std::decay::type::operator()));
template
using return_type = decltype(return_type_impl(&std::decay::type::operator()));
template
using enable_if_return =
typename std::enable_if, T>::value, RT>;
template
using enable_if_empty = typename std::enable_if::value, R>::type;
template
using enable_if_not_empty =
typename std::enable_if::value, R>::type;
};
/// A type erased callable object which may only be invoked once.
/// It can be constructed from any lambda which matches the provided call signature.
/// Invoking it results in destruction of the lambda, freeing any state/references
/// immediately. Invoking a default constructed FnOnce or one which has already been
/// invoked will segfault.
template
class FnOnce;
template
class FnOnce {
public:
FnOnce() = default;
template ()(std::declval()...)), R>::value>::type>
FnOnce(Fn fn) : impl_(new FnImpl(std::move(fn))) { // NOLINT runtime/explicit
}
explicit operator bool() const { return impl_ != NULLPTR; }
R operator()(A... a) && {
auto bye = std::move(impl_);
return bye->invoke(std::forward(a)...);
}
private:
struct Impl {
virtual ~Impl() = default;
virtual R invoke(A&&... a) = 0;
};
template
struct FnImpl : Impl {
explicit FnImpl(Fn fn) : fn_(std::move(fn)) {}
R invoke(A&&... a) override { return std::move(fn_)(std::forward(a)...); }
Fn fn_;
};
std::unique_ptr impl_;
};
} // namespace internal
} // namespace arrow