Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Sign in
Toggle navigation
Menu
Open sidebar
ORNL Quantum Computing Institute
xacc
Commits
d85cbd97
Commit
d85cbd97
authored
Apr 05, 2018
by
Mccaskey, Alex
Browse files
updating cmakelists to search for openssl on fedora
Signed-off-by:
Alex McCaskey
<
mccaskeyaj@ornl.gov
>
parent
7a944307
Changes
34
Expand all
Hide whitespace changes
Inline
Side-by-side
CMakeLists.txt
View file @
d85cbd97
...
...
@@ -75,14 +75,20 @@ ExternalProject_Add(cppmicroservices
# Make it so you don't always have to
# specify openssl dir on mac
if
(
APPLE AND NOT OPENSSL_ROOT_DIR
)
if
(
EXISTS /usr/local/opt/openssl
)
message
(
STATUS
"
${
BoldGreen
}
Searching for OpenSSL from /usr/local/opt/openssl. Override with -DOPENSSL_ROOT_DIR=...
${
ColorReset
}
"
)
set
(
OPENSSL_ROOT_DIR /usr/local/opt/openssl
)
endif
()
if
(
EXISTS /usr/local/opt/openssl
)
message
(
STATUS
"
${
BoldGreen
}
[OSX] Searching for OpenSSL from /usr/local/opt/openssl. Override with -DOPENSSL_ROOT_DIR=...
${
ColorReset
}
"
)
set
(
OPENSSL_ROOT_DIR /usr/local/opt/openssl
)
endif
()
elseif
(
EXISTS /etc/redhat-release AND NOT OPENSSL_ROOT_DIR
)
# we are on fedora... check for custom openssl install
# in /usr/local/ssl
if
(
EXISTS /usr/local/ssl
)
message
(
STATUS
"
${
BoldGreen
}
[Fedora] Searching for OpenSSL from /usr/local/ssl. Override with -DOPENSSL_ROOT_DIR=...
${
ColorReset
}
"
)
set
(
OPENSSL_ROOT_DIR /usr/local/ssl
)
endif
()
endif
()
find_package
(
OpenSSL 1.0.2 REQUIRED
)
message
(
STATUS
"
${
BoldGreen
}
Found OpenSSL version
${
OPENSSL_VERSION
}${
ColorReset
}
"
)
message
(
STATUS
"
${
BoldGreen
}
Found OpenSSL version
${
OPENSSL_VERSION
}${
ColorReset
}
at
${
OPENSSL_ROOT_DIR
}
"
)
ExternalProject_Add
(
cpprestsdk
DEPENDS cppmicroservices
...
...
python/pybind11/CMakeLists.txt
deleted
100644 → 0
View file @
7a944307
# CMakeLists.txt -- Build system for the pybind11 modules
#
# Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
#
# All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.
cmake_minimum_required
(
VERSION 2.8.12
)
if
(
POLICY CMP0048
)
# cmake warns if loaded from a min-3.0-required parent dir, so silence the warning:
cmake_policy
(
SET CMP0048 NEW
)
endif
()
# CMake versions < 3.4.0 do not support try_compile/pthread checks without C as active language.
if
(
CMAKE_VERSION VERSION_LESS 3.4.0
)
project
(
pybind11
)
else
()
project
(
pybind11 CXX
)
endif
()
# Check if pybind11 is being used directly or via add_subdirectory
set
(
PYBIND11_MASTER_PROJECT OFF
)
if
(
CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR
)
set
(
PYBIND11_MASTER_PROJECT ON
)
endif
()
option
(
PYBIND11_INSTALL
"Install pybind11 header files?"
${
PYBIND11_MASTER_PROJECT
}
)
option
(
PYBIND11_TEST
"Build pybind11 test suite?"
${
PYBIND11_MASTER_PROJECT
}
)
list
(
APPEND CMAKE_MODULE_PATH
"
${
CMAKE_CURRENT_LIST_DIR
}
/tools"
)
include
(
pybind11Tools
)
# Cache variables so pybind11_add_module can be used in parent projects
set
(
PYBIND11_INCLUDE_DIR
"
${
CMAKE_CURRENT_LIST_DIR
}
/include"
CACHE INTERNAL
""
)
set
(
PYTHON_INCLUDE_DIRS
${
PYTHON_INCLUDE_DIRS
}
CACHE INTERNAL
""
)
set
(
PYTHON_LIBRARIES
${
PYTHON_LIBRARIES
}
CACHE INTERNAL
""
)
set
(
PYTHON_MODULE_PREFIX
${
PYTHON_MODULE_PREFIX
}
CACHE INTERNAL
""
)
set
(
PYTHON_MODULE_EXTENSION
${
PYTHON_MODULE_EXTENSION
}
CACHE INTERNAL
""
)
# NB: when adding a header don't forget to also add it to setup.py
set
(
PYBIND11_HEADERS
include/pybind11/detail/class.h
include/pybind11/detail/common.h
include/pybind11/detail/descr.h
include/pybind11/detail/init.h
include/pybind11/detail/internals.h
include/pybind11/detail/typeid.h
include/pybind11/attr.h
include/pybind11/buffer_info.h
include/pybind11/cast.h
include/pybind11/chrono.h
include/pybind11/common.h
include/pybind11/complex.h
include/pybind11/options.h
include/pybind11/eigen.h
include/pybind11/embed.h
include/pybind11/eval.h
include/pybind11/functional.h
include/pybind11/numpy.h
include/pybind11/operators.h
include/pybind11/pybind11.h
include/pybind11/pytypes.h
include/pybind11/stl.h
include/pybind11/stl_bind.h
)
string
(
REPLACE
"include/"
"
${
CMAKE_CURRENT_SOURCE_DIR
}
/include/"
PYBIND11_HEADERS
"
${
PYBIND11_HEADERS
}
"
)
if
(
PYBIND11_TEST
)
add_subdirectory
(
tests
)
endif
()
include
(
GNUInstallDirs
)
include
(
CMakePackageConfigHelpers
)
# extract project version from source
file
(
STRINGS
"
${
PYBIND11_INCLUDE_DIR
}
/pybind11/detail/common.h"
pybind11_version_defines
REGEX
"#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) "
)
foreach
(
ver
${
pybind11_version_defines
}
)
if
(
ver MATCHES
"#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) +([^ ]+)$"
)
set
(
PYBIND11_VERSION_
${
CMAKE_MATCH_1
}
"
${
CMAKE_MATCH_2
}
"
CACHE INTERNAL
""
)
endif
()
endforeach
()
set
(
${
PROJECT_NAME
}
_VERSION
${
PYBIND11_VERSION_MAJOR
}
.
${
PYBIND11_VERSION_MINOR
}
.
${
PYBIND11_VERSION_PATCH
}
)
message
(
STATUS
"pybind11 v
${${
PROJECT_NAME
}
_VERSION
}
"
)
option
(
USE_PYTHON_INCLUDE_DIR
"Install pybind11 headers in Python include directory instead of default installation prefix"
OFF
)
if
(
USE_PYTHON_INCLUDE_DIR
)
file
(
RELATIVE_PATH CMAKE_INSTALL_INCLUDEDIR
${
CMAKE_INSTALL_PREFIX
}
${
PYTHON_INCLUDE_DIRS
}
)
endif
()
if
(
NOT
(
CMAKE_VERSION VERSION_LESS 3.0
))
# CMake >= 3.0
# Build an interface library target:
add_library
(
pybind11 INTERFACE
)
add_library
(
pybind11::pybind11 ALIAS pybind11
)
# to match exported target
target_include_directories
(
pybind11 INTERFACE $<BUILD_INTERFACE:
${
PYBIND11_INCLUDE_DIR
}
>
$<BUILD_INTERFACE:
${
PYTHON_INCLUDE_DIRS
}
>
$<INSTALL_INTERFACE:
${
CMAKE_INSTALL_INCLUDEDIR
}
>
)
target_compile_options
(
pybind11 INTERFACE $<BUILD_INTERFACE:
${
PYBIND11_CPP_STANDARD
}
>
)
add_library
(
module INTERFACE
)
add_library
(
pybind11::module ALIAS module
)
if
(
NOT MSVC
)
target_compile_options
(
module INTERFACE -fvisibility=hidden
)
endif
()
target_link_libraries
(
module INTERFACE pybind11::pybind11
)
if
(
WIN32 OR CYGWIN
)
target_link_libraries
(
module INTERFACE $<BUILD_INTERFACE:
${
PYTHON_LIBRARIES
}
>
)
elseif
(
APPLE
)
target_link_libraries
(
module INTERFACE
"-undefined dynamic_lookup"
)
endif
()
add_library
(
embed INTERFACE
)
add_library
(
pybind11::embed ALIAS embed
)
target_link_libraries
(
embed INTERFACE pybind11::pybind11 $<BUILD_INTERFACE:
${
PYTHON_LIBRARIES
}
>
)
endif
()
if
(
PYBIND11_INSTALL
)
install
(
DIRECTORY
${
PYBIND11_INCLUDE_DIR
}
/pybind11 DESTINATION
${
CMAKE_INSTALL_INCLUDEDIR
}
)
# GNUInstallDirs "DATADIR" wrong here; CMake search path wants "share".
set
(
PYBIND11_CMAKECONFIG_INSTALL_DIR
"share/cmake/
${
PROJECT_NAME
}
"
CACHE STRING
"install path for pybind11Config.cmake"
)
configure_package_config_file
(
tools/
${
PROJECT_NAME
}
Config.cmake.in
"
${
CMAKE_CURRENT_BINARY_DIR
}
/
${
PROJECT_NAME
}
Config.cmake"
INSTALL_DESTINATION
${
PYBIND11_CMAKECONFIG_INSTALL_DIR
}
)
# Remove CMAKE_SIZEOF_VOID_P from ConfigVersion.cmake since the library does
# not depend on architecture specific settings or libraries.
set
(
_PYBIND11_CMAKE_SIZEOF_VOID_P
${
CMAKE_SIZEOF_VOID_P
}
)
unset
(
CMAKE_SIZEOF_VOID_P
)
write_basic_package_version_file
(
${
CMAKE_CURRENT_BINARY_DIR
}
/
${
PROJECT_NAME
}
ConfigVersion.cmake
VERSION
${${
PROJECT_NAME
}
_VERSION
}
COMPATIBILITY AnyNewerVersion
)
set
(
CMAKE_SIZEOF_VOID_P
${
_PYBIND11_CMAKE_SIZEOF_VOID_P
}
)
install
(
FILES
${
CMAKE_CURRENT_BINARY_DIR
}
/
${
PROJECT_NAME
}
Config.cmake
${
CMAKE_CURRENT_BINARY_DIR
}
/
${
PROJECT_NAME
}
ConfigVersion.cmake
tools/FindPythonLibsNew.cmake
tools/pybind11Tools.cmake
DESTINATION
${
PYBIND11_CMAKECONFIG_INSTALL_DIR
}
)
if
(
NOT
(
CMAKE_VERSION VERSION_LESS 3.0
))
if
(
NOT PYBIND11_EXPORT_NAME
)
set
(
PYBIND11_EXPORT_NAME
"
${
PROJECT_NAME
}
Targets"
)
endif
()
install
(
TARGETS pybind11 module embed
EXPORT
"
${
PYBIND11_EXPORT_NAME
}
"
)
if
(
PYBIND11_MASTER_PROJECT
)
install
(
EXPORT
"
${
PYBIND11_EXPORT_NAME
}
"
NAMESPACE
"
${
PROJECT_NAME
}
::"
DESTINATION
${
PYBIND11_CMAKECONFIG_INSTALL_DIR
}
)
endif
()
endif
()
endif
()
python/pybind11/include/pybind11/attr.h
deleted
100644 → 0
View file @
7a944307
/*
pybind11/attr.h: Infrastructure for processing custom
type and function attributes
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
All rights reserved. Use of this source code is governed by a
BSD-style license that can be found in the LICENSE file.
*/
#pragma once
#include
"cast.h"
NAMESPACE_BEGIN
(
PYBIND11_NAMESPACE
)
/// \addtogroup annotations
/// @{
/// Annotation for methods
struct
is_method
{
handle
class_
;
is_method
(
const
handle
&
c
)
:
class_
(
c
)
{
}
};
/// Annotation for operators
struct
is_operator
{
};
/// Annotation for parent scope
struct
scope
{
handle
value
;
scope
(
const
handle
&
s
)
:
value
(
s
)
{
}
};
/// Annotation for documentation
struct
doc
{
const
char
*
value
;
doc
(
const
char
*
value
)
:
value
(
value
)
{
}
};
/// Annotation for function names
struct
name
{
const
char
*
value
;
name
(
const
char
*
value
)
:
value
(
value
)
{
}
};
/// Annotation indicating that a function is an overload associated with a given "sibling"
struct
sibling
{
handle
value
;
sibling
(
const
handle
&
value
)
:
value
(
value
.
ptr
())
{
}
};
/// Annotation indicating that a class derives from another given type
template
<
typename
T
>
struct
base
{
PYBIND11_DEPRECATED
(
"base<T>() was deprecated in favor of specifying 'T' as a template argument to class_"
)
base
()
{
}
};
/// Keep patient alive while nurse lives
template
<
size_t
Nurse
,
size_t
Patient
>
struct
keep_alive
{
};
/// Annotation indicating that a class is involved in a multiple inheritance relationship
struct
multiple_inheritance
{
};
/// Annotation which enables dynamic attributes, i.e. adds `__dict__` to a class
struct
dynamic_attr
{
};
/// Annotation which enables the buffer protocol for a type
struct
buffer_protocol
{
};
/// Annotation which requests that a special metaclass is created for a type
struct
metaclass
{
handle
value
;
PYBIND11_DEPRECATED
(
"py::metaclass() is no longer required. It's turned on by default now."
)
metaclass
()
{}
/// Override pybind11's default metaclass
explicit
metaclass
(
handle
value
)
:
value
(
value
)
{
}
};
/// Annotation that marks a class as local to the module:
struct
module_local
{
const
bool
value
;
constexpr
module_local
(
bool
v
=
true
)
:
value
(
v
)
{
}
};
/// Annotation to mark enums as an arithmetic type
struct
arithmetic
{
};
/** \rst
A call policy which places one or more guard variables (``Ts...``) around the function call.
For example, this definition:
.. code-block:: cpp
m.def("foo", foo, py::call_guard<T>());
is equivalent to the following pseudocode:
.. code-block:: cpp
m.def("foo", [](args...) {
T scope_guard;
return foo(args...); // forwarded arguments
});
\endrst */
template
<
typename
...
Ts
>
struct
call_guard
;
template
<
>
struct
call_guard
<>
{
using
type
=
detail
::
void_type
;
};
template
<
typename
T
>
struct
call_guard
<
T
>
{
static_assert
(
std
::
is_default_constructible
<
T
>::
value
,
"The guard type must be default constructible"
);
using
type
=
T
;
};
template
<
typename
T
,
typename
...
Ts
>
struct
call_guard
<
T
,
Ts
...
>
{
struct
type
{
T
guard
{};
// Compose multiple guard types with left-to-right default-constructor order
typename
call_guard
<
Ts
...
>::
type
next
{};
};
};
/// @} annotations
NAMESPACE_BEGIN
(
detail
)
/* Forward declarations */
enum
op_id
:
int
;
enum
op_type
:
int
;
struct
undefined_t
;
template
<
op_id
id
,
op_type
ot
,
typename
L
=
undefined_t
,
typename
R
=
undefined_t
>
struct
op_
;
inline
void
keep_alive_impl
(
size_t
Nurse
,
size_t
Patient
,
function_call
&
call
,
handle
ret
);
/// Internal data structure which holds metadata about a keyword argument
struct
argument_record
{
const
char
*
name
;
///< Argument name
const
char
*
descr
;
///< Human-readable version of the argument value
handle
value
;
///< Associated Python object
bool
convert
:
1
;
///< True if the argument is allowed to convert when loading
bool
none
:
1
;
///< True if None is allowed when loading
argument_record
(
const
char
*
name
,
const
char
*
descr
,
handle
value
,
bool
convert
,
bool
none
)
:
name
(
name
),
descr
(
descr
),
value
(
value
),
convert
(
convert
),
none
(
none
)
{
}
};
/// Internal data structure which holds metadata about a bound function (signature, overloads, etc.)
struct
function_record
{
function_record
()
:
is_constructor
(
false
),
is_new_style_constructor
(
false
),
is_stateless
(
false
),
is_operator
(
false
),
has_args
(
false
),
has_kwargs
(
false
),
is_method
(
false
)
{
}
/// Function name
char
*
name
=
nullptr
;
/* why no C++ strings? They generate heavier code.. */
// User-specified documentation string
char
*
doc
=
nullptr
;
/// Human-readable version of the function signature
char
*
signature
=
nullptr
;
/// List of registered keyword arguments
std
::
vector
<
argument_record
>
args
;
/// Pointer to lambda function which converts arguments and performs the actual call
handle
(
*
impl
)
(
function_call
&
)
=
nullptr
;
/// Storage for the wrapped function pointer and captured data, if any
void
*
data
[
3
]
=
{
};
/// Pointer to custom destructor for 'data' (if needed)
void
(
*
free_data
)
(
function_record
*
ptr
)
=
nullptr
;
/// Return value policy associated with this function
return_value_policy
policy
=
return_value_policy
::
automatic
;
/// True if name == '__init__'
bool
is_constructor
:
1
;
/// True if this is a new-style `__init__` defined in `detail/init.h`
bool
is_new_style_constructor
:
1
;
/// True if this is a stateless function pointer
bool
is_stateless
:
1
;
/// True if this is an operator (__add__), etc.
bool
is_operator
:
1
;
/// True if the function has a '*args' argument
bool
has_args
:
1
;
/// True if the function has a '**kwargs' argument
bool
has_kwargs
:
1
;
/// True if this is a method
bool
is_method
:
1
;
/// Number of arguments (including py::args and/or py::kwargs, if present)
std
::
uint16_t
nargs
;
/// Python method object
PyMethodDef
*
def
=
nullptr
;
/// Python handle to the parent scope (a class or a module)
handle
scope
;
/// Python handle to the sibling function representing an overload chain
handle
sibling
;
/// Pointer to next overload
function_record
*
next
=
nullptr
;
};
/// Special data structure which (temporarily) holds metadata about a bound class
struct
type_record
{
PYBIND11_NOINLINE
type_record
()
:
multiple_inheritance
(
false
),
dynamic_attr
(
false
),
buffer_protocol
(
false
),
module_local
(
false
)
{
}
/// Handle to the parent scope
handle
scope
;
/// Name of the class
const
char
*
name
=
nullptr
;
// Pointer to RTTI type_info data structure
const
std
::
type_info
*
type
=
nullptr
;
/// How large is the underlying C++ type?
size_t
type_size
=
0
;
/// How large is the type's holder?
size_t
holder_size
=
0
;
/// The global operator new can be overridden with a class-specific variant
void
*
(
*
operator_new
)(
size_t
)
=
::
operator
new
;
/// Function pointer to class_<..>::init_instance
void
(
*
init_instance
)(
instance
*
,
const
void
*
)
=
nullptr
;
/// Function pointer to class_<..>::dealloc
void
(
*
dealloc
)(
detail
::
value_and_holder
&
)
=
nullptr
;
/// List of base classes of the newly created type
list
bases
;
/// Optional docstring
const
char
*
doc
=
nullptr
;
/// Custom metaclass (optional)
handle
metaclass
;
/// Multiple inheritance marker
bool
multiple_inheritance
:
1
;
/// Does the class manage a __dict__?
bool
dynamic_attr
:
1
;
/// Does the class implement the buffer protocol?
bool
buffer_protocol
:
1
;
/// Is the default (unique_ptr) holder type used?
bool
default_holder
:
1
;
/// Is the class definition local to the module shared object?
bool
module_local
:
1
;
PYBIND11_NOINLINE
void
add_base
(
const
std
::
type_info
&
base
,
void
*
(
*
caster
)(
void
*
))
{
auto
base_info
=
detail
::
get_type_info
(
base
,
false
);
if
(
!
base_info
)
{
std
::
string
tname
(
base
.
name
());
detail
::
clean_type_id
(
tname
);
pybind11_fail
(
"generic_type: type
\"
"
+
std
::
string
(
name
)
+
"
\"
referenced unknown base type
\"
"
+
tname
+
"
\"
"
);
}
if
(
default_holder
!=
base_info
->
default_holder
)
{
std
::
string
tname
(
base
.
name
());
detail
::
clean_type_id
(
tname
);
pybind11_fail
(
"generic_type: type
\"
"
+
std
::
string
(
name
)
+
"
\"
"
+
(
default_holder
?
"does not have"
:
"has"
)
+
" a non-default holder type while its base
\"
"
+
tname
+
"
\"
"
+
(
base_info
->
default_holder
?
"does not"
:
"does"
));
}
bases
.
append
((
PyObject
*
)
base_info
->
type
);
if
(
base_info
->
type
->
tp_dictoffset
!=
0
)
dynamic_attr
=
true
;
if
(
caster
)
base_info
->
implicit_casts
.
emplace_back
(
type
,
caster
);
}
};
inline
function_call
::
function_call
(
function_record
&
f
,
handle
p
)
:
func
(
f
),
parent
(
p
)
{
args
.
reserve
(
f
.
nargs
);
args_convert
.
reserve
(
f
.
nargs
);
}
/// Tag for a new-style `__init__` defined in `detail/init.h`
struct
is_new_style_constructor
{
};
/**
* Partial template specializations to process custom attributes provided to
* cpp_function_ and class_. These are either used to initialize the respective
* fields in the type_record and function_record data structures or executed at
* runtime to deal with custom call policies (e.g. keep_alive).
*/
template
<
typename
T
,
typename
SFINAE
=
void
>
struct
process_attribute
;
template
<
typename
T
>
struct
process_attribute_default
{
/// Default implementation: do nothing
static
void
init
(
const
T
&
,
function_record
*
)
{
}
static
void
init
(
const
T
&
,
type_record
*
)
{
}
static
void
precall
(
function_call
&
)
{
}
static
void
postcall
(
function_call
&
,
handle
)
{
}
};
/// Process an attribute specifying the function's name
template
<
>
struct
process_attribute
<
name
>
:
process_attribute_default
<
name
>
{
static
void
init
(
const
name
&
n
,
function_record
*
r
)
{
r
->
name
=
const_cast
<
char
*>
(
n
.
value
);
}
};
/// Process an attribute specifying the function's docstring
template
<
>
struct
process_attribute
<
doc
>
:
process_attribute_default
<
doc
>
{
static
void
init
(
const
doc
&
n
,
function_record
*
r
)
{
r
->
doc
=
const_cast
<
char
*>
(
n
.
value
);
}
};
/// Process an attribute specifying the function's docstring (provided as a C-style string)
template
<
>
struct
process_attribute
<
const
char
*>
:
process_attribute_default
<
const
char
*>
{
static
void
init
(
const
char
*
d
,
function_record
*
r
)
{
r
->
doc
=
const_cast
<
char
*>
(
d
);
}
static
void
init
(
const
char
*
d
,
type_record
*
r
)
{
r
->
doc
=
const_cast
<
char
*>
(
d
);
}
};
template
<
>
struct
process_attribute
<
char
*>
:
process_attribute
<
const
char
*>
{
};
/// Process an attribute indicating the function's return value policy
template
<
>
struct
process_attribute
<
return_value_policy
>
:
process_attribute_default
<
return_value_policy
>
{
static
void
init
(
const
return_value_policy
&
p
,
function_record
*
r
)
{
r
->
policy
=
p
;
}
};
/// Process an attribute which indicates that this is an overloaded function associated with a given sibling
template
<
>
struct
process_attribute
<
sibling
>
:
process_attribute_default
<
sibling
>
{
static
void
init
(
const
sibling
&
s
,
function_record
*
r
)
{
r
->
sibling
=
s
.
value
;
}
};
/// Process an attribute which indicates that this function is a method
template
<
>
struct
process_attribute
<
is_method
>
:
process_attribute_default
<
is_method
>
{
static
void
init
(
const
is_method
&
s
,
function_record
*
r
)
{
r
->
is_method
=
true
;
r
->
scope
=
s
.
class_
;
}
};
/// Process an attribute which indicates the parent scope of a method
template
<
>
struct
process_attribute
<
scope
>
:
process_attribute_default
<
scope
>
{
static
void
init
(
const
scope
&
s
,
function_record
*
r
)
{
r
->
scope
=
s
.
value
;
}
};
/// Process an attribute which indicates that this function is an operator
template
<
>
struct
process_attribute
<
is_operator
>
:
process_attribute_default
<
is_operator
>
{
static
void
init
(
const
is_operator
&
,
function_record
*
r
)
{
r
->
is_operator
=
true
;
}
};
template
<
>
struct
process_attribute
<
is_new_style_constructor
>
:
process_attribute_default
<
is_new_style_constructor
>
{
static
void
init
(
const
is_new_style_constructor
&
,
function_record
*
r
)
{
r
->
is_new_style_constructor
=
true
;
}
};
/// Process a keyword argument attribute (*without* a default value)
template
<
>
struct
process_attribute
<
arg
>
:
process_attribute_default
<
arg
>
{
static
void
init
(
const
arg
&
a
,
function_record
*
r
)
{
if
(
r
->
is_method
&&
r
->
args
.
empty
())
r
->
args
.
emplace_back
(
"self"
,
nullptr
,
handle
(),
true
/*convert*/
,
false
/*none not allowed*/
);
r
->
args
.
emplace_back
(
a
.
name
,
nullptr
,
handle
(),
!
a
.
flag_noconvert
,
a
.
flag_none
);
}
};
/// Process a keyword argument attribute (*with* a default value)
template
<
>
struct
process_attribute
<
arg_v
>
:
process_attribute_default
<
arg_v
>
{
static
void
init
(
const
arg_v
&
a
,
function_record
*
r
)
{
if
(
r
->
is_method
&&
r
->
args
.
empty
())
r
->
args
.
emplace_back
(
"self"
,
nullptr
/*descr*/
,
handle
()
/*parent*/
,
true
/*convert*/
,
false
/*none not allowed*/
);
if
(
!
a
.
value
)
{
#if !defined(NDEBUG)
std
::
string
descr
(
"'"
);
if
(
a
.
name
)
descr
+=
std
::
string
(
a
.
name
)
+
": "
;
descr
+=
a
.
type
+
"'"
;
if
(
r
->
is_method
)
{
if
(
r
->
name
)
descr
+=
" in method '"
+
(
std
::
string
)
str
(
r
->
scope
)
+
"."
+
(
std
::
string
)
r
->
name
+
"'"
;
else
descr
+=
" in method of '"
+
(
std
::
string
)
str
(
r
->
scope
)
+
"'"
;
}
else
if
(
r
->
name
)
{
descr
+=
" in function '"
+
(
std
::
string
)
r
->
name
+
"'"
;
}
pybind11_fail
(
"arg(): could not convert default argument "
+
descr
+
" into a Python object (type not registered yet?)"
);
#else
pybind11_fail
(
"arg(): could not convert default argument "
"into a Python object (type not registered yet?). "
"Compile in debug mode for more information."
);
#endif
}
r
->
args
.
emplace_back
(
a
.
name
,
a
.
descr
,
a
.
value
.
inc_ref
(),
!
a
.
flag_noconvert
,
a
.
flag_none
);
}
};
/// Process a parent class attribute. Single inheritance only (class_ itself already guarantees that)
template
<
typename
T
>
struct
process_attribute
<
T
,
enable_if_t
<
is_pyobject
<
T
>::
value
>>
:
process_attribute_default
<
handle
>
{
static
void
init
(
const
handle
&
h
,
type_record
*
r
)
{
r
->
bases
.
append
(
h
);
}
};
/// Process a parent class attribute (deprecated, does not support multiple inheritance)
template
<
typename
T
>
struct
process_attribute
<
base
<
T
>>
:
process_attribute_default
<
base
<
T
>>
{
static
void
init
(
const
base
<
T
>
&
,
type_record
*
r
)
{
r
->
add_base
(
typeid
(
T
),
nullptr
);
}
};
/// Process a multiple inheritance attribute
template
<
>
struct
process_attribute
<
multiple_inheritance
>
:
process_attribute_default
<
multiple_inheritance
>
{
static
void
init
(
const
multiple_inheritance
&
,
type_record
*
r
)
{
r
->
multiple_inheritance
=
true
;
}
};
template
<
>
struct
process_attribute
<
dynamic_attr
>
:
process_attribute_default
<
dynamic_attr
>
{
static
void
init
(
const
dynamic_attr
&
,
type_record
*
r
)
{
r
->
dynamic_attr
=
true
;
}
};
template
<
>
struct
process_attribute
<
buffer_protocol
>
:
process_attribute_default
<
buffer_protocol
>
{
static
void
init
(
const
buffer_protocol
&
,
type_record
*
r
)
{
r
->
buffer_protocol
=
true
;
}
};