pax_global_header 0000666 0000000 0000000 00000000064 14703210004 0014501 g ustar 00root root 0000000 0000000 52 comment=f6355e7a3adcacf157a89f3a667b019e73f05f7c
python-gphoto2-2.5.1/ 0000775 0000000 0000000 00000000000 14703210004 0014407 5 ustar 00root root 0000000 0000000 python-gphoto2-2.5.1/.github/ 0000775 0000000 0000000 00000000000 14703210004 0015747 5 ustar 00root root 0000000 0000000 python-gphoto2-2.5.1/.github/ISSUE_TEMPLATE/ 0000775 0000000 0000000 00000000000 14703210004 0020132 5 ustar 00root root 0000000 0000000 python-gphoto2-2.5.1/.github/ISSUE_TEMPLATE/bug_report.md 0000664 0000000 0000000 00000001166 14703210004 0022630 0 ustar 00root root 0000000 0000000 ---
name: Bug report
about: Help the developers fix problems in python-gphoto2.
title: ''
labels: ''
assignees: ''
---
This page is for reporting problems with the Python interface to libgphoto2. If your question is about using libgphoto2 you should ask on the [gphoto2 mailing list](http://gphoto.org/mailinglists/).
**Your system**
What version of Python are you using?
What version of libgphoto2 have you installed?
How have you installed (or attempted to install) python-gphoto2?
**Your problem**
Please describe what you are trying to do and what goes wrong. A short Python script that shows the problem may be useful.
python-gphoto2-2.5.1/.github/workflows/ 0000775 0000000 0000000 00000000000 14703210004 0020004 5 ustar 00root root 0000000 0000000 python-gphoto2-2.5.1/.github/workflows/build-linux.yml 0000664 0000000 0000000 00000002721 14703210004 0022765 0 ustar 00root root 0000000 0000000 name: build gphoto2 linux x86_64
on: workflow_dispatch
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Check out repository code
uses: actions/checkout@v4
- name: Download libgphoto2
run: wget -nv
https://github.com/gphoto/libgphoto2/releases/download/v2.5.31/libgphoto2-2.5.31.tar.xz
-O libgphoto2.tar.xz
- name: Extract libgphoto2
run: |
mkdir $PWD/libgphoto2
tar xf libgphoto2.tar.xz \
--directory $PWD/libgphoto2 --strip-components=1
- name: Build wheels
uses: pypa/cibuildwheel@v2.21.3
env:
CIBW_ARCHS: auto64
CIBW_MANYLINUX_X86_64_IMAGE: manylinux_2_28
CIBW_BUILD: cp*-manylinux_x86_64
CIBW_ENVIRONMENT: GPHOTO2_ROOT=$PWD/libgphoto2/local_install
CIBW_TEST_COMMAND: >
python3 -m gphoto2 -v &&
python3 -m unittest discover {project}/tests -v
CIBW_BEFORE_ALL: >
yum install -y libusbx-devel libexif-devel libjpeg-turbo-devel
gd-devel libcurl-devel libxml2-devel libtool-ltdl-devel &&
pushd $PWD/libgphoto2 &&
./configure --prefix=$PWD/local_install --disable-internal-docs
--enable-vusb &&
make &&
make install &&
popd
- name: Store results
uses: actions/upload-artifact@v4
with:
name: linux-x86_64-wheels
path: wheelhouse/*.whl
python-gphoto2-2.5.1/.github/workflows/build-macos-arm.yml 0000664 0000000 0000000 00000002720 14703210004 0023504 0 ustar 00root root 0000000 0000000 name: build gphoto2 macOS arm64
on: workflow_dispatch
jobs:
build:
runs-on: macos-latest
steps:
- name: Check out repository code
uses: actions/checkout@v4
- name: Download libgphoto2
run: wget -nv
https://github.com/gphoto/libgphoto2/releases/download/v2.5.31/libgphoto2-2.5.31.tar.xz
-O libgphoto2.tar.xz
- name: Extract libgphoto2
run: |
mkdir $PWD/libgphoto2
tar xf libgphoto2.tar.xz \
--directory $PWD/libgphoto2 --strip-components=1
- name: Build wheels
uses: pypa/cibuildwheel@v2.21.3
env:
CIBW_ARCHS: arm64
CIBW_SKIP: pp3*
CIBW_ENVIRONMENT: >
GPHOTO2_ROOT=$PWD/libgphoto2/local_install
MACOSX_DEPLOYMENT_TARGET="14.0"
SYSTEM_VERSION_COMPAT=0
CIBW_TEST_COMMAND: >
python3 -m gphoto2 -v &&
python3 -m unittest discover {project}/tests -v
CIBW_BEFORE_ALL: >
brew install libexif libtool gd &&
pushd $PWD/libgphoto2 &&
./configure --prefix=$PWD/local_install --disable-internal-docs \
--enable-vusb \
CFLAGS="-D_DARWIN_C_SOURCE -I$(brew --prefix)/include" &&
make &&
make install &&
popd
- name: Store results
uses: actions/upload-artifact@v4
with:
name: macos-arm64-wheels
path: wheelhouse/*.whl
python-gphoto2-2.5.1/.github/workflows/build-macos.yml 0000664 0000000 0000000 00000002704 14703210004 0022731 0 ustar 00root root 0000000 0000000 name: build gphoto2 macOS x86_64
on: workflow_dispatch
jobs:
build:
runs-on: macos-13
steps:
- name: Check out repository code
uses: actions/checkout@v4
- name: Download libgphoto2
run: wget -nv
https://github.com/gphoto/libgphoto2/releases/download/v2.5.31/libgphoto2-2.5.31.tar.xz
-O libgphoto2.tar.xz
- name: Extract libgphoto2
run: |
mkdir $PWD/libgphoto2
tar xf libgphoto2.tar.xz \
--directory $PWD/libgphoto2 --strip-components=1
- name: Build wheels
uses: pypa/cibuildwheel@v2.21.3
env:
CIBW_ARCHS: x86_64
CIBW_SKIP: pp3*
CIBW_ENVIRONMENT: >
GPHOTO2_ROOT=$PWD/libgphoto2/local_install
MACOSX_DEPLOYMENT_TARGET="13.0"
SYSTEM_VERSION_COMPAT=0
CIBW_TEST_COMMAND: >
python3 -m gphoto2 -v &&
python3 -m unittest discover {project}/tests -v
CIBW_BEFORE_ALL: >
brew install libexif &&
pushd $PWD/libgphoto2 &&
./configure --prefix=$PWD/local_install --disable-internal-docs \
--enable-vusb \
CFLAGS="-D_DARWIN_C_SOURCE -I$(brew --prefix)/include" &&
make &&
make install &&
popd
- name: Store results
uses: actions/upload-artifact@v4
with:
name: macos-x86_64-wheels
path: wheelhouse/*.whl
python-gphoto2-2.5.1/.github/workflows/lint_python.yml 0000664 0000000 0000000 00000002100 14703210004 0023067 0 ustar 00root root 0000000 0000000 name: lint_python
on: [pull_request, push]
jobs:
lint_python:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: actions/setup-python@v2
- run: sudo apt-get install -y libgirepository1.0-dev libgphoto2-dev swig
- run: pip install bandit black codespell flake8 isort mypy pytest pyupgrade safety
- run: bandit -r . || true
- run: black --check . || true
- run: codespell --quiet-level=2
- run: flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
- run: isort --check-only --profile black . || true
- run: shopt -s globstar && pyupgrade --py36-plus **/*.py || true
- run: pip install -r requirements.txt || true
- run: mypy --ignore-missing-imports . || true
- run: python developer/build_swig.py
- run: python setup.py build
- run: rm -rf build
- run: CC=clang python setup.py build
- run: pip install exifread Pillow PyGObject PyQt5 tzlocal
- run: pytest . || true
- run: pytest --doctest-modules . || true
# - run: safety check
python-gphoto2-2.5.1/.gitignore 0000664 0000000 0000000 00000000130 14703210004 0016371 0 ustar 00root root 0000000 0000000 build
dist
doxy2swig
src/gphoto2/common/doc.i
tests/__pycache__/
gphoto2.egg-info
*.whl
python-gphoto2-2.5.1/.travis.yml 0000664 0000000 0000000 00000000655 14703210004 0016526 0 ustar 00root root 0000000 0000000 language: python
python:
- "2.7"
- "3.6"
before_install:
- sudo apt-get install -y swig libgphoto2-dev
script:
- python setup.py build_swig
- PYTHON_GPHOTO2_BUILTIN=1 python setup.py build
- rm -rf build
- PYTHON_GPHOTO2_NO_BUILTIN=1 python setup.py build
- rm -rf build
- PYTHON_GPHOTO2_BUILTIN=1 CC=clang python setup.py build
- rm -rf build
- PYTHON_GPHOTO2_NO_BUILTIN=1 CC=clang python setup.py build
python-gphoto2-2.5.1/CHANGELOG.txt 0000664 0000000 0000000 00000025247 14703210004 0016451 0 ustar 00root root 0000000 0000000 python-gphoto2 - Python interface to libgphoto2
http://github.com/jim-easterbrook/python-gphoto2
Copyright (C) 2014-24 Jim Easterbrook jim@jim-easterbrook.me.uk
This file is part of python-gphoto2.
python-gphoto2 is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
python-gphoto2 is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with python-gphoto2. If not, see
`_ for more details.
Raspberry Pi
^^^^^^^^^^^^
Binary wheels for the Raspberry Pi are available from piwheels_.
You need to install some system packages to use these::
$ sudo apt install libexif12 libgphoto2-6 libgphoto2-port12 libltdl7
$ pip3 install gphoto2 --user --only-binary :all:
Using python-gphoto2
--------------------
The Python interface to libgphoto2_ should allow you to do anything you could do in a C program.
However, there are still bits missing and functions that cannot be called from Python.
Let me know if you run into any problems.
The following paragraphs show how the Python interfaces differ from C.
See the example programs for typical usage of the Python gphoto2 API.
"C" interface
^^^^^^^^^^^^^
These functions are as similar as possible to their libgphoto2_ equivalents.
Most of them return an error code which you must check.
Using SWIG_ to generate the Python interfaces automatically means that every function in libgphoto2_ *should* be available to Python.
You can show the documentation of a function with the ``pydoc`` command (or ``python -m pydoc`` if you installed gphoto2 with pip inside a virtual environment)::
$ pydoc3 gphoto2.gp_camera_folder_list_files
Help on built-in function gp_camera_folder_list_files in gphoto2:
gphoto2.gp_camera_folder_list_files = gp_camera_folder_list_files(...)
gp_camera_folder_list_files(camera, folder, context) -> int
Parameters
----------
camera: gphoto2.Camera
folder: str
context: gphoto2.Context (default=None)
Lists the files in supplied `folder`.
Parameters
----------
* `camera` :
a Camera
* `folder` :
a folder
* `list` :
a CameraList
* `context` :
a GPContext
Returns
-------
a gphoto2 error code
See also gphoto2.Camera.folder_list_files
The first part of this text is the function signature and parameter list generated by SWIG.
(Note that ``context`` is optional - it's only needed if you need the callback functions that can be associated with a context.)
The rest of the text is copied from the "doxygen" format documentation in the C source code.
(The online `API documentation`_ shows how it is intended to look.)
Note that this includes a ``list`` parameter that is not in the function signature.
In C this is an "output" parameter, a concept that doesn't really exist in Python.
The Python version of ``gp_camera_folder_list_files`` returns a sequence containing the integer error code and the ``list`` value.
Most of the libgphoto2_ functions that use pointer parameters to return values in the C API have been adapted like this in the Python API.
(Unfortunately I've not found a way to persuade SWIG_ to include this extra return value in the documentation.
You should use ``pydoc`` to check the actual parameters expected by the Python function.)
For example, the C code:
.. code:: c
#include "gphoto2.h"
int error;
Camera *camera;
error = gp_camera_new(&camera);
...
error = gp_camera_unref(camera);
has this Python equivalent:
.. code:: python
import gphoto2 as gp
error, camera = gp.gp_camera_new()
...
Note that the gp_camera_unref() call is not needed.
It is called automatically when the Python camera object is deleted.
Here is a complete example program (without any error checking):
.. code:: python
import gphoto2 as gp
error, camera = gp.gp_camera_new()
error = gp.gp_camera_init(camera)
error, text = gp.gp_camera_get_summary(camera)
print('Summary')
print('=======')
print(text.text)
error = gp.gp_camera_exit(camera)
"Object oriented" interface
^^^^^^^^^^^^^^^^^^^^^^^^^^^
This is the preferred way to use libgphoto2_ from Python.
Most of the libgphoto2_ functions have been added as methods of the appropriate GPhoto2 object.
This allows GPhoto2 to be used in a more "Pythonic" style.
For example, ``gp.gp_camera_init(camera)`` can be replaced by ``camera.init()``.
These methods also include error checking.
If an error occurs they raise a Python ``GPhoto2Error`` exception.
The example program can be re-written as follows:
.. code:: python
import gphoto2 as gp
camera = gp.Camera()
camera.init()
text = camera.get_summary()
print('Summary')
print('=======')
print(str(text))
camera.exit()
No additional error checking is required.
Error checking
^^^^^^^^^^^^^^
Most of the libgphoto2_ functions return an integer to indicate success or failure.
The Python interface includes a ``check_result()`` function to check these values and raise a ``GPhoto2Error`` exception if an error occurs.
This function also removes the error code from lists such as that returned by ``gp_camera_new()`` in the example.
Using this function the earlier example becomes:
.. code:: python
import gphoto2 as gp
camera = gp.check_result(gp.gp_camera_new())
gp.check_result(gp.gp_camera_init(camera))
text = gp.check_result(gp.gp_camera_get_summary(camera))
print('Summary')
print('=======')
print(text.text)
gp.check_result(gp.gp_camera_exit(camera))
There may be some circumstances where you don't want an exception to be raised when some errors occur.
You can "fine tune" the behaviour of the ``check_result()`` function by adjusting the ``error_severity`` variable:
.. code:: python
import gphoto2 as gp
gp.error_severity[gp.GP_ERROR] = logging.WARNING
...
In this case a warning message will be logged (using Python's standard logging module) but no exception will be raised when a ``GP_ERROR`` error occurs.
However, this is a "blanket" approach that treats all ``GP_ERROR`` errors the same.
It is better to test for particular error conditions after particular operations, as described below.
The ``GPhoto2Error`` exception object has two attributes that may be useful in an exception handler.
``GPhoto2Error.code`` stores the integer error generated by the library function and ``GPhoto2Error.string`` stores the corresponding error message.
For example, to wait for a user to connect a camera you could do something like this:
.. code:: python
import gphoto2 as gp
...
print('Please connect and switch on your camera')
while True:
try:
camera.init()
except gp.GPhoto2Error as ex:
if ex.code == gp.GP_ERROR_MODEL_NOT_FOUND:
# no camera, try again in 2 seconds
time.sleep(2)
continue
# some other error we can't handle here
raise
# operation completed successfully so exit loop
break
# continue with rest of program
...
When just calling a single function like this, it's probably easier to test the error value directly instead of using Python exceptions:
.. code:: python
import gphoto2 as gp
...
print('Please connect and switch on your camera')
while True:
error = gp.gp_camera_init(camera)
if error >= gp.GP_OK:
# operation completed successfully so exit loop
break
if error != gp.GP_ERROR_MODEL_NOT_FOUND:
# some other error we can't handle here
raise gp.GPhoto2Error(error)
# no camera, try again in 2 seconds
time.sleep(2)
# continue with rest of program
...
Logging
^^^^^^^
The libgphoto2_ library includes functions (such as ``gp_log()``) to output messages from its various functions.
These messages are mostly used for debugging purposes, and it can be helpful to see them when using libgphoto2_ from Python.
The Python interface includes a ``use_python_logging()`` function to connect libgphoto2_ logging to the standard Python logging system.
If you want to see the messages you should call ``use_python_logging()`` near the start of your program, as shown in the examples.
In normal use you probably don't want to see these messages (libgphoto2_ is rather verbose) so this could be controlled by a "verbose" or "debug" option in your application.
The libgphoto2_ logging messages have four possible severity levels, each of which is mapped to a suitable Python logging severity.
You can override this mapping by passing your own to ``use_python_logging()``:
.. code:: python
import logging
import gphoto2 as gp
...
callback_obj = gp.check_result(gp.use_python_logging(mapping={
gp.GP_LOG_ERROR : logging.INFO,
gp.GP_LOG_DEBUG : logging.DEBUG,
gp.GP_LOG_VERBOSE : logging.DEBUG - 3,
gp.GP_LOG_DATA : logging.DEBUG - 6}))
...
If you prefer to use your own logging system you can define a logging callback function in Python.
The function must take 3 or 4 parameters: ``level``, ``domain``, ``string`` and an optional ``data``.
The ``data`` parameter allows you to pass some user data to your callback function (e.g. to log which thread an error occurred in):
The callback function is installed with ``gp_log_add_func``:
.. code:: python
import gphoto2 as gp
...
def callback(level, domain, string, data=None):
print('Callback: level =', level, ', domain =', domain, ', string =', string, 'data =', data)
...
callback_obj1 = gp.check_result(gp.gp_log_add_func(gp.GP_LOG_VERBOSE, callback))
callback_obj2 = gp.check_result(gp.gp_log_add_func(gp.GP_LOG_VERBOSE, callback, 123))
...
Deprecated functions
--------------------
Some functions are intended for use by camera drivers and should not have been included in the Python interface.
They will be removed in a future release.
During testing you should run your software with Python's ``-Wd`` flag to show the warnings issued if you use any of the deprecated functions.
Please contact me if you have reason to believe a deprecated function should not be removed.
What to do if you have a problem
--------------------------------
If you find a problem in the Python gphoto2 interface (e.g. a segfault, a missing function, or a function without a usable return value) then please report it on the GitHub "issues" page (https://github.com/jim-easterbrook/python-gphoto2/issues) or email jim@jim-easterbrook.me.uk.
If your problem is more general, e.g. difficulty with capturing multiple images, then try doing what you want to do with the `gphoto2 command line program`_.
If the problem persists then it might be worth asking on the `gphoto-user mailing list`_.
Another reader of the mailing list may have the same camera model and already know what to do.
Notes on some gphoto2 functions
-------------------------------
gp_camera_capture_preview / gp_camera_file_get
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Before python-gphoto2 version 2.5.0 these functions (and their corresponding "object oriented" methods) always allocated and returned a new ``CameraFile`` object.
Now you can pass in a previously allocated ``CameraFile`` for them to use.
In this case it is not returned by the function.
If you need to use a ``Context`` value with these functions without passing in a ``CameraFile``, then pass ``None`` in place of the ``CameraFile`` object.
gp_log_add_func / use_python_logging
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Since python-gphoto2 version 2.0.0 these functions return a sequence containing an error code and an object storing details of the callback.
The callback is automatically uninstalled when this object is deleted.
In earlier versions of python-gphoto2 these functions return an integer id that must be passed to ``gp_log_remove_func`` to uninstall the callback.
gp_context_set_idle_func / gp_context_set_progress_funcs / etc.
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
These functions are only usable since python-gphoto2 version 1.9.0.
They return a Python object which your program must store until the callback(s) are no longer required.
Deleting the returned object cancels the callback(s), so there is no need to do this yourself.
See the ``context_with_callbacks.py`` example for a convenient way to do this.
gp_file_get_data_and_size / CameraFile.get_data_and_size
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Since python-gphoto2 version 2.4.0 these functions return a Python memoryview_ object.
Prior to that they returned a ``FileData`` object that supports the `buffer protocol`_ so its data can be made accessible to Python by using a memoryview_ object.
This allows the data to be used without copying.
See the ``copy-data.py`` example for typical usage.
Note that if the CameraFile object is deleted, or another function (such as ``gp_file_set_data_and_size`` or ``gp_file_open``) changes the CameraFile's data, then this object will be invalidated and you will probably get a segmentation fault.
gp_file_set_data_and_size / CameraFile.set_data_and_size
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Since python-gphoto2 version 2.1.0 these functions accept any `bytes-like object`_.
In earlier versions of python-gphoto2 these functions required a string and its length, and didn't work correctly anyway.
gp_camera_file_read / Camera.file_read
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The ``buf`` parameter can be any Python object that exposes a writeable buffer interface.
This allows you to read a file directly into a Python object without additional copying.
See the ``copy-chunks.py`` example which uses memoryview_ to expose a bytearray_.
gp_camera_wait_for_event / Camera.wait_for_event
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
These functions return both the event type and the event data.
The data you get depends on the type.
``GP_EVENT_FILE_ADDED`` and ``GP_EVENT_FOLDER_ADDED`` events return a ``CameraFilePath``, others return ``None`` or a text string.
Licence
-------
| python-gphoto2 - Python interface to libgphoto2
| http://github.com/jim-easterbrook/python-gphoto2
| Copyright (C) 2014-23 Jim Easterbrook jim@jim-easterbrook.me.uk
python-gphoto2 is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
python-gphoto2 is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with python-gphoto2. If not, see
... \endif and \cond
# ... \endcond blocks.
ENABLED_SECTIONS =
# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
# initial value of a variable or macro / define can have for it to appear in the
# documentation. If the initializer consists of more lines than specified here
# it will be hidden. Use a value of 0 to hide initializers completely. The
# appearance of the value of individual variables and macros / defines can be
# controlled using \showinitializer or \hideinitializer command in the
# documentation regardless of this setting.
# Minimum value: 0, maximum value: 10000, default value: 30.
MAX_INITIALIZER_LINES = 30
# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
# the bottom of the documentation of classes and structs. If set to YES, the
# list will mention the files that were used to generate the documentation.
# The default value is: YES.
SHOW_USED_FILES = YES
# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
# will remove the Files entry from the Quick Index and from the Folder Tree View
# (if specified).
# The default value is: YES.
SHOW_FILES = YES
# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
# page. This will remove the Namespaces entry from the Quick Index and from the
# Folder Tree View (if specified).
# The default value is: YES.
SHOW_NAMESPACES = YES
# The FILE_VERSION_FILTER tag can be used to specify a program or script that
# doxygen should invoke to get the current version for each file (typically from
# the version control system). Doxygen will invoke the program by executing (via
# popen()) the command command input-file, where command is the value of the
# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
# by doxygen. Whatever the program writes to standard output is used as the file
# version. For an example see the documentation.
FILE_VERSION_FILTER =
# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
# by doxygen. The layout file controls the global structure of the generated
# output files in an output format independent way. To create the layout file
# that represents doxygen's defaults, run doxygen with the -l option. You can
# optionally specify a file name after the option, if omitted DoxygenLayout.xml
# will be used as the name of the layout file.
#
# Note that if you run doxygen from a directory containing a file called
# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
# tag is left empty.
LAYOUT_FILE =
# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
# the reference definitions. This must be a list of .bib files. The .bib
# extension is automatically appended if omitted. This requires the bibtex tool
# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
# For LaTeX the style of the bibliography can be controlled using
# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
# search path. See also \cite for info how to create references.
CITE_BIB_FILES =
#---------------------------------------------------------------------------
# Configuration options related to warning and progress messages
#---------------------------------------------------------------------------
# The QUIET tag can be used to turn on/off the messages that are generated to
# standard output by doxygen. If QUIET is set to YES this implies that the
# messages are off.
# The default value is: NO.
QUIET = YES
# The WARNINGS tag can be used to turn on/off the warning messages that are
# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
# this implies that the warnings are on.
#
# Tip: Turn warnings on while writing the documentation.
# The default value is: YES.
WARNINGS = NO
# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
# will automatically be disabled.
# The default value is: YES.
WARN_IF_UNDOCUMENTED = NO
# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
# potential errors in the documentation, such as not documenting some parameters
# in a documented function, or documenting parameters that don't exist or using
# markup commands wrongly.
# The default value is: YES.
WARN_IF_DOC_ERROR = NO
# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
# are documented, but have no documentation for their parameters or return
# value. If set to NO, doxygen will only warn about wrong or incomplete
# parameter documentation, but not about the absence of documentation.
# The default value is: NO.
WARN_NO_PARAMDOC = NO
# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
# a warning is encountered.
# The default value is: NO.
WARN_AS_ERROR = NO
# The WARN_FORMAT tag determines the format of the warning messages that doxygen
# can produce. The string should contain the $file, $line, and $text tags, which
# will be replaced by the file and line number from which the warning originated
# and the warning text. Optionally the format may contain $version, which will
# be replaced by the version of the file (if it could be obtained via
# FILE_VERSION_FILTER)
# The default value is: $file:$line: $text.
WARN_FORMAT = "$file:$line: $text"
# The WARN_LOGFILE tag can be used to specify a file to which warning and error
# messages should be written. If left blank the output is written to standard
# error (stderr).
WARN_LOGFILE =
#---------------------------------------------------------------------------
# Configuration options related to the input files
#---------------------------------------------------------------------------
# The INPUT tag is used to specify the files and/or directories that contain
# documented source files. You may enter file names like myfile.cpp or
# directories like /usr/src/myproject. Separate the files or directories with
# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
# Note: If this tag is empty the current directory is searched.
INPUT = libgphoto2 \
gphoto2 \
libgphoto2_port/gphoto2 \
libgphoto2_port/libgphoto2_port \
camlibs/template
# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
# documentation (see: https://www.gnu.org/software/libiconv/) for the list of
# possible encodings.
# The default value is: UTF-8.
INPUT_ENCODING = ISO-8859-15
# If the value of the INPUT tag contains directories, you can use the
# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
# *.h) to filter out the source-files in the directories.
#
# Note that for custom extensions or not directly supported extensions you also
# need to set EXTENSION_MAPPING for the extension otherwise the files are not
# read by doxygen.
#
# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.pyw, *.f90, *.f95, *.f03, *.f08,
# *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf and *.qsf.
FILE_PATTERNS = *.h \
*.c
# The RECURSIVE tag can be used to specify whether or not subdirectories should
# be searched for input files as well.
# The default value is: NO.
RECURSIVE = NO
# The EXCLUDE tag can be used to specify files and/or directories that should be
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
#
# Note that relative paths are relative to the directory from which doxygen is
# run.
EXCLUDE =
# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
# directories that are symbolic links (a Unix file system feature) are excluded
# from the input.
# The default value is: NO.
EXCLUDE_SYMLINKS = NO
# If the value of the INPUT tag contains directories, you can use the
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
# certain files from those directories.
#
# Note that the wildcards are matched against the file with absolute path, so to
# exclude all test directories for example use the pattern */test/*
EXCLUDE_PATTERNS =
# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
# (namespaces, classes, functions, etc.) that should be excluded from the
# output. The symbol name can be a fully qualified name, a word, or if the
# wildcard * is used, a substring. Examples: ANamespace, AClass,
# AClass::ANamespace, ANamespace::*Test
#
# Note that the wildcards are matched against the file with absolute path, so to
# exclude all test directories use the pattern */test/*
EXCLUDE_SYMBOLS =
# The EXAMPLE_PATH tag can be used to specify one or more files or directories
# that contain example code fragments that are included (see the \include
# command).
EXAMPLE_PATH =
# If the value of the EXAMPLE_PATH tag contains directories, you can use the
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
# *.h) to filter out the source-files in the directories. If left blank all
# files are included.
EXAMPLE_PATTERNS =
# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
# searched for input files to be used with the \include or \dontinclude commands
# irrespective of the value of the RECURSIVE tag.
# The default value is: NO.
EXAMPLE_RECURSIVE = NO
# The IMAGE_PATH tag can be used to specify one or more files or directories
# that contain images that are to be included in the documentation (see the
# \image command).
IMAGE_PATH =
# The INPUT_FILTER tag can be used to specify a program that doxygen should
# invoke to filter for each input file. Doxygen will invoke the filter program
# by executing (via popen()) the command:
#
#
#
# where is the value of the INPUT_FILTER tag, and is the
# name of an input file. Doxygen will then use the output that the filter
# program writes to standard output. If FILTER_PATTERNS is specified, this tag
# will be ignored.
#
# Note that the filter must not add or remove lines; it is applied before the
# code is scanned, but not when the output code is generated. If lines are added
# or removed, the anchors will not be placed correctly.
#
# Note that for custom extensions or not directly supported extensions you also
# need to set EXTENSION_MAPPING for the extension otherwise the files are not
# properly processed by doxygen.
INPUT_FILTER =
# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
# basis. Doxygen will compare the file name with each pattern and apply the
# filter if there is a match. The filters are a list of the form: pattern=filter
# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
# patterns match the file name, INPUT_FILTER is applied.
#
# Note that for custom extensions or not directly supported extensions you also
# need to set EXTENSION_MAPPING for the extension otherwise the files are not
# properly processed by doxygen.
FILTER_PATTERNS =
# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
# INPUT_FILTER) will also be used to filter the input files that are used for
# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
# The default value is: NO.
FILTER_SOURCE_FILES = NO
# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
# it is also possible to disable source filtering for a specific pattern using
# *.ext= (so without naming a filter).
# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
FILTER_SOURCE_PATTERNS =
# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
# is part of the input, its contents will be placed on the main page
# (index.html). This can be useful if you have a project on for instance GitHub
# and want to reuse the introduction page also for the doxygen output.
USE_MDFILE_AS_MAINPAGE =
#---------------------------------------------------------------------------
# Configuration options related to source browsing
#---------------------------------------------------------------------------
# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
# generated. Documented entities will be cross-referenced with these sources.
#
# Note: To get rid of all source code in the generated output, make sure that
# also VERBATIM_HEADERS is set to NO.
# The default value is: NO.
SOURCE_BROWSER = NO
# Setting the INLINE_SOURCES tag to YES will include the body of functions,
# classes and enums directly into the documentation.
# The default value is: NO.
INLINE_SOURCES = NO
# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
# special comment blocks from generated source code fragments. Normal C, C++ and
# Fortran comments will always remain visible.
# The default value is: YES.
STRIP_CODE_COMMENTS = YES
# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
# function all documented functions referencing it will be listed.
# The default value is: NO.
REFERENCED_BY_RELATION = YES
# If the REFERENCES_RELATION tag is set to YES then for each documented function
# all documented entities called/used by that function will be listed.
# The default value is: NO.
REFERENCES_RELATION = YES
# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
# to YES then the hyperlinks from functions in REFERENCES_RELATION and
# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
# link to the documentation.
# The default value is: YES.
REFERENCES_LINK_SOURCE = YES
# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
# source code will show a tooltip with additional information such as prototype,
# brief description and links to the definition and documentation. Since this
# will make the HTML file larger and loading of large files a bit slower, you
# can opt to disable this feature.
# The default value is: YES.
# This tag requires that the tag SOURCE_BROWSER is set to YES.
SOURCE_TOOLTIPS = YES
# If the USE_HTAGS tag is set to YES then the references to source code will
# point to the HTML generated by the htags(1) tool instead of doxygen built-in
# source browser. The htags tool is part of GNU's global source tagging system
# (see https://www.gnu.org/software/global/global.html). You will need version
# 4.8.6 or higher.
#
# To use it do the following:
# - Install the latest version of global
# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
# - Make sure the INPUT points to the root of the source tree
# - Run doxygen as normal
#
# Doxygen will invoke htags (and that will in turn invoke gtags), so these
# tools must be available from the command line (i.e. in the search path).
#
# The result: instead of the source browser generated by doxygen, the links to
# source code will now point to the output of htags.
# The default value is: NO.
# This tag requires that the tag SOURCE_BROWSER is set to YES.
USE_HTAGS = NO
# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
# verbatim copy of the header file for each class for which an include is
# specified. Set to NO to disable this.
# See also: Section \class.
# The default value is: YES.
VERBATIM_HEADERS = YES
#---------------------------------------------------------------------------
# Configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
# compounds will be generated. Enable this if the project contains a lot of
# classes, structs, unions or interfaces.
# The default value is: YES.
ALPHABETICAL_INDEX = NO
# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
# which the alphabetical index list will be split.
# Minimum value: 1, maximum value: 20, default value: 5.
# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
COLS_IN_ALPHA_INDEX = 5
# In case all classes in a project start with a common prefix, all classes will
# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
# can be used to specify a prefix (or a list of prefixes) that should be ignored
# while generating the index headers.
# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the HTML output
#---------------------------------------------------------------------------
# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
# The default value is: YES.
GENERATE_HTML = NO
# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
# it.
# The default directory is: html.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_OUTPUT = html
# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
# generated HTML page (for example: .htm, .php, .asp).
# The default value is: .html.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_FILE_EXTENSION = .html
# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
# each generated HTML page. If the tag is left blank doxygen will generate a
# standard header.
#
# To get valid HTML the header file that includes any scripts and style sheets
# that doxygen needs, which is dependent on the configuration options used (e.g.
# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
# default header using
# doxygen -w html new_header.html new_footer.html new_stylesheet.css
# YourConfigFile
# and then modify the file new_header.html. See also section "Doxygen usage"
# for information on how to generate the default header that doxygen normally
# uses.
# Note: The header is subject to change so you typically have to regenerate the
# default header when upgrading to a newer version of doxygen. For a description
# of the possible markers and block names see the documentation.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_HEADER =
# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
# generated HTML page. If the tag is left blank doxygen will generate a standard
# footer. See HTML_HEADER for more information on how to generate a default
# footer and what special commands can be used inside the footer. See also
# section "Doxygen usage" for information on how to generate the default footer
# that doxygen normally uses.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_FOOTER =
# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
# sheet that is used by each HTML page. It can be used to fine-tune the look of
# the HTML output. If left blank doxygen will generate a default style sheet.
# See also section "Doxygen usage" for information on how to generate the style
# sheet that doxygen normally uses.
# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
# it is more robust and this tag (HTML_STYLESHEET) will in the future become
# obsolete.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_STYLESHEET =
# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
# cascading style sheets that are included after the standard style sheets
# created by doxygen. Using this option one can overrule certain style aspects.
# This is preferred over using HTML_STYLESHEET since it does not replace the
# standard style sheet and is therefore more robust against future updates.
# Doxygen will copy the style sheet files to the output directory.
# Note: The order of the extra style sheet files is of importance (e.g. the last
# style sheet in the list overrules the setting of the previous ones in the
# list). For an example see the documentation.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_EXTRA_STYLESHEET =
# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
# other source files which should be copied to the HTML output directory. Note
# that these files will be copied to the base HTML output directory. Use the
# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
# files will be copied as-is; there are no commands or markers available.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_EXTRA_FILES =
# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
# will adjust the colors in the style sheet and background images according to
# this color. Hue is specified as an angle on a colorwheel, see
# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
# purple, and 360 is red again.
# Minimum value: 0, maximum value: 359, default value: 220.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_COLORSTYLE_HUE = 220
# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
# in the HTML output. For a value of 0 the output will use grayscales only. A
# value of 255 will produce the most vivid colors.
# Minimum value: 0, maximum value: 255, default value: 100.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_COLORSTYLE_SAT = 100
# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
# luminance component of the colors in the HTML output. Values below 100
# gradually make the output lighter, whereas values above 100 make the output
# darker. The value divided by 100 is the actual gamma applied, so 80 represents
# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
# change the gamma.
# Minimum value: 40, maximum value: 240, default value: 80.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_COLORSTYLE_GAMMA = 80
# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
# page will contain the date and time when the page was generated. Setting this
# to YES can help to show when doxygen was last run and thus if the
# documentation is up to date.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_TIMESTAMP = NO
# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
# documentation will contain a main index with vertical navigation menus that
# are dynamically created via Javascript. If disabled, the navigation index will
# consists of multiple levels of tabs that are statically embedded in every HTML
# page. Disable this option to support browsers that do not have Javascript,
# like the Qt help browser.
# The default value is: YES.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_DYNAMIC_MENUS = YES
# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
# documentation will contain sections that can be hidden and shown after the
# page has loaded.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_DYNAMIC_SECTIONS = NO
# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
# shown in the various tree structured indices initially; the user can expand
# and collapse entries dynamically later on. Doxygen will expand the tree to
# such a level that at most the specified number of entries are visible (unless
# a fully collapsed tree already exceeds this amount). So setting the number of
# entries 1 will produce a full collapsed tree by default. 0 is a special value
# representing an infinite number of entries and will result in a full expanded
# tree by default.
# Minimum value: 0, maximum value: 9999, default value: 100.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_INDEX_NUM_ENTRIES = 100
# If the GENERATE_DOCSET tag is set to YES, additional index files will be
# generated that can be used as input for Apple's Xcode 3 integrated development
# environment (see: https://developer.apple.com/tools/xcode/), introduced with
# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
# Makefile in the HTML output directory. Running make will produce the docset in
# that directory and running make install will install the docset in
# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
# startup. See https://developer.apple.com/tools/creatingdocsetswithdoxygen.html
# for more information.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
GENERATE_DOCSET = NO
# This tag determines the name of the docset feed. A documentation feed provides
# an umbrella under which multiple documentation sets from a single provider
# (such as a company or product suite) can be grouped.
# The default value is: Doxygen generated docs.
# This tag requires that the tag GENERATE_DOCSET is set to YES.
DOCSET_FEEDNAME = "Doxygen generated docs"
# This tag specifies a string that should uniquely identify the documentation
# set bundle. This should be a reverse domain-name style string, e.g.
# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
# The default value is: org.doxygen.Project.
# This tag requires that the tag GENERATE_DOCSET is set to YES.
DOCSET_BUNDLE_ID = org.doxygen.Project
# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
# the documentation publisher. This should be a reverse domain-name style
# string, e.g. com.mycompany.MyDocSet.documentation.
# The default value is: org.doxygen.Publisher.
# This tag requires that the tag GENERATE_DOCSET is set to YES.
DOCSET_PUBLISHER_ID = org.doxygen.Publisher
# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
# The default value is: Publisher.
# This tag requires that the tag GENERATE_DOCSET is set to YES.
DOCSET_PUBLISHER_NAME = Publisher
# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
# Windows.
#
# The HTML Help Workshop contains a compiler that can convert all HTML output
# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
# files are now used as the Windows 98 help format, and will replace the old
# Windows help format (.hlp) on all Windows platforms in the future. Compressed
# HTML files also contain an index, a table of contents, and you can search for
# words in the documentation. The HTML workshop also contains a viewer for
# compressed HTML files.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
GENERATE_HTMLHELP = NO
# The CHM_FILE tag can be used to specify the file name of the resulting .chm
# file. You can add a path in front of the file if the result should not be
# written to the html output directory.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
CHM_FILE =
# The HHC_LOCATION tag can be used to specify the location (absolute path
# including file name) of the HTML help compiler (hhc.exe). If non-empty,
# doxygen will try to run the HTML help compiler on the generated index.hhp.
# The file has to be specified with full path.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
HHC_LOCATION =
# The GENERATE_CHI flag controls if a separate .chi index file is generated
# (YES) or that it should be included in the master .chm file (NO).
# The default value is: NO.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
GENERATE_CHI = NO
# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
# and project file content.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
CHM_INDEX_ENCODING =
# The BINARY_TOC flag controls whether a binary table of contents is generated
# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
# enables the Previous and Next buttons.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
BINARY_TOC = NO
# The TOC_EXPAND flag can be set to YES to add extra items for group members to
# the table of contents of the HTML help documentation and to the tree view.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
TOC_EXPAND = NO
# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
# (.qch) of the generated HTML documentation.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
GENERATE_QHP = NO
# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
# the file name of the resulting .qch file. The path specified is relative to
# the HTML output folder.
# This tag requires that the tag GENERATE_QHP is set to YES.
QCH_FILE =
# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
# Project output. For more information please see Qt Help Project / Namespace
# (see: http://doc.qt.io/qt-4.8/qthelpproject.html#namespace).
# The default value is: org.doxygen.Project.
# This tag requires that the tag GENERATE_QHP is set to YES.
QHP_NAMESPACE = org.doxygen.Project
# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
# Help Project output. For more information please see Qt Help Project / Virtual
# Folders (see: http://doc.qt.io/qt-4.8/qthelpproject.html#virtual-folders).
# The default value is: doc.
# This tag requires that the tag GENERATE_QHP is set to YES.
QHP_VIRTUAL_FOLDER = doc
# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
# filter to add. For more information please see Qt Help Project / Custom
# Filters (see: http://doc.qt.io/qt-4.8/qthelpproject.html#custom-filters).
# This tag requires that the tag GENERATE_QHP is set to YES.
QHP_CUST_FILTER_NAME =
# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
# custom filter to add. For more information please see Qt Help Project / Custom
# Filters (see: http://doc.qt.io/qt-4.8/qthelpproject.html#custom-filters).
# This tag requires that the tag GENERATE_QHP is set to YES.
QHP_CUST_FILTER_ATTRS =
# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
# project's filter section matches. Qt Help Project / Filter Attributes (see:
# http://doc.qt.io/qt-4.8/qthelpproject.html#filter-attributes).
# This tag requires that the tag GENERATE_QHP is set to YES.
QHP_SECT_FILTER_ATTRS =
# The QHG_LOCATION tag can be used to specify the location of Qt's
# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
# generated .qhp file.
# This tag requires that the tag GENERATE_QHP is set to YES.
QHG_LOCATION =
# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
# generated, together with the HTML files, they form an Eclipse help plugin. To
# install this plugin and make it available under the help contents menu in
# Eclipse, the contents of the directory containing the HTML and XML files needs
# to be copied into the plugins directory of eclipse. The name of the directory
# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
# After copying Eclipse needs to be restarted before the help appears.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
GENERATE_ECLIPSEHELP = NO
# A unique identifier for the Eclipse help plugin. When installing the plugin
# the directory name containing the HTML and XML files should also have this
# name. Each documentation set should have its own identifier.
# The default value is: org.doxygen.Project.
# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
ECLIPSE_DOC_ID = org.doxygen.Project
# If you want full control over the layout of the generated HTML pages it might
# be necessary to disable the index and replace it with your own. The
# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
# of each HTML page. A value of NO enables the index and the value YES disables
# it. Since the tabs in the index contain the same information as the navigation
# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
DISABLE_INDEX = NO
# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
# structure should be generated to display hierarchical information. If the tag
# value is set to YES, a side panel will be generated containing a tree-like
# index structure (just like the one that is generated for HTML Help). For this
# to work a browser that supports JavaScript, DHTML, CSS and frames is required
# (i.e. any modern browser). Windows users are probably better off using the
# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
# further fine-tune the look of the index. As an example, the default style
# sheet generated by doxygen has an example that shows how to put an image at
# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
# the same information as the tab index, you could consider setting
# DISABLE_INDEX to YES when enabling this option.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
GENERATE_TREEVIEW = NO
# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
# doxygen will group on one line in the generated HTML documentation.
#
# Note that a value of 0 will completely suppress the enum values from appearing
# in the overview section.
# Minimum value: 0, maximum value: 20, default value: 4.
# This tag requires that the tag GENERATE_HTML is set to YES.
ENUM_VALUES_PER_LINE = 4
# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
# to set the initial width (in pixels) of the frame in which the tree is shown.
# Minimum value: 0, maximum value: 1500, default value: 250.
# This tag requires that the tag GENERATE_HTML is set to YES.
TREEVIEW_WIDTH = 250
# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
# external symbols imported via tag files in a separate window.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
EXT_LINKS_IN_WINDOW = NO
# Use this tag to change the font size of LaTeX formulas included as images in
# the HTML documentation. When you change the font size after a successful
# doxygen run you need to manually remove any form_*.png images from the HTML
# output directory to force them to be regenerated.
# Minimum value: 8, maximum value: 50, default value: 10.
# This tag requires that the tag GENERATE_HTML is set to YES.
FORMULA_FONTSIZE = 10
# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
# generated for formulas are transparent PNGs. Transparent PNGs are not
# supported properly for IE 6.0, but are supported on all modern browsers.
#
# Note that when changing this option you need to delete any form_*.png files in
# the HTML output directory before the changes have effect.
# The default value is: YES.
# This tag requires that the tag GENERATE_HTML is set to YES.
FORMULA_TRANSPARENT = YES
# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
# https://www.mathjax.org) which uses client side Javascript for the rendering
# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
# installed or if you want to formulas look prettier in the HTML output. When
# enabled you may also need to install MathJax separately and configure the path
# to it using the MATHJAX_RELPATH option.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
USE_MATHJAX = NO
# When MathJax is enabled you can set the default output format to be used for
# the MathJax output. See the MathJax site (see:
# http://docs.mathjax.org/en/latest/output.html) for more details.
# Possible values are: HTML-CSS (which is slower, but has the best
# compatibility), NativeMML (i.e. MathML) and SVG.
# The default value is: HTML-CSS.
# This tag requires that the tag USE_MATHJAX is set to YES.
MATHJAX_FORMAT = HTML-CSS
# When MathJax is enabled you need to specify the location relative to the HTML
# output directory using the MATHJAX_RELPATH option. The destination directory
# should contain the MathJax.js script. For instance, if the mathjax directory
# is located at the same level as the HTML output directory, then
# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
# Content Delivery Network so you can quickly see the result without installing
# MathJax. However, it is strongly recommended to install a local copy of
# MathJax from https://www.mathjax.org before deployment.
# The default value is: https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/.
# This tag requires that the tag USE_MATHJAX is set to YES.
MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest
# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
# extension names that should be enabled during MathJax rendering. For example
# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
# This tag requires that the tag USE_MATHJAX is set to YES.
MATHJAX_EXTENSIONS =
# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
# of code that will be used on startup of the MathJax code. See the MathJax site
# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
# example see the documentation.
# This tag requires that the tag USE_MATHJAX is set to YES.
MATHJAX_CODEFILE =
# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
# the HTML output. The underlying search engine uses javascript and DHTML and
# should work on any modern browser. Note that when using HTML help
# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
# there is already a search function so this one should typically be disabled.
# For large projects the javascript based search engine can be slow, then
# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
# search using the keyboard; to jump to the search box use + S
# (what the is depends on the OS and browser, but it is typically
# , /, or both). Inside the search box use the to jump into the search results window, the results can be navigated
# using the . Press to select an item or to cancel
# the search. The filter options can be selected when the cursor is inside the
# search box by pressing +. Also here use the
# to select a filter and or to activate or cancel the filter
# option.
# The default value is: YES.
# This tag requires that the tag GENERATE_HTML is set to YES.
SEARCHENGINE = YES
# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
# implemented using a web server instead of a web client using Javascript. There
# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
# setting. When disabled, doxygen will generate a PHP script for searching and
# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
# and searching needs to be provided by external tools. See the section
# "External Indexing and Searching" for details.
# The default value is: NO.
# This tag requires that the tag SEARCHENGINE is set to YES.
SERVER_BASED_SEARCH = NO
# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
# script for searching. Instead the search results are written to an XML file
# which needs to be processed by an external indexer. Doxygen will invoke an
# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
# search results.
#
# Doxygen ships with an example indexer (doxyindexer) and search engine
# (doxysearch.cgi) which are based on the open source search engine library
# Xapian (see: https://xapian.org/).
#
# See the section "External Indexing and Searching" for details.
# The default value is: NO.
# This tag requires that the tag SEARCHENGINE is set to YES.
EXTERNAL_SEARCH = NO
# The SEARCHENGINE_URL should point to a search engine hosted by a web server
# which will return the search results when EXTERNAL_SEARCH is enabled.
#
# Doxygen ships with an example indexer (doxyindexer) and search engine
# (doxysearch.cgi) which are based on the open source search engine library
# Xapian (see: https://xapian.org/). See the section "External Indexing and
# Searching" for details.
# This tag requires that the tag SEARCHENGINE is set to YES.
SEARCHENGINE_URL =
# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
# search data is written to a file for indexing by an external tool. With the
# SEARCHDATA_FILE tag the name of this file can be specified.
# The default file is: searchdata.xml.
# This tag requires that the tag SEARCHENGINE is set to YES.
SEARCHDATA_FILE = searchdata.xml
# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
# projects and redirect the results back to the right project.
# This tag requires that the tag SEARCHENGINE is set to YES.
EXTERNAL_SEARCH_ID =
# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
# projects other than the one defined by this configuration file, but that are
# all added to the same external search index. Each project needs to have a
# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
# to a relative location where the documentation can be found. The format is:
# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
# This tag requires that the tag SEARCHENGINE is set to YES.
EXTRA_SEARCH_MAPPINGS =
#---------------------------------------------------------------------------
# Configuration options related to the LaTeX output
#---------------------------------------------------------------------------
# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
# The default value is: YES.
GENERATE_LATEX = NO
# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
# it.
# The default directory is: latex.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_OUTPUT = latex
# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
# invoked.
#
# Note that when enabling USE_PDFLATEX this option is only used for generating
# bitmaps for formulas in the HTML output, but not in the Makefile that is
# written to the output directory.
# The default file is: latex.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_CMD_NAME = latex
# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
# index for LaTeX.
# The default file is: makeindex.
# This tag requires that the tag GENERATE_LATEX is set to YES.
MAKEINDEX_CMD_NAME = makeindex
# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
# documents. This may be useful for small projects and may help to save some
# trees in general.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
COMPACT_LATEX = NO
# The PAPER_TYPE tag can be used to set the paper type that is used by the
# printer.
# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
# 14 inches) and executive (7.25 x 10.5 inches).
# The default value is: a4.
# This tag requires that the tag GENERATE_LATEX is set to YES.
PAPER_TYPE = a4
# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
# that should be included in the LaTeX output. The package can be specified just
# by its name or with the correct syntax as to be used with the LaTeX
# \usepackage command. To get the times font for instance you can specify :
# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
# To use the option intlimits with the amsmath package you can specify:
# EXTRA_PACKAGES=[intlimits]{amsmath}
# If left blank no extra packages will be included.
# This tag requires that the tag GENERATE_LATEX is set to YES.
EXTRA_PACKAGES =
# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
# generated LaTeX document. The header should contain everything until the first
# chapter. If it is left blank doxygen will generate a standard header. See
# section "Doxygen usage" for information on how to let doxygen write the
# default header to a separate file.
#
# Note: Only use a user-defined header if you know what you are doing! The
# following commands have a special meaning inside the header: $title,
# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
# string, for the replacement values of the other commands the user is referred
# to HTML_HEADER.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_HEADER =
# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
# generated LaTeX document. The footer should contain everything after the last
# chapter. If it is left blank doxygen will generate a standard footer. See
# LATEX_HEADER for more information on how to generate a default footer and what
# special commands can be used inside the footer.
#
# Note: Only use a user-defined footer if you know what you are doing!
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_FOOTER =
# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
# LaTeX style sheets that are included after the standard style sheets created
# by doxygen. Using this option one can overrule certain style aspects. Doxygen
# will copy the style sheet files to the output directory.
# Note: The order of the extra style sheet files is of importance (e.g. the last
# style sheet in the list overrules the setting of the previous ones in the
# list).
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_EXTRA_STYLESHEET =
# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
# other source files which should be copied to the LATEX_OUTPUT output
# directory. Note that the files will be copied as-is; there are no commands or
# markers available.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_EXTRA_FILES =
# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
# contain links (just like the HTML output) instead of page references. This
# makes the output suitable for online browsing using a PDF viewer.
# The default value is: YES.
# This tag requires that the tag GENERATE_LATEX is set to YES.
PDF_HYPERLINKS = YES
# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
# the PDF file directly from the LaTeX files. Set this option to YES, to get a
# higher quality PDF documentation.
# The default value is: YES.
# This tag requires that the tag GENERATE_LATEX is set to YES.
USE_PDFLATEX = YES
# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
# command to the generated LaTeX files. This will instruct LaTeX to keep running
# if errors occur, instead of asking the user for help. This option is also used
# when generating formulas in HTML.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_BATCHMODE = NO
# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
# index chapters (such as File Index, Compound Index, etc.) in the output.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_HIDE_INDICES = NO
# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
# code with syntax highlighting in the LaTeX output.
#
# Note that which sources are shown also depends on other settings such as
# SOURCE_BROWSER.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_SOURCE_CODE = NO
# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
# bibliography, e.g. plainnat, or ieeetr. See
# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
# The default value is: plain.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_BIB_STYLE = plain
# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
# page will contain the date and time when the page was generated. Setting this
# to NO can help when comparing the output of multiple runs.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_TIMESTAMP = NO
#---------------------------------------------------------------------------
# Configuration options related to the RTF output
#---------------------------------------------------------------------------
# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
# RTF output is optimized for Word 97 and may not look too pretty with other RTF
# readers/editors.
# The default value is: NO.
GENERATE_RTF = NO
# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
# it.
# The default directory is: rtf.
# This tag requires that the tag GENERATE_RTF is set to YES.
RTF_OUTPUT = rtf
# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
# documents. This may be useful for small projects and may help to save some
# trees in general.
# The default value is: NO.
# This tag requires that the tag GENERATE_RTF is set to YES.
COMPACT_RTF = NO
# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
# contain hyperlink fields. The RTF file will contain links (just like the HTML
# output) instead of page references. This makes the output suitable for online
# browsing using Word or some other Word compatible readers that support those
# fields.
#
# Note: WordPad (write) and others do not support links.
# The default value is: NO.
# This tag requires that the tag GENERATE_RTF is set to YES.
RTF_HYPERLINKS = NO
# Load stylesheet definitions from file. Syntax is similar to doxygen's config
# file, i.e. a series of assignments. You only have to provide replacements,
# missing definitions are set to their default value.
#
# See also section "Doxygen usage" for information on how to generate the
# default style sheet that doxygen normally uses.
# This tag requires that the tag GENERATE_RTF is set to YES.
RTF_STYLESHEET_FILE =
# Set optional variables used in the generation of an RTF document. Syntax is
# similar to doxygen's config file. A template extensions file can be generated
# using doxygen -e rtf extensionFile.
# This tag requires that the tag GENERATE_RTF is set to YES.
RTF_EXTENSIONS_FILE =
# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
# with syntax highlighting in the RTF output.
#
# Note that which sources are shown also depends on other settings such as
# SOURCE_BROWSER.
# The default value is: NO.
# This tag requires that the tag GENERATE_RTF is set to YES.
RTF_SOURCE_CODE = NO
#---------------------------------------------------------------------------
# Configuration options related to the man page output
#---------------------------------------------------------------------------
# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
# classes and files.
# The default value is: NO.
GENERATE_MAN = NO
# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
# it. A directory man3 will be created inside the directory specified by
# MAN_OUTPUT.
# The default directory is: man.
# This tag requires that the tag GENERATE_MAN is set to YES.
MAN_OUTPUT = man
# The MAN_EXTENSION tag determines the extension that is added to the generated
# man pages. In case the manual section does not start with a number, the number
# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
# optional.
# The default value is: .3.
# This tag requires that the tag GENERATE_MAN is set to YES.
MAN_EXTENSION = .3
# The MAN_SUBDIR tag determines the name of the directory created within
# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
# MAN_EXTENSION with the initial . removed.
# This tag requires that the tag GENERATE_MAN is set to YES.
MAN_SUBDIR =
# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
# will generate one additional man file for each entity documented in the real
# man page(s). These additional files only source the real man page, but without
# them the man command would be unable to find the correct page.
# The default value is: NO.
# This tag requires that the tag GENERATE_MAN is set to YES.
MAN_LINKS = NO
#---------------------------------------------------------------------------
# Configuration options related to the XML output
#---------------------------------------------------------------------------
# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
# captures the structure of the code including all documentation.
# The default value is: NO.
GENERATE_XML = YES
# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
# it.
# The default directory is: xml.
# This tag requires that the tag GENERATE_XML is set to YES.
XML_OUTPUT = xml
# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
# listings (including syntax highlighting and cross-referencing information) to
# the XML output. Note that enabling this will significantly increase the size
# of the XML output.
# The default value is: YES.
# This tag requires that the tag GENERATE_XML is set to YES.
XML_PROGRAMLISTING = NO
#---------------------------------------------------------------------------
# Configuration options related to the DOCBOOK output
#---------------------------------------------------------------------------
# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
# that can be used to generate PDF.
# The default value is: NO.
GENERATE_DOCBOOK = NO
# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
# front of it.
# The default directory is: docbook.
# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
DOCBOOK_OUTPUT = docbook
# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
# program listings (including syntax highlighting and cross-referencing
# information) to the DOCBOOK output. Note that enabling this will significantly
# increase the size of the DOCBOOK output.
# The default value is: NO.
# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
DOCBOOK_PROGRAMLISTING = NO
#---------------------------------------------------------------------------
# Configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
# the structure of the code including all documentation. Note that this feature
# is still experimental and incomplete at the moment.
# The default value is: NO.
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# Configuration options related to the Perl module output
#---------------------------------------------------------------------------
# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
# file that captures the structure of the code including all documentation.
#
# Note that this feature is still experimental and incomplete at the moment.
# The default value is: NO.
GENERATE_PERLMOD = NO
# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
# output from the Perl module output.
# The default value is: NO.
# This tag requires that the tag GENERATE_PERLMOD is set to YES.
PERLMOD_LATEX = NO
# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
# formatted so it can be parsed by a human reader. This is useful if you want to
# understand what is going on. On the other hand, if this tag is set to NO, the
# size of the Perl module output will be much smaller and Perl will parse it
# just the same.
# The default value is: YES.
# This tag requires that the tag GENERATE_PERLMOD is set to YES.
PERLMOD_PRETTY = YES
# The names of the make variables in the generated doxyrules.make file are
# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
# so different doxyrules.make files included by the same Makefile don't
# overwrite each other's variables.
# This tag requires that the tag GENERATE_PERLMOD is set to YES.
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
# C-preprocessor directives found in the sources and include files.
# The default value is: YES.
ENABLE_PREPROCESSING = YES
# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
# in the source code. If set to NO, only conditional compilation will be
# performed. Macro expansion can be done in a controlled way by setting
# EXPAND_ONLY_PREDEF to YES.
# The default value is: NO.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
MACRO_EXPANSION = NO
# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
# the macro expansion is limited to the macros specified with the PREDEFINED and
# EXPAND_AS_DEFINED tags.
# The default value is: NO.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
EXPAND_ONLY_PREDEF = NO
# If the SEARCH_INCLUDES tag is set to YES, the include files in the
# INCLUDE_PATH will be searched if a #include is found.
# The default value is: YES.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
SEARCH_INCLUDES = YES
# The INCLUDE_PATH tag can be used to specify one or more directories that
# contain include files that are not input files but should be processed by the
# preprocessor.
# This tag requires that the tag SEARCH_INCLUDES is set to YES.
INCLUDE_PATH =
# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
# patterns (like *.h and *.hpp) to filter out the header-files in the
# directories. If left blank, the patterns specified with FILE_PATTERNS will be
# used.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
INCLUDE_FILE_PATTERNS =
# The PREDEFINED tag can be used to specify one or more macro names that are
# defined before the preprocessor is started (similar to the -D option of e.g.
# gcc). The argument of the tag is a list of macros of the form: name or
# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
# is assumed. To prevent a macro definition from being undefined via #undef or
# recursively expanded use the := operator instead of the = operator.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
PREDEFINED =
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
# tag can be used to specify a list of macro names that should be expanded. The
# macro definition that is found in the sources will be used. Use the PREDEFINED
# tag if you want to use a different macro definition that overrules the
# definition found in the source code.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
EXPAND_AS_DEFINED =
# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
# remove all references to function-like macros that are alone on a line, have
# an all uppercase name, and do not end with a semicolon. Such function macros
# are typically used for boiler-plate code, and will confuse the parser if not
# removed.
# The default value is: YES.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration options related to external references
#---------------------------------------------------------------------------
# The TAGFILES tag can be used to specify one or more tag files. For each tag
# file the location of the external documentation should be added. The format of
# a tag file without this location is as follows:
# TAGFILES = file1 file2 ...
# Adding location for the tag files is done as follows:
# TAGFILES = file1=loc1 "file2 = loc2" ...
# where loc1 and loc2 can be relative or absolute paths or URLs. See the
# section "Linking to external documentation" for more information about the use
# of tag files.
# Note: Each tag file must have a unique name (where the name does NOT include
# the path). If a tag file is not located in the directory in which doxygen is
# run, you must also specify the path to the tagfile here.
TAGFILES =
# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
# tag file that is based on the input files it reads. See section "Linking to
# external documentation" for more information about the usage of tag files.
GENERATE_TAGFILE =
# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
# the class index. If set to NO, only the inherited external classes will be
# listed.
# The default value is: NO.
ALLEXTERNALS = NO
# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
# in the modules index. If set to NO, only the current project's groups will be
# listed.
# The default value is: YES.
EXTERNAL_GROUPS = YES
# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
# the related pages index. If set to NO, only the current project's pages will
# be listed.
# The default value is: YES.
EXTERNAL_PAGES = YES
# The PERL_PATH should be the absolute path and name of the perl script
# interpreter (i.e. the result of 'which perl').
# The default file (with absolute path) is: /usr/bin/perl.
PERL_PATH = /usr/bin/perl
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
# NO turns the diagrams off. Note that this option also works with HAVE_DOT
# disabled, but it is recommended to install and use dot, since it yields more
# powerful graphs.
# The default value is: YES.
CLASS_DIAGRAMS = YES
# You can define message sequence charts within doxygen comments using the \msc
# command. Doxygen will then run the mscgen tool (see:
# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
# documentation. The MSCGEN_PATH tag allows you to specify the directory where
# the mscgen tool resides. If left empty the tool is assumed to be found in the
# default search path.
MSCGEN_PATH =
# You can include diagrams made with dia in doxygen documentation. Doxygen will
# then run dia to produce the diagram and insert it in the documentation. The
# DIA_PATH tag allows you to specify the directory where the dia binary resides.
# If left empty dia is assumed to be found in the default search path.
DIA_PATH =
# If set to YES the inheritance and collaboration graphs will hide inheritance
# and usage relations if the target is undocumented or is not a class.
# The default value is: YES.
HIDE_UNDOC_RELATIONS = YES
# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
# available from the path. This tool is part of Graphviz (see:
# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
# Bell Labs. The other options in this section have no effect if this option is
# set to NO
# The default value is: NO.
HAVE_DOT = NO
# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
# to run in parallel. When set to 0 doxygen will base this on the number of
# processors available in the system. You can set it explicitly to a value
# larger than 0 to get control over the balance between CPU load and processing
# speed.
# Minimum value: 0, maximum value: 32, default value: 0.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_NUM_THREADS = 0
# When you want a differently looking font in the dot files that doxygen
# generates you can specify the font name using DOT_FONTNAME. You need to make
# sure dot is able to find the font, which can be done by putting it in a
# standard location or by setting the DOTFONTPATH environment variable or by
# setting DOT_FONTPATH to the directory containing the font.
# The default value is: Helvetica.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_FONTNAME = Helvetica
# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
# dot graphs.
# Minimum value: 4, maximum value: 24, default value: 10.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_FONTSIZE = 10
# By default doxygen will tell dot to use the default font as specified with
# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
# the path where dot can find it using this tag.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_FONTPATH =
# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
# each documented class showing the direct and indirect inheritance relations.
# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
CLASS_GRAPH = YES
# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
# graph for each documented class showing the direct and indirect implementation
# dependencies (inheritance, containment, and class references variables) of the
# class with other documented classes.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
COLLABORATION_GRAPH = YES
# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
# groups, showing the direct groups dependencies.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
GROUP_GRAPHS = YES
# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
# collaboration diagrams in a style similar to the OMG's Unified Modeling
# Language.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
UML_LOOK = NO
# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
# class node. If there are many fields or methods and many nodes the graph may
# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
# number of items for each type to make the size more manageable. Set this to 0
# for no limit. Note that the threshold may be exceeded by 50% before the limit
# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
# but if the number exceeds 15, the total amount of fields shown is limited to
# 10.
# Minimum value: 0, maximum value: 100, default value: 10.
# This tag requires that the tag HAVE_DOT is set to YES.
UML_LIMIT_NUM_FIELDS = 10
# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
# collaboration graphs will show the relations between templates and their
# instances.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
TEMPLATE_RELATIONS = NO
# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
# YES then doxygen will generate a graph for each documented file showing the
# direct and indirect include dependencies of the file with other documented
# files.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
INCLUDE_GRAPH = YES
# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
# set to YES then doxygen will generate a graph for each documented file showing
# the direct and indirect include dependencies of the file with other documented
# files.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
INCLUDED_BY_GRAPH = YES
# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
# dependency graph for every global function or class method.
#
# Note that enabling this option will significantly increase the time of a run.
# So in most cases it will be better to enable call graphs for selected
# functions only using the \callgraph command. Disabling a call graph can be
# accomplished by means of the command \hidecallgraph.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
CALL_GRAPH = NO
# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
# dependency graph for every global function or class method.
#
# Note that enabling this option will significantly increase the time of a run.
# So in most cases it will be better to enable caller graphs for selected
# functions only using the \callergraph command. Disabling a caller graph can be
# accomplished by means of the command \hidecallergraph.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
CALLER_GRAPH = NO
# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
# hierarchy of all classes instead of a textual one.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
GRAPHICAL_HIERARCHY = YES
# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
# dependencies a directory has on other directories in a graphical way. The
# dependency relations are determined by the #include relations between the
# files in the directories.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
DIRECTORY_GRAPH = YES
# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
# generated by dot. For an explanation of the image formats see the section
# output formats in the documentation of the dot tool (Graphviz (see:
# http://www.graphviz.org/)).
# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
# to make the SVG files visible in IE 9+ (other browsers do not have this
# requirement).
# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
# png:gdiplus:gdiplus.
# The default value is: png.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_IMAGE_FORMAT = png
# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
# enable generation of interactive SVG images that allow zooming and panning.
#
# Note that this requires a modern browser other than Internet Explorer. Tested
# and working are Firefox, Chrome, Safari, and Opera.
# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
# the SVG files visible. Older versions of IE do not have SVG support.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
INTERACTIVE_SVG = NO
# The DOT_PATH tag can be used to specify the path where the dot tool can be
# found. If left blank, it is assumed the dot tool can be found in the path.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_PATH =
# The DOTFILE_DIRS tag can be used to specify one or more directories that
# contain dot files that are included in the documentation (see the \dotfile
# command).
# This tag requires that the tag HAVE_DOT is set to YES.
DOTFILE_DIRS =
# The MSCFILE_DIRS tag can be used to specify one or more directories that
# contain msc files that are included in the documentation (see the \mscfile
# command).
MSCFILE_DIRS =
# The DIAFILE_DIRS tag can be used to specify one or more directories that
# contain dia files that are included in the documentation (see the \diafile
# command).
DIAFILE_DIRS =
# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
# path where java can find the plantuml.jar file. If left blank, it is assumed
# PlantUML is not used or called during a preprocessing step. Doxygen will
# generate a warning when it encounters a \startuml command in this case and
# will not generate output for the diagram.
PLANTUML_JAR_PATH =
# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
# configuration file for plantuml.
PLANTUML_CFG_FILE =
# When using plantuml, the specified paths are searched for files specified by
# the !include statement in a plantuml block.
PLANTUML_INCLUDE_PATH =
# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
# that will be shown in the graph. If the number of nodes in a graph becomes
# larger than this value, doxygen will truncate the graph, which is visualized
# by representing a node as a red box. Note that doxygen if the number of direct
# children of the root node in a graph is already larger than
# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
# Minimum value: 0, maximum value: 10000, default value: 50.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_GRAPH_MAX_NODES = 50
# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
# generated by dot. A depth value of 3 means that only nodes reachable from the
# root by following a path via at most 3 edges will be shown. Nodes that lay
# further from the root node will be omitted. Note that setting this option to 1
# or 2 may greatly reduce the computation time needed for large code bases. Also
# note that the size of a graph can be further restricted by
# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
# Minimum value: 0, maximum value: 1000, default value: 0.
# This tag requires that the tag HAVE_DOT is set to YES.
MAX_DOT_GRAPH_DEPTH = 0
# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
# background. This is disabled by default, because dot on Windows does not seem
# to support this out of the box.
#
# Warning: Depending on the platform used, enabling this option may lead to
# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
# read).
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_TRANSPARENT = NO
# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
# files in one run (i.e. multiple -o and -T options on the command line). This
# makes dot run faster, but since only newer versions of dot (>1.8.10) support
# this, this feature is disabled by default.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_MULTI_TARGETS = NO
# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
# explaining the meaning of the various boxes and arrows in the dot generated
# graphs.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
GENERATE_LEGEND = NO
# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
# files that are used to generate the various graphs.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_CLEANUP = YES
python-gphoto2-2.5.1/developer/README.rst 0000664 0000000 0000000 00000007054 14703210004 0020071 0 ustar 00root root 0000000 0000000 Notes for developers
====================
The python interfaces can be built with any recent version of libgphoto2, but functions only present in later versions will not be accessible from python unless the interface is built with that later version. However, using this later version interface with an earlier version of libgphoto2 would normally result in undefined reference errors.
The solution is to include definitions of new functions in the interface to replace the proper versions when building for an older version of libgphoto2. See the camera.i interface file for an example.
The ``developer/build_swig.py`` script has one optional parameter: the installation directory of the version to be swigged. If this is omitted, the system installed libgphoto2 is used. For example::
python3 developer/build_swig.py libgphoto2-2.5.28/local_install
Using local libgphoto2
----------------------
To build python-gphoto2 with a different version of libgphoto2 than the one installed on your system you first need to build a local copy of libgphoto2. Download and extract the libgphoto2 source, change to the source directory and then configure, build and install::
./configure --prefix=$PWD/local_install CFLAGS="-std=gnu99 -g -O2"
make
make install
Note the use of ``--prefix=$PWD/local_install`` to create a local copy, rather than a system installation.
Now you can build and install a package that includes your local copy of the libgphoto2 libs::
GPHOTO2_ROOT=$PWD/libgphoto2-2.5.28/local_install pip install --user . -v
The ``GPHOTO2_ROOT`` environment variable tells setup.py to use the files in libgphoto2-2.5.28/local_install.
This value needs to be an absolute path.
Tracking libgphoto2 releases
----------------------------
When a new version of libgphoto2 is issued you should download it from https://sourceforge.net/projects/gphoto/files/libgphoto/ and run ``build_swig.py``. The Python3 script ``developer/compare_versions.py`` can be used to test if the swig generated files for two libgphoto2 versions differ.
If the only differences are the addition of some constants, then no changes to the SWIG sources are required. Other differences may require more work to accommodate. Once this is done the older version can usually be discarded.
Differences found so far::
2.5.0 Base 2.5 version
2.5.1-3 No change
2.5.4 Add GP_MIME_ARW constant
2.5.5 No change
2.5.6 Add GP_MIME_TXT constant
2.5.7-9 No change
2.5.10 Add gp_camera_list_config, gp_camera_get_single_config & gp_camera_set_single_config functions and GP_MIME_NEF constant
2.5.11-16 No change
2.5.17 Add GP_EVENT_FILE_CHANGED enum
2.5.18-22 No change
2.5.23 Add GP_MIME_CR3 constant
2.5.24 Add GP_PORT_IP enum
2.5.25-27 No change
2.5.28 Add gp_filesystem_set_info_dirty
2.5.29 No change
2.5.30 Add gp_init_localedir & gp_port_init_localedir functions
2.5.31 No change
Documentation
-------------
The libgphoto2 source includes documentation in "doxygen" format.
If you install doxygen and doxy2swig (https://github.com/m7thon/doxy2swig) this documentation can be included in the python interfaces.
Clone the doxy2swig GitHub repos to your working directory, then run ``python3 developer/build_doc.py source_dir`` before running ``python3 developer/build_swig.py install_dir``.
Releases
--------
After uploading a new release to PyPI a GitHub tag and corresponding message can be created by running ``python3 developer/tag_release.py``. Only then should the python-gphoto2 version number be incremented.
python-gphoto2-2.5.1/developer/build_doc.py 0000664 0000000 0000000 00000007154 14703210004 0020701 0 ustar 00root root 0000000 0000000 # python-gphoto2 - Python interface to libgphoto2
# http://github.com/jim-easterbrook/python-gphoto2
# Copyright (C) 2021-23 Jim Easterbrook jim@jim-easterbrook.me.uk
#
# This file is part of python-gphoto2.
#
# python-gphoto2 is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# python-gphoto2 is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with python-gphoto2. If not, see
# ]
def start_capture_view():
camera = gp.Camera()
hasCamInited = False
try:
camera.init() # prints: WARNING: gphoto2: (b'gp_context_error') b'Could not detect any camera' if logging set up
hasCamInited = True
except Exception as ex:
lastException = ex
print("No camera: {} {}; ".format( type(lastException).__name__, lastException.args))
if hasCamInited:
camera_config = camera.get_config()
camera_model = get_camera_model(camera_config)
put_camera_capture_preview_mirror(camera, camera_config, camera_model)
print("Started capture view (extended lens/raised mirror) on camera: {}".format(camera_model))
sys.exit(0)
else: # camera not inited
print("Sorry, no camera present, cannot execute command; exiting.")
sys.exit(1)
def stop_capture_view():
camera = gp.Camera()
hasCamInited = False
try:
camera.init()
hasCamInited = True
except Exception as ex:
lastException = ex
print("No camera: {} {}; ".format( type(lastException).__name__, lastException.args))
if hasCamInited:
camera_config = camera.get_config()
camera_model = get_camera_model(camera_config)
# https://github.com/gphoto/gphoto2/issues/195
OK, capture = gp.gp_widget_get_child_by_name( camera_config, 'capture' )
if OK >= gp.GP_OK:
capture.set_value(0)
camera.set_config(camera_config)
print("Stopped capture view (retracted lens/released mirror) on camera: {} ({} {})".format(camera_model, OK, capture))
sys.exit(0)
else: # camera not inited
print("Sorry, no camera present, cannot execute command; exiting.")
sys.exit(1)
# mostly from time_lapse.py (_send_file is from focus-gui.py)
def do_capture_image(camera):
# adjust camera configuratiuon
cfg = camera.get_config()
capturetarget_cfg = cfg.get_child_by_name('capturetarget')
capturetarget = capturetarget_cfg.get_value()
capturetarget_cfg.set_value('Internal RAM')
camera.set_config(cfg)
# do capture
path = camera.capture(gp.GP_CAPTURE_IMAGE)
print('capture cam path: {} {}'.format(path.folder, path.name))
camera_file = camera.file_get(
path.folder, path.name, gp.GP_FILE_TYPE_NORMAL)
# saving of image implied in current directory:
camera_file.save(path.name)
camera.file_delete(path.folder, path.name)
# reset configuration
capturetarget_cfg.set_value(capturetarget)
camera.set_config(cfg)
return path.name
def get_json_filters(args):
jsonfilters = []
if hasattr(args, 'include_names_json'):
splitnames = args.include_names_json.split(",")
for iname in splitnames:
splitnameeq = iname.split("=") # 1-element array if = not present; 2-element array if present
splitnameeq = list(filter(None, splitnameeq))
jsonfilters.append(splitnameeq)
jsonfilters = list(filter(None, jsonfilters))
return jsonfilters
def copy_json_filter_props(inarr, outarr, inpropcount, outpropcount, jsonfilters):
for inchild in inarr:
inpropcount.numtot += 1
if inchild['ro'] == 1:
inpropcount.numro += 1
else:
inpropcount.numrw += 1
shouldCopy = False
if len(jsonfilters)>0:
for jfilter in jsonfilters:
if len(jfilter) == 2:
key = jfilter[0] ; val = jfilter[1]
if ( str(inchild[key]) == val ):
shouldCopy = True
elif len(jfilter) == 1:
if inchild["name"] == jfilter[0]:
shouldCopy = True
else: # len(jsonfilters) == 0: ; no filters, pass everything
shouldCopy = True
# copy with flatten hierarchy - only copy dicts that have 'value' (else they have 'children'):
if ( ('value' in inchild.keys()) and (inchild['value'] is not None) ):
if shouldCopy:
outpropcount.numtot += 1
if inchild['ro'] == 1:
outpropcount.numro += 1
else:
outpropcount.numrw += 1
if 'Error' in str(inchild['value']):
outpropcount.numexc += 1
outarr.append(inchild)
else: # if the child dict has no 'value' then it has 'children'
if 'children' in inchild.keys():
copy_json_filter_props(inchild['children'], outarr, inpropcount, outpropcount, jsonfilters)
def do_GetSaveCamConfJson(camera, jsonfile, inunixts=None):
camera_config = camera.get_config() # may print: WARNING: gphoto2: (b'_get_config [config.c:7649]') b"Type of property 'Owner Name' expected: 0x4002 got: 0x0000"
camconfobj = get_camera_config_object(camera_config, inunixts)
with open(jsonfile, 'wb') as f:
json.dump(camconfobj, codecs.getwriter('utf-8')(f), ensure_ascii=False, indent=2, separators=(',', ': '))
print("Saved config to {}".format(jsonfile))
def getSaveCamConfJson(args):
if (not(args.save_cam_conf_json)):
print("getSaveCamConfJson: Sorry, unusable/empty output .json filename; aborting")
sys.exit(1)
jsonfile = os.path.realpath(args.save_cam_conf_json)
print("getSaveCamConfJson: saving to {}".format(jsonfile))
camera = gp.Camera()
hasCamInited = False
try:
camera.init()
hasCamInited = True
except Exception as ex:
lastException = ex
print("No camera: {} {}; ".format( type(lastException).__name__, lastException.args))
if hasCamInited:
do_GetSaveCamConfJson(camera, jsonfile)
print("Exiting.")
sys.exit(0)
else: # camera not inited
print("Sorry, no camera present, cannot execute command; exiting.")
sys.exit(1)
def copyFilterCamConfJson(args):
if (not(args.load_cam_conf_json) or not(args.save_cam_conf_json)):
print("copyFilterCamConfJson: Sorry, unusable/empty input or output .json filename; aborting")
sys.exit(1)
injsonfile = os.path.realpath(args.load_cam_conf_json)
outjsonfile = os.path.realpath(args.save_cam_conf_json)
print("loadSetCamConfJson: input load from {}, output save to {}".format(injsonfile, outjsonfile))
# no need for camera here
# open and parse injsonfile as object
with open(injsonfile) as in_data_file:
indatadict = json.load(in_data_file, object_pairs_hook=OrderedDict)
# check filters
jsonfilters = get_json_filters(args)
jsonfilterslen = len(jsonfilters)
if jsonfilterslen > 0:
print("Got {} json filters; including only properties names(/values) in filters in output file".format(jsonfilterslen))
else:
print("Got no ({}) json filters; copying input (flattened) to output file".format(jsonfilterslen))
retdict = OrderedDict()
retdict['camera_model'] = indatadict['camera_model']
retdict['orig_ts_taken_on'] = indatadict['ts_taken_on']
retdict['orig_date_taken_on'] = indatadict['date_taken_on']
unixts, isots, fsuffts = get_formatted_ts( time.time() )
retdict['ts_taken_on'] = unixts
retdict['date_taken_on'] = isots
inpropcount = PropCount()
outpropcount = PropCount()
retdict['children'] = []
copy_json_filter_props(indatadict['children'], retdict['children'], inpropcount, outpropcount, jsonfilters)
print("Processed input props: {} ro, {} rw, {} total; got output props: {} ro, {} rw, {} total".format(
inpropcount.numro, inpropcount.numrw, inpropcount.numtot, outpropcount.numro, outpropcount.numrw, outpropcount.numtot
))
# save
with open(outjsonfile, 'wb') as f:
json.dump(retdict, codecs.getwriter('utf-8')(f), ensure_ascii=False, indent=2, separators=(',', ': '))
print("Saved filtered copy to output file {}".format(outjsonfile))
sys.exit(0)
def do_LoadSetCamConfJson(camera, injsonfile):
camera_config = camera.get_config()
# open and parse injsonfile as object
with open(injsonfile) as in_data_file:
indatadict = json.load(in_data_file, object_pairs_hook=OrderedDict)
print("Getting flattened object (removes hierarchy/nodes with only children and without value) from {} ...".format(injsonfile))
inpropcount = PropCount()
outpropcount = PropCount()
jsonfilters = [] # empty here
flatproparray = []
copy_json_filter_props(indatadict['children'], flatproparray, inpropcount, outpropcount, jsonfilters)
print("Flattened {} ro, {} rw, {} total input props to: {} ro, {} rw, {} total flat props".format(
inpropcount.numro, inpropcount.numrw, inpropcount.numtot, outpropcount.numro, outpropcount.numrw, outpropcount.numtot
))
print("Applying at most {} read/write props (ignoring {} read-only ones, out of {} total props) to camera:".format(
outpropcount.numrw, outpropcount.numro, len(flatproparray)
))
numappliedprops = 0
usedlabels = [] ; usednames = []
# NOTE - some of the camera properties depend on others;
# say for shootingmode=Manual, some vars are r/w, but for shootingmode=Auto, same vars become r/o
# thus we split off flatproparray in two parts, executed first the one, then the other
flatproparrayfirst = []
for iname in PROPNAMESTOSETFIRST: # SO: 54343917
# find the object having the name iname
foundidx = -1
for ix, idict in enumerate(flatproparray):
if idict.get('name') == iname:
foundidx = ix
break
if foundidx > -1:
# remove dict object via pop at index, save removed object
remdict = flatproparray.pop(foundidx)
# add removed object to newarr:
flatproparrayfirst.append(remdict)
print("First pass (of applying cam settings):")
usednamesfirst = []
passedpropsfirst = 0
# no need to check duplicates or blacklisted here:
for ix, tprop in enumerate(flatproparrayfirst):
if tprop['ro'] == 1:
print(" {:3d}: (ignoring read-only prop '{}' ({}))".format(ix+1, tprop['name'], tprop['label'] ))
else:
numappliedprops += 1
print(" {:3d}: Applying prop {}/{}: '{}' = '{}' ({}))".format(ix+1, numappliedprops, outpropcount.numrw, tprop['name'], tprop['value'], tprop['label']))
usedlabels.append(tprop['label'])
usednamesfirst.append(tprop['name'])
OK, gpprop = gp.gp_widget_get_child_by_name( camera_config, "{}".format(tprop['name']) )
if OK >= gp.GP_OK:
if ( type(tprop['value']).__name__ == "unicode" ):
gpprop.set_value( "{}".format(tprop['value']) )
else:
gpprop.set_value( tprop['value'] )
passedpropsfirst = ix+1
print(" applying props: {}.".format(",".join(usednamesfirst)))
camera.set_config(camera_config)
# sleeping for 5 sec seems enough to allow changes between auto and manual shootingmode, without taking a picture... but 1 sec is not; 2 seems enough..
time.sleep(SLEEPWAITCHANGE)
print("Second pass (of applying cam settings):")
for ix, tprop in enumerate(flatproparray):
propnum = passedpropsfirst + ix + 1
if tprop['ro'] == 1:
print(" {:3d}: (ignoring read-only prop '{}' ({}))".format(propnum, tprop['name'], tprop['label'] ))
# only look for exact duplicates - rest, if needed, can be blacklisted:
elif ( tprop['label'] in usedlabels ):
print(" {:3d}: (ignoring duplicate label prop '{}' ({}))".format(propnum, tprop['name'], tprop['label'] ))
elif ( any([pat.match(tprop['name']) for pat in BLACKLISTPROPSREGEX]) ):
print(" {:3d}: (ignoring blacklisted name prop '{}' ({}))".format(propnum, tprop['name'], tprop['label'] ))
else:
numappliedprops += 1
print(" {:3d}: Applying prop {}/{}: '{}' = '{}' ({}))".format(propnum, numappliedprops, outpropcount.numrw, tprop['name'], tprop['value'], tprop['label']))
usedlabels.append(tprop['label'])
usednames.append(tprop['name'])
OK, gpprop = gp.gp_widget_get_child_by_name( camera_config, "{}".format(tprop['name']) )
if OK >= gp.GP_OK:
if ( type(tprop['value']).__name__ == "unicode" ):
gpprop.set_value( "{}".format(tprop['value']) )
else:
gpprop.set_value( tprop['value'] )
print(" applying props: {} (+ {}).".format( ",".join(usednames), ",".join(usednamesfirst) ))
camera.set_config(camera_config)
print("Applied {} properties from file {} to camera.".format(numappliedprops, injsonfile))
def loadSetCamConfJson(args):
if (not(args.load_cam_conf_json)):
print("loadSetCamConfJson: Sorry, unusable/empty output .json filename; aborting")
sys.exit(1)
injsonfile = os.path.realpath(args.load_cam_conf_json)
print("loadSetCamConfJson: loading from {}".format(injsonfile))
camera = gp.Camera()
ctx = gp.Context()
hasCamInited = False
try:
camera.init(ctx)
hasCamInited = True
except Exception as ex:
lastException = ex
print("No camera: {} {}; ".format( type(lastException).__name__, lastException.args))
if hasCamInited:
do_LoadSetCamConfJson(camera, injsonfile)
print("Exiting.")
sys.exit(0)
else:
print("Sorry, no camera present, cannot execute command; exiting.")
sys.exit(1)
# SO:35514531 - see also SO:46934526, 40683840, 9475772, https://github.com/baoboa/pyqt5/blob/master/examples/widgets/imageviewer.py
class PhotoViewer(QtWidgets.QGraphicsView):
photoClicked = QtCore.pyqtSignal(QtCore.QPoint)
def __init__(self, parent):
super(PhotoViewer, self).__init__(parent)
self.parent = parent
self.isMouseOver = False
self.ZOOMFACT = 1.25
self._zoom = 0
self._zoomfactor = 1
self._empty = True
self._scene = QtWidgets.QGraphicsScene(self)
self._photo = QtWidgets.QGraphicsPixmapItem()
self._scene.addItem(self._photo)
self.setScene(self._scene)
self.setTransformationAnchor(QtWidgets.QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QtWidgets.QGraphicsView.AnchorUnderMouse)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.setBackgroundBrush(QtGui.QBrush(QtGui.QColor(30, 30, 30)))
self.setFrameShape(QtWidgets.QFrame.NoFrame)
def hasPhoto(self):
return not self._empty
def printUnityFactor(self):
rect = QtCore.QRectF(self._photo.pixmap().rect())
unity = self.transform().mapRect(QtCore.QRectF(0, 0, 1, 1))
viewrect = self.viewport().rect()
scenerect = self.transform().mapRect(rect)
factor = min(viewrect.width() / scenerect.width(),
viewrect.height() / scenerect.height())
print("puf factor {} vr_w {} sr_w {} u_w {} vr_h {} sr_h {} u_h {} ".format(factor, viewrect.width(), scenerect.width(), unity.width(), viewrect.height(), scenerect.height(), unity.height() ))
def fitInView(self, scale=True):
rect = QtCore.QRectF(self._photo.pixmap().rect())
if not rect.isNull():
self.setSceneRect(rect)
if self.hasPhoto():
unity = self.transform().mapRect(QtCore.QRectF(0, 0, 1, 1))
self.scale(1 / unity.width(), 1 / unity.height())
viewrect = self.viewport().rect()
scenerect = self.transform().mapRect(rect)
factor = min(viewrect.width() / scenerect.width(),
viewrect.height() / scenerect.height())
# here, view scaled to fit:
self._zoomfactor = factor
self._zoom = math.log( self._zoomfactor, self.ZOOMFACT )
self.scale(factor, factor)
self.parent.updateStatusBar()
if (self.isMouseOver): # should be true on wheel, regardless
self.setDragState()
def setPhoto(self, pixmap=None):
if pixmap and not pixmap.isNull():
self._empty = False
self._photo.setPixmap(pixmap)
else:
self._empty = True
self._photo.setPixmap(QtGui.QPixmap())
def resetZoom(self):
if self.hasPhoto():
self._zoom = 0
self._zoomfactor = 1.0
unity = self.transform().mapRect(QtCore.QRectF(0, 0, 1, 1))
self.scale(1 / unity.width(), 1 / unity.height())
self.parent.updateStatusBar()
if (self.isMouseOver):
self.setDragState()
def zoomPlus(self):
if self.hasPhoto():
factor = self.ZOOMFACT # 1.25
self._zoomfactor = self._zoomfactor * self.ZOOMFACT
self._zoom += 1
self.scale(factor, factor)
self.parent.updateStatusBar()
self.setDragState()
def zoomMinus(self):
if self.hasPhoto():
factor = 1.0/self.ZOOMFACT #0.8
self._zoomfactor = self._zoomfactor / self.ZOOMFACT
self._zoom -= 1
self.scale(factor, factor)
self.parent.updateStatusBar()
self.setDragState()
def wheelEvent(self, event):
if self.hasPhoto():
if event.angleDelta().y() > 0:
self.zoomPlus()
else:
self.zoomMinus()
def mousePressEvent(self, event):
if self._photo.isUnderMouse():
self.photoClicked.emit(QtCore.QPoint(event.pos()))
super(PhotoViewer, self).mousePressEvent(event)
def getCanDrag(self):
return ((self.horizontalScrollBar().maximum() > 0) or (self.verticalScrollBar().maximum() > 0))
def setDragState(self):
# here we mostly want to take case of the mouse cursor/pointer - and show the hand only when dragging is possible
canDrag = self.getCanDrag()
if (canDrag):
self.setDragMode(QtWidgets.QGraphicsView.ScrollHandDrag)
else:
self.setDragMode(QtWidgets.QGraphicsView.NoDrag)
def enterEvent(self, event):
self.isMouseOver = True
self.setDragState()
return super(PhotoViewer, self).enterEvent(event)
def leaveEvent(self, event):
self.isMouseOver = False
# no need for setDragState - is autohandled, as we leave
return super(PhotoViewer, self).enterEvent(event)
# monkeypatch ccgoo.RangeWidget - it reacted only on self.sliderReleased.connect(self.new_value),
# which reacts only if slider dragged first, making it impossible to control from say VNC
class MyRangeWidget(QtWidgets.QSlider):
def __init__(self, config_changed, config, parent=None):
QtWidgets.QSlider.__init__(self, Qt.Horizontal, parent)
self.config_changed = config_changed
self.config = config
if self.config.get_readonly():
self.setDisabled(True)
assert self.config.count_children() == 0
lo, hi, self.inc = self.config.get_range()
value = self.config.get_value()
self.setRange(int(lo * self.inc), int(hi * self.inc))
self.setValue(int(value * self.inc))
self.valueChanged.connect(self.new_value)
def mousePressEvent(self, e):
if e.button() == Qt.LeftButton:
e.accept()
x = e.pos().x()
value = (self.maximum() - self.minimum()) * x / self.width() + self.minimum()
self.setValue(value)
else:
return super().mousePressEvent(self, e)
def new_value(self):
value = float(self.value()) * self.inc
self.config.set_value(value)
self.config_changed()
ccgoo.RangeWidget = MyRangeWidget
class MainWindow(QtWidgets.QMainWindow):
quit_action = None
new_image_sig = QtCore.pyqtSignal(object)
def _reset_config(self):
if self.hasCamInited:
if self.old_capturetarget is not None:
# find the capture target item
OK, capture_target = gp.gp_widget_get_child_by_name(
self.camera_config, 'capturetarget')
if OK >= gp.GP_OK:
# set config
capture_target.set_value(self.old_capturetarget)
self.camera.set_config(self.camera_config)
self.old_capturetarget = None
def closeEvent(self, event):
if self.hasCamInited:
self.running = False
self._reset_config()
self.camera.exit()
self.settings.setValue("geometry", self.saveGeometry())
self.settings.setValue("windowState", self.saveState())
return super(MainWindow, self).closeEvent(event)
def _set_config(self):
if self.hasCamInited:
# find the capture target item
OK, capture_target = gp.gp_widget_get_child_by_name(
self.camera_config, 'capturetarget')
if OK >= gp.GP_OK:
if self.old_capturetarget is None:
self.old_capturetarget = capture_target.get_value()
choice_count = capture_target.count_choices()
for n in range(choice_count):
choice = capture_target.get_choice(n)
if 'internal' in choice.lower():
# set config
capture_target.set_value(choice)
self.camera.set_config(self.camera_config)
break
# find the image format config item
# camera dependent - 'imageformat' is 'imagequality' on some
OK, image_format = gp.gp_widget_get_child_by_name(
self.camera_config, 'imageformat')
if OK >= gp.GP_OK:
# get current setting
value = image_format.get_value()
# make sure it's not raw
if 'raw' in value.lower():
print('Cannot preview raw images')
return False
return True
else:
return False
def set_splitter(self, inqtsplittertype, inwidget1, inwidget2):
if (hasattr(self,'splitter1')):
self.mainwid.layout().removeWidget(self.splitter1)
self.splitter1.close()
self.splitter1 = QtWidgets.QSplitter(inqtsplittertype)
self.splitter1.addWidget(inwidget1)
self.splitter1.addWidget(inwidget2)
self.splitter1.setSizes([600, 600]); # equal splitter at start
self.mainwid.layout().addWidget(self.splitter1)
self.mainwid.layout().update()
def create_main_menu(self):
self.mainMenu = self.menuBar()
self.fileMenu = self.mainMenu.addMenu('&File')
# actions
self.load_action = QtWidgets.QAction('&Load settings', self)
self.load_action.setShortcuts(['Ctrl+L'])
self.load_action.triggered.connect(self.load_settings)
self.save_action = QtWidgets.QAction('&Save settings', self)
self.save_action.setShortcuts(['Ctrl+S'])
self.save_action.triggered.connect(self.save_settings)
self.fileMenu.addAction(self.load_action)
self.fileMenu.addAction(self.save_action)
self.fileMenu.addAction(self.quit_action)
self.viewMenu = self.mainMenu.addMenu('&View')
self.zoomorig_action = QtWidgets.QAction('&Zoom original', self)
self.zoomorig_action.setShortcuts(['Ctrl+Z'])
self.zoomorig_action.triggered.connect(self.zoom_original)
self.zoomfitview_action = QtWidgets.QAction('Zoom to &fit view', self)
self.zoomfitview_action.setShortcuts(['Ctrl+F'])
self.zoomfitview_action.triggered.connect(self.zoom_fit_view)
self.zoomplus_action = QtWidgets.QAction('Zoom plu&s', self)
self.zoomplus_action.setShortcuts(['+'])
self.zoomplus_action.triggered.connect(self.zoom_plus)
self.zoomminus_action = QtWidgets.QAction('Zoom &minus', self)
self.zoomminus_action.setShortcuts(['-'])
self.zoomminus_action.triggered.connect(self.zoom_minus)
self.switchlayout_action = QtWidgets.QAction('Switch &Layout', self)
self.switchlayout_action.setShortcuts(['Ctrl+A'])
self.switchlayout_action.triggered.connect(self.switch_splitter_layout)
self.dopreview_action = QtWidgets.QAction('Do &Preview', self)
self.dopreview_action.setShortcuts(['Ctrl+X'])
self.dopreview_action.triggered.connect(self._do_preview)
self.repeatpreview_action = QtWidgets.QAction('&Repeat Preview', self)
self.repeatpreview_action.setShortcuts(['Ctrl+R'])
self.repeatpreview_action.setCheckable(True)
self.repeatpreview_action.setChecked(False)
self.repeatpreview_action.triggered.connect(self.continuous)
self.docapture_action = QtWidgets.QAction('Capture &Image', self)
self.docapture_action.setShortcuts(['Ctrl+I'])
self.docapture_action.triggered.connect(self._capture_image)
self.viewMenu.addAction(self.switchlayout_action)
self.viewMenu.addAction(self.dopreview_action)
self.viewMenu.addAction(self.repeatpreview_action)
self.viewMenu.addAction(self.docapture_action)
self.viewMenu.addAction(self.zoomorig_action)
self.viewMenu.addAction(self.zoomfitview_action)
self.viewMenu.addAction(self.zoomplus_action)
self.viewMenu.addAction(self.zoomminus_action)
def replicate_ccgoo_main_window(self):
# main widget
self.widget = QtWidgets.QWidget()
self.widget.setLayout(QtWidgets.QGridLayout())
self.widget.layout().setColumnStretch(0, 1)
# 'apply' button
if self.args.config_apply_btn == 1:
self.apply_button = QtWidgets.QPushButton('apply changes')
self.apply_button.setEnabled(False)
self.apply_button.clicked.connect(self.apply_changes)
self.widget.layout().addWidget(self.apply_button, 1, 1)
def eventFilter(self, source, event):
return super(MainWindow, self).eventFilter(source, event)
def replicate_fg_viewer(self):
self.image_display = PhotoViewer(self)
self.frameviewlayout.addWidget(self.image_display)
self.new_image_sig.connect(self.new_image)
def updateStatusBar(self):
msgstr = ""
if self.lastException:
msgstr = "No camera: {} {}; ".format( type(self.lastException).__name__, self.lastException.args)
if self.hasCamInited:
msgstr = "Camera model: {} ; ".format(self.camera_model if (self.camera_model) else "No info")
if self.lastImageSize:
msgstr += "last imgsize: {} x {} ".format(self.lastImageSize[0], self.lastImageSize[1])
zoomstr = "zoom: {:.3f} {:.3f}".format(self.image_display._zoom, self.image_display._zoomfactor)
def replacer(m):
retstr = m.group(1).replace(r'0', ' ')+' '*len(m.group(2))
return retstr
zoomstr = patTrailDigSpace.sub(lambda m: replacer(m), zoomstr)
msgstr += zoomstr
if self.fps:
msgstr += " ; {}".format(self.fps)
self.fps = ""
if self.singleStatusMsg:
msgstr += " ({})".format(self.singleStatusMsg)
self.singleStatusMsg = ""
self.statusBar().showMessage(msgstr)
def checkCreateNoCamImg(self):
nocamimgpath = os.path.join(THISSCRIPTDIR, NOCAMIMG)
if (not(os.path.isfile(nocamimgpath))):
# create gradient background with text:
nocamsize = (320, 240)
nocamsizec = (nocamsize[0]/2, nocamsize[1]/2)
colA = (80, 80, 80) ; colB = (210, 30, 30) ; # colB is center
nocamimg = Image.new('RGB', nocamsize, color=0xFF)
gradoffset = (-50, 20)
nocammaxd = math.sqrt((nocamsizec[0]+abs(gradoffset[0]))**2 + (nocamsizec[1]+abs(gradoffset[1]))**2)
for ix in range(nocamsize[0]):
for iy in range(nocamsize[1]):
dist = math.sqrt( (ix-nocamsizec[0]-gradoffset[0])**2 + (iy-nocamsizec[1]-gradoffset[1])**2 )
distnorm = dist/nocammaxd
r = colA[0]*distnorm + colB[0]*(1.0-distnorm)
g = colA[1]*distnorm + colB[1]*(1.0-distnorm)
b = colA[2]*distnorm + colB[2]*(1.0-distnorm)
nocamimg.putpixel((ix, iy), (int(r), int(g), int(b)) )
d = ImageDraw.Draw(nocamimg)
d.text((20,nocamsizec[1]-4), "No camera (unknown)", fill=(240,240,240))
nocamimg.save(nocamimgpath)
def __init__(self, args):
self.args = args
self.current_splitter_style=0
self.lastImageSize = None
self.lastImageType = None # 0 - preview; 1 - capture image
self.timestamp = None
self.fps = ""
self.lastException = None
self.lastOpenPath = None
self.lastSavePath = None
self.singleStatusMsg = ""
self.hasCamInited = False
self.do_init = QtCore.QEvent.registerEventType()
self.do_next = QtCore.QEvent.registerEventType()
self.running = False
QtWidgets.QMainWindow.__init__(self)
self.settings = QtCore.QSettings("MyCompany", APPNAME)
if not self.settings.value("geometry") == None:
self.restoreGeometry(self.settings.value("geometry"))
if not self.settings.value("windowState") == None:
self.restoreState(self.settings.value("windowState"))
self.setWindowTitle("Camera config {}".format(APPNAME))
self.setMinimumWidth(1000)
self.setMinimumHeight(600)
# quit shortcut
self.quit_action = QtWidgets.QAction('&Quit', self)
self.quit_action.setShortcuts(['Ctrl+Q', 'Ctrl+W'])
self.quit_action.setStatusTip('Exit application')
self.quit_action.triggered.connect(QtWidgets.qApp.closeAllWindows)
self.addAction(self.quit_action)
# main menu
self.create_main_menu()
# replicate main window from camera-config-gui-oo
self.replicate_ccgoo_main_window()
# frames
self.frameview = QtWidgets.QFrame(self)
self.frameview.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frameviewlayout = QtWidgets.QGridLayout(self.frameview)
self.frameviewlayout.setSpacing(0);
self.frameviewlayout.setContentsMargins(0,0,0,0);
self.checkCreateNoCamImg()
self.replicate_fg_viewer()
self.frameconf = QtWidgets.QFrame(self)
self.frameconf.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frameconf.setStyleSheet("padding: 0;") # nope
self.frameconflayout = QtWidgets.QHBoxLayout(self.frameconf)
self.frameconflayout.setSpacing(0);
self.frameconflayout.setContentsMargins(0,0,0,0);
self.scrollconf = QtWidgets.QScrollArea(self)
self.scrollconf.setWidgetResizable(False)
# self.contentconf is just used for init here; afterward is replaced by self.widget (self.configsection)
self.contentconf = QtWidgets.QWidget()
self.contentconf.setLayout(QtWidgets.QGridLayout())
self.contentconf.layout().setColumnStretch(0, 1)
self.scrollconf.setWidget(self.contentconf)
self.frameconflayout.addWidget(self.scrollconf)
self.mainwid = QtWidgets.QWidget()
self.mainwid.setLayout(QtWidgets.QGridLayout())
self.setCentralWidget(self.mainwid)
self.set_splitter(Qt.Horizontal, self.frameview, self.frameconf)
self.camera = gp.Camera()
self.ctx = gp.Context()
QtWidgets.QApplication.postEvent(
self, QtCore.QEvent(self.do_init), Qt.LowEventPriority - 1)
def event(self, event):
if ( (event.type() != self.do_init) and (event.type() != self.do_next) ):
return QtWidgets.QMainWindow.event(self, event)
event.accept()
if event.type() == self.do_init:
QtWidgets.QApplication.setOverrideCursor(Qt.WaitCursor)
try:
self.initialise()
finally:
QtWidgets.QApplication.restoreOverrideCursor()
return True
elif event.type() == self.do_next:
self._do_continuous()
return True
def _do_continuous(self):
if not self.running:
self._reset_config()
return
if self.hasCamInited:
self._do_preview()
else:
self._do_preview_camnotinit()
# post event to trigger next capture
QtWidgets.QApplication.postEvent(
self, QtCore.QEvent(self.do_next), Qt.LowEventPriority - 1)
@QtCore.pyqtSlot()
def continuous(self):
if self.running:
self.running = False
self.updateStatusBar() # clear last singleStatusMsg - clears fps upon stop
return
self.running = True
self._do_continuous()
def CameraHandlerInit(self):
# get camera config tree
self.hasCamInited = False
self.lastException = None
try:
self.camera.init(self.ctx)
self.hasCamInited = True
except Exception as ex:
self.lastException = ex
if type(ex) == gp.GPhoto2Error:
nocamimgpath = os.path.join(THISSCRIPTDIR, NOCAMIMG)
temppixmap = QtGui.QPixmap(nocamimgpath)
self.image_display.setPhoto(temppixmap)
if self.hasCamInited:
self.camera_config = self.camera.get_config()
# from CameraHandler::Init:
self.old_capturetarget = None
# get the camera model
self.camera_model = get_camera_model(self.camera_config)
put_camera_capture_preview_mirror(self.camera, self.camera_config, self.camera_model)
self.updateStatusBar()
def recreate_section_widget(self):
if ( hasattr(self, 'configsection') and (self.configsection) ):
self.widget.layout().removeWidget(self.configsection)
self.configsection = ccgoo.SectionWidget(self.config_changed, self.camera_config)
self.widget.layout().addWidget(self.configsection, 0, 0, 1, 3)
self.scrollconf.setWidget(self.widget)
def initialise(self):
self.CameraHandlerInit()
if self.hasCamInited:
# create corresponding tree of tab widgets
self.setWindowTitle(self.camera_config.get_label())
self.recreate_section_widget()
def config_changed(self):
if self.args.config_apply_btn == 1:
self.apply_button.setEnabled(True)
else:
def handler():
self.apply_changes()
timer.stop()
timer.deleteLater()
timer = QtCore.QTimer()
timer.timeout.connect(handler)
timer.start(0)
def reconstruct_config_section(self):
# assumes first setup already done, so there are existing tabs:
tabs = self.configsection.children()[1]
lastindex = tabs.currentIndex()
# get also the values of self.scrollconf scrollbars
lastconfhscroll = (self.scrollconf.horizontalScrollBar().value(), self.scrollconf.horizontalScrollBar().minimum(), self.scrollconf.horizontalScrollBar().singleStep(), self.scrollconf.horizontalScrollBar().pageStep(), self.scrollconf.horizontalScrollBar().maximum())
lastconfvscroll = (self.scrollconf.verticalScrollBar().value(), self.scrollconf.verticalScrollBar().minimum(), self.scrollconf.verticalScrollBar().singleStep(), self.scrollconf.verticalScrollBar().pageStep(), self.scrollconf.verticalScrollBar().maximum())
# Pre-reconstruct
self.camera_config = self.camera.get_config()
self.replicate_ccgoo_main_window()
self.recreate_section_widget()
tabs = self.configsection.children()[1]
tabs.setCurrentIndex(lastindex)
# Post-reconstruct
self.scrollconf.horizontalScrollBar().setValue(lastconfhscroll[0])
self.scrollconf.verticalScrollBar().setValue(lastconfvscroll[0])
def apply_changes(self):
self.camera.set_config(self.camera_config)
# here we'd need to reconstruct, to get the proper config values
self.reconstruct_config_section()
def load_settings(self):
self.updateStatusBar() # clear last singleStatusMsg
if self.lastOpenPath is not None:
startpath, startfile = os.path.split(self.lastOpenPath)
elif self.lastSavePath is not None:
startpath, startfile = os.path.split(self.lastSavePath)
else: # both None
startpath = os.getcwd()
startfile = ""
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getOpenFileName(self, "Load Camera Settings", os.path.join(startpath, startfile), "JSON Text Files (*.json);;All Files (*)", options=options)
if fileName:
do_LoadSetCamConfJson(self.camera, fileName)
# update GUI also
self.camera_config = self.camera.get_config()
# avoid GUI context
def handler():
self.apply_changes()
timer.stop()
timer.deleteLater()
timer = QtCore.QTimer()
timer.timeout.connect(handler)
timer.start(0)
self.lastOpenPath = fileName
self.singleStatusMsg = "loaded file to cam config; see terminal stdout for more"
self.updateStatusBar()
def save_settings(self):
self.updateStatusBar() # clear last singleStatusMsg
if self.lastSavePath is not None:
startpath, startfile = os.path.split(self.lastSavePath)
else: # both None
startpath = os.getcwd()
startfile = "{}.json".format( re.sub(r'\s+', '', self.camera_model) )
unixts = time.time()
startfile = get_stamped_filename(startfile, unixts)
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getSaveFileName(self, "Save Camera Settings", os.path.join(startpath, startfile), "JSON Text Files (*.json);;All Files (*)", options=options)
if fileName:
do_GetSaveCamConfJson(self.camera, fileName, unixts)
self.lastSavePath = fileName
self.singleStatusMsg = "saved cam config to file; see terminal stdout for more"
self.updateStatusBar()
def zoom_original(self):
self.image_display.resetZoom()
def zoom_fit_view(self):
self.image_display.fitInView()
def zoom_plus(self):
self.image_display.zoomPlus()
def zoom_minus(self):
self.image_display.zoomMinus()
def set_splitter_layout_style(self):
if self.current_splitter_style == 0:
self.set_splitter(Qt.Horizontal, self.frameview, self.frameconf)
elif self.current_splitter_style == 1:
self.set_splitter(Qt.Vertical, self.frameview, self.frameconf)
elif self.current_splitter_style == 2:
self.set_splitter(Qt.Horizontal, self.frameconf, self.frameview)
elif self.current_splitter_style == 3:
self.set_splitter(Qt.Vertical, self.frameconf, self.frameview)
def switch_splitter_layout(self):
self.current_splitter_style = (self.current_splitter_style + 1) % 4
self.set_splitter_layout_style()
def _do_preview(self):
# capture preview image
OK, camera_file = gp.gp_camera_capture_preview(self.camera)
if OK < gp.GP_OK:
print('Failed to capture preview')
self.running = False
return
self._send_file(camera_file)
def _do_preview_camnotinit(self):
# since cam not inited here, just load the cam-conf-no-cam.png/NOCAMIMG
nocamimgpath = os.path.join(THISSCRIPTDIR, NOCAMIMG)
image = Image.open(nocamimgpath)
image.load()
self.singleStatusMsg = "No cam img: {} x {}".format(image.size[0], image.size[1])
self.new_image_sig.emit(image)
def _capture_image(self):
startts = time.time()
self.running = False
self.repeatpreview_action.setChecked(False) # needed just for the menu item
self.singleStatusMsg = "Capturing image - wait ..."
self.updateStatusBar() # clear last singleStatusMsg
imgfilename = do_capture_image(self.camera)
imgpathname = os.path.realpath(imgfilename)
image = Image.open(imgpathname)
image.load()
self.new_image_sig.emit(image)
self.lastImageType = 1
self.image_display.fitInView()
endts = time.time()
self.singleStatusMsg = "Captured image: {} [{:.3f} s]".format(imgpathname, endts-startts)
self.updateStatusBar()
def _send_file(self, camera_file):
file_data = camera_file.get_data_and_size()
image = Image.open(io.BytesIO(file_data))
image.load()
self.new_image_sig.emit(image)
if self.lastImageType != 0:
self.image_display.fitInView() # reset previous offsets..
self.image_display.resetZoom() # .. then back to zoom_original for preview img
self.lastImageType = 0
@QtCore.pyqtSlot(object)
def new_image(self, image):
self.lastImageSize = image.size
w, h = image.size
image_data = image.tobytes('raw', 'RGB')
self.q_image = QtGui.QImage(image_data, w, h, QtGui.QImage.Format_RGB888)
self._draw_image()
if self.timestamp is not None:
tstampnow = time.time()
tdelta = tstampnow - self.timestamp
fps = 1.0/tdelta
self.fps = "(<{} fps)".format(MINFPS) if (fps
#endif
#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
* See https://github.com/swig/swig/issues/2090 */
# include
#endif
# undef _DEBUG
# include
# define _DEBUG 1
#else
# include
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
creating a static or dynamic library from the SWIG runtime code.
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
But only do this if strictly necessary, ie, if you have problems
with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif
#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif
/* Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
#define SWIG_POINTER_NO_NULL 0x4
#define SWIG_POINTER_CLEAR 0x8
#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
if (SWIG_IsOK(res)) {
// success code
if (SWIG_IsNewObj(res) {
...
delete *ptr;
} else {
...
}
} else {
// fail code
}
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if () {
if () {
*ptr = ;
return SWIG_NEWOBJ;
} else {
*ptr = ;
return SWIG_OLDOBJ;
}
} else {
return SWIG_BADOBJ;
}
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows returning the 'cast rank', for example, if you have this
int food(double)
int fooi(int);
and you call
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
*/
#define SWIG_OK (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ (SWIG_ERROR)
#define SWIG_OLDOBJ (SWIG_OK)
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
# define SWIG_TypeRank unsigned long
# endif
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
# define SWIG_MAXCASTRANK (2)
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
# define SWIG_AddCast(r) (r)
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
#include
#ifdef __cplusplus
extern "C" {
#endif
typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
void *clientdata; /* language specific type data */
int owndata; /* flag if the structure owns the clientdata */
} swig_type_info;
/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
swig_type_info *type; /* pointer to type that is equivalent to this type */
swig_converter_func converter; /* function to cast the void pointers */
struct swig_cast_info *next; /* pointer to next cast in linked list */
struct swig_cast_info *prev; /* pointer to the previous cast */
} swig_cast_info;
/* Structure used to store module information
* Each module generates one structure like this, and the runtime collects
* all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
size_t size; /* Number of types in this module */
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
swig_type_info **type_initial; /* Array of initially generated type structures */
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
void *clientdata; /* Language specific module data */
} swig_module_info;
/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class" == "Class", etc.
Return 0 when the two name types are equivalent, as in
strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
const char *f2, const char *l2) {
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
while ((*f1 == ' ') && (f1 != l1)) ++f1;
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
return (int)((l1 - f1) - (l2 - f2));
}
/*
Check type equivalence in a name list like ||...
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
}
/*
Check type equivalence in a name list like ||...
Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (strcmp(iter->type->name, c) == 0) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (iter->type == from) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
swig_type_info *lastty = ty;
if (!ty || !ty->dcast) return ty;
while (ty && (ty->dcast)) {
ty = (*ty->dcast)(ptr);
if (ty) lastty = ty;
}
return lastty;
}
/*
Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
return ty->name;
}
/*
Return the pretty name associated with this type,
that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
/* The "str" field contains the equivalent pretty names of the
type, separated by vertical-bar characters. Choose the last
name. It should be the most specific; a fully resolved name
but not necessarily with default template parameters expanded. */
if (!type) return NULL;
if (type->str != NULL) {
const char *last_name = type->str;
const char *s;
for (s = type->str; *s; s++)
if (*s == '|') last_name = s+1;
return last_name;
}
else
return type->name;
}
/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
}
cast = cast->next;
}
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
size_t l = 0;
size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
r = i - 1;
} else {
break;
}
} else if (compare > 0) {
l = i + 1;
}
} else {
break; /* should never happen */
}
} while (l <= r);
}
iter = iter->next;
} while (iter != end);
return 0;
}
/*
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
if (ret) {
return ret;
} else {
/* STEP 2: If the type hasn't been found, do a complete search
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
}
iter = iter->next;
} while (iter != end);
}
/* neither found a match */
return 0;
}
/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
const unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
char d = *(c++);
unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
uu = (unsigned char)((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
uu |= (unsigned char)(d - ('a'-10));
else
return (char *) 0;
*u = uu;
}
return c;
}
/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
char *r = buff;
if ((2*sizeof(void *) + 2) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,&ptr,sizeof(void *));
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
strcpy(r,name);
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
*ptr = (void *) 0;
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sizeof(void *));
}
SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
char *r = buff;
size_t lname = (name ? strlen(name) : 0);
if ((2*sz + 2 + lname) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
if (lname) {
strncpy(r,name,lname+1);
} else {
*r = 0;
}
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
memset(ptr,0,sz);
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sz);
}
#ifdef __cplusplus
}
#endif
/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
#endif
#ifndef Py_TYPE
# define Py_TYPE(op) ((op)->ob_type)
#endif
/* SWIG APIs for compatibility of both Python 2 & 3 */
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
# define SWIG_Python_str_FromFormat PyString_FromFormat
#endif
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03030000
return (char *)PyUnicode_AsUTF8(str);
#else
return PyString_AsString(str);
#endif
}
/* Was useful for Python 3.0.x-3.2.x - now provided only for compatibility
* with any uses in user interface files. */
#define SWIG_Python_str_DelForPy3(x)
SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromString(c);
#else
return PyString_FromString(c);
#endif
}
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif
/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif
/* -----------------------------------------------------------------------------
* error manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
PyObject* type = 0;
switch(code) {
case SWIG_MemoryError:
type = PyExc_MemoryError;
break;
case SWIG_IOError:
type = PyExc_IOError;
break;
case SWIG_RuntimeError:
type = PyExc_RuntimeError;
break;
case SWIG_IndexError:
type = PyExc_IndexError;
break;
case SWIG_TypeError:
type = PyExc_TypeError;
break;
case SWIG_DivisionByZero:
type = PyExc_ZeroDivisionError;
break;
case SWIG_OverflowError:
type = PyExc_OverflowError;
break;
case SWIG_SyntaxError:
type = PyExc_SyntaxError;
break;
case SWIG_ValueError:
type = PyExc_ValueError;
break;
case SWIG_SystemError:
type = PyExc_SystemError;
break;
case SWIG_AttributeError:
type = PyExc_AttributeError;
break;
default:
type = PyExc_RuntimeError;
}
return type;
}
SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
if (PyErr_Occurred())
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
PyErr_Clear();
Py_XINCREF(type);
if (tmp)
PyErr_Format(type, "%s %s", tmp, mesg);
else
PyErr_Format(type, "%s", mesg);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
PyErr_SetString(PyExc_RuntimeError, mesg);
}
}
SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
PyObject *error;
if (obj)
return 0;
error = PyErr_Occurred();
return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}
SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
if (SWIG_Python_TypeErrorOccurred(NULL)) {
/* Use existing TypeError to preserve stacktrace and enhance with given message */
PyObject *newvalue;
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
if (newvalue) {
Py_XDECREF(value);
PyErr_Restore(type, newvalue, traceback);
} else {
PyErr_Restore(type, value, traceback);
}
} else {
/* Raise TypeError using given message */
PyErr_SetString(PyExc_TypeError, message);
}
}
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
# undef SWIG_PYTHON_THREADS
# endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
# define SWIG_PYTHON_USE_GIL
# endif
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# if PY_VERSION_HEX < 0x03070000
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
# else
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# endif
# ifdef __cplusplus /* C++ code */
class SWIG_Python_Thread_Block {
bool status;
PyGILState_STATE state;
public:
void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block() { end(); }
};
class SWIG_Python_Thread_Allow {
bool status;
PyThreadState *save;
public:
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow() { end(); }
};
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
# else /* C code */
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
# endif
# else /* Old thread way, not implemented, user must provide it */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
# define SWIG_PYTHON_THREAD_END_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# endif
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
# define SWIG_PYTHON_THREAD_END_ALLOW
# endif
# endif
#else /* No thread support */
# define SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# define SWIG_PYTHON_THREAD_END_BLOCK
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# define SWIG_PYTHON_THREAD_END_ALLOW
#endif
/* -----------------------------------------------------------------------------
* Python API portion that goes into the runtime
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* Constant declarations
* ----------------------------------------------------------------------------- */
/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY 5
/* Constant information structure */
typedef struct swig_const_info {
int type;
const char *name;
long lvalue;
double dvalue;
void *pvalue;
swig_type_info **ptype;
} swig_const_info;
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* pyrun.swg
*
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* type checking.
*
* ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif
#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#endif
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif
#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
#define SWIG_fail goto fail
/* Runtime API implementation */
/* Error manipulation */
SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetObject(errtype, obj);
Py_DECREF(obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetString(errtype, msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
/* Set a constant value */
#if defined(SWIGPYTHON_BUILTIN)
SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
PyObject *s = PyString_InternFromString(key);
PyList_Append(seq, s);
Py_DECREF(s);
}
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
if (public_interface)
SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}
#else
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
}
#endif
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyList_Check(result)) {
PyObject *o2 = result;
result = PyList_New(1);
if (result) {
PyList_SET_ITEM(result, 0, o2);
} else {
Py_DECREF(obj);
return o2;
}
}
PyList_Append(result,obj);
Py_DECREF(obj);
}
return result;
}
/* Unpack the argument tuple */
SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
if (!PyTuple_Check(args)) {
if (min <= 1 && max >= 1) {
Py_ssize_t i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
}
return 2;
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
Py_ssize_t i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
for (; l < max; ++l) {
objs[l] = 0;
}
return i + 1;
}
}
}
SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
int no_kwargs = 1;
if (kwargs) {
assert(PyDict_Check(kwargs));
if (PyDict_Size(kwargs) > 0) {
PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
no_kwargs = 0;
}
}
return no_kwargs;
}
/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
/*
Helper for static pointer initialization for both C and C++ code, for example
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var) var
#else
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Python-specific SWIG API */
#define SWIG_newvarlink() SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
/* -----------------------------------------------------------------------------
* global variable support code.
* ----------------------------------------------------------------------------- */
typedef struct swig_globalvar {
char *name; /* Name of global variable */
PyObject *(*get_attr)(void); /* Return the current value */
int (*set_attr)(PyObject *); /* Set the value */
struct swig_globalvar *next;
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar *vars;
} swig_varlinkobject;
SWIGINTERN PyObject *
swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_InternFromString("");
#else
return PyString_FromString("");
#endif
}
SWIGINTERN PyObject *
swig_varlink_str(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
PyObject *str = PyUnicode_InternFromString("(");
PyObject *tail;
PyObject *joined;
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
tail = PyUnicode_FromString(var->name);
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
if (var->next) {
tail = PyUnicode_InternFromString(", ");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
}
}
tail = PyUnicode_InternFromString(")");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
#else
PyObject *str = PyString_FromString("(");
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
return str;
}
SWIGINTERN void
swig_varlink_dealloc(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
swig_globalvar *var = v->vars;
while (var) {
swig_globalvar *n = var->next;
free(var->name);
free(var);
var = n;
}
}
SWIGINTERN PyObject *
swig_varlink_getattr(PyObject *o, char *n) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
PyObject *res = NULL;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->get_attr)();
break;
}
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN int
swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
int res = 1;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->set_attr)(p);
break;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
static char varlink__doc__[] = "Swig var link object";
static PyTypeObject varlink_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"swigvarlink", /* tp_name */
sizeof(swig_varlinkobject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) swig_varlink_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc) swig_varlink_getattr, /* tp_getattr */
(setattrfunc) swig_varlink_setattr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc) swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
varlink__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
varlink_type = tmp;
type_init = 1;
if (PyType_Ready(&varlink_type) < 0)
return NULL;
}
return &varlink_type;
}
/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
if (result) {
result->vars = 0;
}
return ((PyObject*) result);
}
SWIGINTERN void
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
memcpy(gv->name, name, size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
}
}
v->vars = gv;
}
static PyObject *Swig_Globals_global = NULL;
SWIGINTERN PyObject *
SWIG_globals(void) {
if (Swig_Globals_global == NULL) {
Swig_Globals_global = SWIG_newvarlink();
}
return Swig_Globals_global;
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* Pointer declarations
* ----------------------------------------------------------------------------- */
/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
#ifdef __cplusplus
extern "C" {
#endif
/* The python void return value */
SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)
{
PyObject *none = Py_None;
Py_INCREF(none);
return none;
}
/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
PyTypeObject *pytype;
} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
int fail = data ? data->implicitconv : 0;
if (fail)
PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
return fail;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
/* the newraw method and newargs arguments used to create a new raw instance */
if (PyClass_Check(obj)) {
data->newraw = 0;
Py_INCREF(obj);
data->newargs = obj;
} else {
data->newraw = PyObject_GetAttrString(data->klass, "__new__");
if (data->newraw) {
data->newargs = PyTuple_New(1);
if (data->newargs) {
Py_INCREF(obj);
PyTuple_SET_ITEM(data->newargs, 0, obj);
} else {
Py_DECREF(data->newraw);
Py_DECREF(data->klass);
free(data);
return 0;
}
} else {
Py_INCREF(obj);
data->newargs = obj;
}
}
/* the destroy method, aka as the C++ delete method */
data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
}
if (data->destroy) {
data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
} else {
data->delargs = 0;
}
data->implicitconv = 0;
data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData *data)
{
Py_XDECREF(data->klass);
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
free(data);
}
/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
PyObject *dict;
#endif
} SwigPyObject;
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
if (!sobj->dict)
sobj->dict = PyDict_New();
Py_XINCREF(sobj->dict);
return sobj->dict;
}
#endif
SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
PyObject *val = SwigPyObject_long(v);
if (val) {
PyObject *ofmt;
PyTuple_SET_ITEM(args, 0, val);
ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
res = PyUnicode_Format(ofmt,args);
#else
res = PyString_Format(ofmt,args);
#endif
Py_DECREF(ofmt);
}
}
Py_DECREF(args);
}
return res;
}
SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v);
if (repr && v->next) {
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
PyObject *joined = PyUnicode_Concat(repr, nrep);
Py_DecRef(repr);
Py_DecRef(nrep);
repr = joined;
# else
PyString_ConcatAndDel(&repr,nrep);
# endif
} else {
Py_DecRef(repr);
repr = NULL;
}
}
return repr;
}
/* We need a version taking two PyObject* parameters so it's a valid
* PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
return SwigPyObject_repr((SwigPyObject*)v);
}
SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
PyObject* res;
if( op != Py_EQ && op != Py_NE ) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
return res;
}
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
SwigPyClientData *cd;
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
assert(cd);
assert(cd->pytype);
return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
#endif
SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
PyTypeObject *target_tp = SwigPyObject_type();
if (PyType_IsSubtype(op->ob_type, target_tp))
return 1;
return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
return (Py_TYPE(op) == SwigPyObject_type())
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
static PyObject* Swig_Capsule_global = NULL;
SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
/* PyObject_CallFunction() has the potential to silently drop
the active exception. In cases of unnamed temporary
variable or where we just finished iterating over a generator
StopIteration will be active right now, and this needs to
remain true upon return from SwigPyObject_dealloc. So save
and restore. */
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
if (data->delargs) {
/* we need to create a temporary object to carry the destroy operation */
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
if (tmp) {
res = SWIG_Python_CallFunctor(destroy, tmp);
} else {
res = 0;
}
Py_XDECREF(tmp);
} else {
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
PyObject *mself = PyCFunction_GET_SELF(destroy);
res = ((*meth)(mself, v));
}
if (!res)
PyErr_WriteUnraisable(destroy);
PyErr_Restore(type, value, traceback);
Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
else {
const char *name = SWIG_TypePrettyName(ty);
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
#endif
Py_XDECREF(Swig_Capsule_global);
}
Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
Py_XDECREF(sobj->dict);
#endif
PyObject_DEL(v);
}
SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject* v, PyObject* next)
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (!SwigPyObject_Check(next)) {
PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
((SwigPyObject *)next)->next = sobj->next;
sobj->next = next;
Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
return NULL;
} else {
SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
if (PyObject_IsTrue(val)) {
Py_DECREF(SwigPyObject_acquire(v,args));
} else {
Py_DECREF(SwigPyObject_disown(v,args));
}
}
return obj;
}
}
static PyMethodDef
swigobject_methods[] = {
{"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
{"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
{"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
{"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
{"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
{"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
{0, 0, 0, 0}
};
SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
/* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
#endif
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
(unaryfunc)0, /*nb_negative*/
(unaryfunc)0, /*nb_positive*/
(unaryfunc)0, /*nb_absolute*/
(inquiry)0, /*nb_nonzero*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
0, /*nb_coerce*/
#endif
(unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_long, /*nb_long*/
#else
0, /*nb_reserved*/
#endif
(unaryfunc)0, /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
};
static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyObject", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
(cmpfunc)SwigPyObject_compare, /* tp_compare */
#endif
(reprfunc)SwigPyObject_repr, /* tp_repr */
&SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigobject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
(richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
swigobject_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobject_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpyobject_type) != 0)
return NULL;
}
return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
sobj->own = own;
sobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
sobj->dict = 0;
#endif
if (own == SWIG_POINTER_OWN) {
/* Obtain a reference to the Python capsule wrapping the module information, so that the
* module information is correctly destroyed after all SWIG python objects have been freed
* by the GC (and corresponding destructors invoked) */
Py_XINCREF(Swig_Capsule_global);
}
}
return (PyObject *)sobj;
}
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
void *pack;
swig_type_info *ty;
size_t size;
} SwigPyPacked;
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return SWIG_Python_str_FromFormat("", result, v->ty->name);
} else {
return SWIG_Python_str_FromFormat("", v->ty->name);
}
}
SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}
SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
return ((op)->ob_type == SwigPyPacked_TypeOnce())
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
if (SwigPyPacked_Check(v)) {
SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyPacked", /* tp_name */
sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
0, /* tp_reserved in 3.0.1 */
#else
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
#endif
(reprfunc)SwigPyPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigpacked_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpypacked_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpypacked_type) != 0)
return NULL;
}
return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
memcpy(pack, ptr, size);
sobj->pack = pack;
sobj->ty = ty;
sobj->size = size;
} else {
PyObject_DEL((PyObject *) sobj);
sobj = 0;
}
}
return (PyObject *) sobj;
}
SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (SwigPyPacked_Check(obj)) {
SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
} else {
return 0;
}
}
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
static PyObject *Swig_This_global = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
if (Swig_This_global == NULL)
Swig_This_global = SWIG_Python_str_FromChar("this");
return Swig_This_global;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS
#endif
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
PyObject *obj;
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
#ifdef SWIGPYTHON_BUILTIN
(void)obj;
# ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
pyobj = PyWeakref_GET_OBJECT(pyobj);
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
# endif
return NULL;
#else
obj = 0;
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
}
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
#endif
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
return oldown;
}
}
return 0;
}
/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
int res;
SwigPyObject *sobj;
int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
if (!obj)
return SWIG_ERROR;
if (obj == Py_None && !implicit_conv) {
if (ptr)
*ptr = 0;
return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
}
res = SWIG_ERROR;
sobj = SWIG_Python_GetSwigThis(obj);
if (own)
*own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
swig_type_info *to = sobj->ty;
if (to == ty) {
/* no type cast needed */
if (ptr) *ptr = vptr;
break;
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
sobj = (SwigPyObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
if (own)
*own = *own | SWIG_CAST_NEW_MEMORY;
}
}
break;
}
}
} else {
if (ptr) *ptr = vptr;
break;
}
}
if (sobj) {
if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
res = SWIG_ERROR_RELEASE_NOT_OWNED;
} else {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
if (flags & SWIG_POINTER_CLEAR) {
sobj->ptr = 0;
}
res = SWIG_OK;
}
} else {
if (implicit_conv) {
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
PyObject *impconv;
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
impconv = SWIG_Python_CallFunctor(klass, obj);
data->implicitconv = 0;
if (PyErr_Occurred()) {
PyErr_Clear();
impconv = 0;
}
if (impconv) {
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
if (SWIG_IsOK(res)) {
if (ptr) {
*ptr = vptr;
/* transfer the ownership to 'ptr' */
iobj->own = 0;
res = SWIG_AddCast(res);
res = SWIG_AddNewMask(res);
} else {
res = SWIG_AddCast(res);
}
}
}
Py_DECREF(impconv);
}
}
}
if (!SWIG_IsOK(res) && obj == Py_None) {
if (ptr)
*ptr = 0;
if (PyErr_Occurred())
PyErr_Clear();
res = SWIG_OK;
}
}
}
return res;
}
/* Convert a function ptr value */
SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
if (!PyCFunction_Check(obj)) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
swig_cast_info *tc;
/* here we get the method pointer for callbacks */
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
if (!desc)
return SWIG_ERROR;
tc = SWIG_TypeCheck(desc,ty);
if (tc) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
} else {
return SWIG_ERROR;
}
return SWIG_OK;
}
}
/* Convert a packed pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
/* check type cast? */
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* -----------------------------------------------------------------------------
* Create a new pointer object
* ----------------------------------------------------------------------------- */
/*
Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
inst = PyObject_Call(newraw, data->newargs, NULL);
if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
Py_DECREF(inst);
inst = 0;
}
}
#else
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
}
#endif
}
} else {
#if PY_VERSION_HEX >= 0x03000000
PyObject *empty_args = PyTuple_New(0);
if (empty_args) {
PyObject *empty_kwargs = PyDict_New();
if (empty_kwargs) {
inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
Py_DECREF(empty_kwargs);
if (inst) {
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
} else {
PyType_Modified(Py_TYPE(inst));
}
}
}
Py_DECREF(empty_args);
}
#else
PyObject *dict = PyDict_New();
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
}
#endif
}
return inst;
}
SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
return PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
return -1;
}
}
#endif
return PyObject_SetAttr(inst, SWIG_This(), swig_this);
}
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
return NULL;
} else {
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
} else {
if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
return NULL;
}
return SWIG_Py_Void();
}
}
/* Create a new pointer object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
SwigPyClientData *clientdata;
PyObject * robj;
int own;
if (!ptr)
return SWIG_Py_Void();
clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
if (clientdata && clientdata->pytype) {
SwigPyObject *newobj;
if (flags & SWIG_BUILTIN_TP_INIT) {
newobj = (SwigPyObject*) self;
if (newobj->ptr) {
PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
while (newobj->next)
newobj = (SwigPyObject *) newobj->next;
newobj->next = next_self;
newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
newobj->dict = 0;
#endif
}
} else {
newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
if (newobj) {
newobj->dict = 0;
}
#endif
}
if (newobj) {
newobj->ptr = ptr;
newobj->ty = type;
newobj->own = own;
newobj->next = 0;
return (PyObject*) newobj;
}
return SWIG_Py_Void();
}
assert(!(flags & SWIG_BUILTIN_TP_INIT));
robj = SwigPyObject_New(ptr, type, own);
if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
Py_DECREF(robj);
robj = inst;
}
return robj;
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
* Get type list
* -----------------------------------------------------------------------------*/
#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif
static PyObject *Swig_TypeCache_global = NULL;
/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
if (Swig_TypeCache_global == NULL) {
Swig_TypeCache_global = PyDict_New();
}
return Swig_TypeCache_global;
}
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
}
#else
void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
}
#endif
return (swig_module_info *) type_pointer;
}
static int interpreter_counter = 0; // how many (sub-)interpreters are using swig_module's types
SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
swig_type_info **types = swig_module->types;
size_t i;
if (--interpreter_counter != 0) // another sub-interpreter may still be using the swig_module's types
return;
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
ty->clientdata = 0;
if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
Swig_This_global = NULL;
Py_DECREF(SWIG_globals());
Swig_Globals_global = NULL;
Py_DECREF(SWIG_Python_TypeCache());
Swig_TypeCache_global = NULL;
Swig_Capsule_global = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
/* Add a dummy module object into sys.modules */
PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && module) {
if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
++interpreter_counter;
Swig_Capsule_global = pointer;
} else {
Py_DECREF(pointer);
}
} else {
Py_XDECREF(pointer);
}
}
SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
PyObject *key = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
} else {
swig_module_info *swig_module = SWIG_GetModule(0);
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
obj = PyCapsule_New((void*) descriptor, NULL, NULL);
if (obj) {
PyDict_SetItem(cache, key, obj);
Py_DECREF(obj);
}
}
}
Py_DECREF(key);
return descriptor;
}
/*
For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION 0
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
const char *errmesg = tmp ? tmp : "Invalid error message";
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, errmesg);
} else {
PyErr_Format(type, "%s %s", errmesg, mesg);
}
Py_DECREF(old_str);
}
return 1;
} else {
return 0;
}
}
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
if (PyErr_Occurred()) {
/* add information about failing argument */
char mesg[256];
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
} else {
return 0;
}
}
SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : "";
}
SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
if (obj && SwigPyObject_Check(obj)) {
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
type, otype);
return;
}
} else
#endif
{
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
}
Py_XDECREF(str);
return;
}
}
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
} else {
PyErr_Format(PyExc_TypeError, "unexpected type is received");
}
}
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
}
return result;
}
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
PyTypeObject *tp = obj->ob_type;
PyObject *descr;
PyObject *encoded_name;
descrsetfunc f;
int res = -1;
# ifdef Py_USING_UNICODE
if (PyString_Check(name)) {
name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
if (!name)
return -1;
} else if (!PyUnicode_Check(name))
# else
if (!PyString_Check(name))
# endif
{
PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
return -1;
} else {
Py_INCREF(name);
}
if (!tp->tp_dict) {
if (PyType_Ready(tp) != 0)
goto done;
}
descr = _PyType_Lookup(tp, name);
f = NULL;
if (descr != NULL)
f = descr->ob_type->tp_descr_set;
if (!f) {
if (PyString_Check(name)) {
encoded_name = name;
Py_INCREF(name);
} else {
encoded_name = PyUnicode_AsUTF8String(name);
if (!encoded_name)
goto done;
}
PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
Py_DECREF(encoded_name);
} else {
res = f(descr, obj, value);
}
done:
Py_DECREF(name);
return res;
}
#endif
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN Py_hash_t
SwigPyObject_hash(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
void *ptr = sobj->ptr;
#if PY_VERSION_HEX < 0x03020000
return (Py_hash_t)(Py_ssize_t)ptr;
#else
return (Py_hash_t)ptr;
#endif
}
SWIGINTERN Py_hash_t
SWIG_PyNumber_AsPyHash(PyObject *obj) {
Py_hash_t result = -1;
#if PY_VERSION_HEX < 0x03020000
if (PyInt_Check(obj))
result = PyInt_AsLong(obj);
else if (PyLong_Check(obj))
result = PyLong_AsLong(obj);
#else
if (PyNumber_Check(obj))
result = PyNumber_AsSsize_t(obj, NULL);
#endif
else
PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
return PyErr_Occurred() ? -1 : result;
}
SWIGINTERN int
SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
return -1;
}
SWIGINTERN void
SwigPyBuiltin_BadDealloc(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
if (sobj->own) {
PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", obj->ob_type->tp_name);
}
}
typedef struct {
PyCFunction get;
PyCFunction set;
} SwigPyGetSet;
SWIGINTERN PyObject *
SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
tuple = PyTuple_New(0);
assert(tuple);
result = (*getset->get)(obj, tuple);
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyObject *
SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
result = (*getset->get)(obj, NULL);
return result;
}
SWIGINTERN int
SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(val);
PyTuple_SET_ITEM(tuple, 0, val);
result = (*getset->set)(obj, tuple);
Py_DECREF(tuple);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN int
SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
result = (*getset->set)(obj, val);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN void
SwigPyStaticVar_dealloc(PyDescrObject *descr) {
PyObject_GC_UnTrack(descr);
Py_XDECREF(PyDescr_TYPE(descr));
Py_XDECREF(PyDescr_NAME(descr));
PyObject_GC_Del(descr);
}
SWIGINTERN PyObject *
SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromFormat("", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
return PyString_FromFormat("", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
}
SWIGINTERN int
SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
PyDescrObject *descr;
descr = (PyDescrObject *)self;
Py_VISIT((PyObject*) PyDescr_TYPE(descr));
return 0;
}
SWIGINTERN PyObject *
SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
if (descr->d_getset->get != NULL)
return descr->d_getset->get(obj, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return NULL;
}
SWIGINTERN int
SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
if (descr->d_getset->set != NULL)
return descr->d_getset->set(obj, value, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return -1;
}
SWIGINTERN int
SwigPyObjectType_setattro(PyObject *typeobject, PyObject *name, PyObject *value) {
PyObject *attribute;
PyTypeObject *type;
descrsetfunc local_set;
assert(PyType_Check(typeobject));
type = (PyTypeObject *)typeobject;
attribute = _PyType_Lookup(type, name);
if (attribute != NULL) {
/* Implement descriptor functionality, if any */
local_set = attribute->ob_type->tp_descr_set;
if (local_set != NULL)
return local_set(attribute, (PyObject *)type, value);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
} else {
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
}
return -1;
}
SWIGINTERN PyTypeObject*
SwigPyStaticVar_Type(void) {
static PyTypeObject staticvar_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"swig_static_var_getset_descriptor", /* tp_name */
sizeof(PyGetSetDescrObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyStaticVar_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
(reprfunc)SwigPyStaticVar_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
0, /* tp_doc */
SwigPyStaticVar_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc)SwigPyStaticVar_get, /* tp_descr_get */
(descrsetfunc)SwigPyStaticVar_set, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
staticvar_type = tmp;
type_init = 1;
if (PyType_Ready(&staticvar_type) < 0)
return NULL;
}
return &staticvar_type;
}
SWIGINTERN PyTypeObject*
SwigPyObjectType(void) {
static char swigpyobjecttype_doc[] = "Metaclass for SWIG wrapped types";
static PyTypeObject swigpyobjecttype_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"SwigPyObjectType", /* tp_name */
PyType_Type.tp_basicsize, /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
SwigPyObjectType_setattro, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
swigpyobjecttype_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobjecttype_type = tmp;
type_init = 1;
swigpyobjecttype_type.tp_base = &PyType_Type;
if (PyType_Ready(&swigpyobjecttype_type) < 0)
return NULL;
}
return &swigpyobjecttype_type;
}
SWIGINTERN PyGetSetDescrObject *
SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
PyGetSetDescrObject *descr;
descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
assert(descr);
Py_XINCREF(type);
PyDescr_TYPE(descr) = type;
PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
descr->d_getset = getset;
if (PyDescr_NAME(descr) == NULL) {
Py_DECREF(descr);
descr = NULL;
}
return descr;
}
SWIGINTERN void
SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
Py_ssize_t base_count = 0;
PyTypeObject **b;
PyObject *tuple;
Py_ssize_t i;
if (!bases[0]) {
bases[0] = SwigPyObject_type();
bases[1] = NULL;
}
type->tp_base = bases[0];
Py_INCREF((PyObject *)bases[0]);
for (b = bases; *b != NULL; ++b)
++base_count;
tuple = PyTuple_New(base_count);
for (i = 0; i < base_count; ++i) {
Py_INCREF((PyObject *)bases[i]);
PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
}
type->tp_bases = tuple;
}
SWIGINTERN PyObject *
SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
PyObject *result;
result = (PyObject *)SWIG_Python_GetSwigThis(self);
Py_XINCREF(result);
return result;
}
SWIGINTERN void
SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
{
#if PY_VERSION_HEX >= 0x030900a4
Py_SET_TYPE(type, metatype);
#else
Py_TYPE(type) = metatype;
#endif
}
/* Start of callback function macros for use in PyTypeObject */
typedef PyObject *(*SwigPyWrapperFunction)(PyObject *, PyObject *);
#define SWIGPY_UNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_unaryfunc_closure(PyObject *a) { \
return SwigPyBuiltin_unaryfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_unaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper) \
SWIGINTERN void \
wrapper##_destructor_closure(PyObject *a) { \
SwigPyBuiltin_destructor_closure(wrapper, #wrapper, a); \
}
SWIGINTERN void
SwigPyBuiltin_destructor_closure(SwigPyWrapperFunction wrapper, const char *wrappername, PyObject *a) {
SwigPyObject *sobj;
sobj = (SwigPyObject *)a;
Py_XDECREF(sobj->dict);
if (sobj->own) {
PyObject *o;
PyObject *type = 0, *value = 0, *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
o = wrapper(a, NULL);
if (!o) {
PyObject *deallocname = PyString_FromString(wrappername);
PyErr_WriteUnraisable(deallocname);
Py_DECREF(deallocname);
}
PyErr_Restore(type, value, traceback);
Py_XDECREF(o);
}
if (PyType_IS_GC(a->ob_type)) {
PyObject_GC_Del(a);
} else {
PyObject_Del(a);
}
}
#define SWIGPY_INQUIRY_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_inquiry_closure(PyObject *a) { \
return SwigPyBuiltin_inquiry_closure(wrapper, a); \
}
SWIGINTERN int
SwigPyBuiltin_inquiry_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
int result;
pyresult = wrapper(a, NULL);
result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_GETITERFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_getiterfunc_closure(PyObject *a) { \
return SwigPyBuiltin_getiterfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_getiterfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_BINARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_binaryfunc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_binaryfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_binaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
typedef ternaryfunc ternarycallfunc;
#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternaryfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternaryfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternarycallfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternarycallfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternarycallfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
(void) c;
return wrapper(a, b);
}
#define SWIGPY_LENFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_ssize_t \
wrapper##_lenfunc_closure(PyObject *a) { \
return SwigPyBuiltin_lenfunc_closure(wrapper, a); \
}
SWIGINTERN Py_ssize_t
SwigPyBuiltin_lenfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *resultobj;
Py_ssize_t result;
resultobj = wrapper(a, NULL);
result = PyNumber_AsSsize_t(resultobj, NULL);
Py_DECREF(resultobj);
return result;
}
#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizessizeargfunc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) { \
return SwigPyBuiltin_ssizessizeargfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizessizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizessizeobjargproc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
return SwigPyBuiltin_ssizessizeobjargproc_closure(wrapper, a, b, c, d); \
}
SWIGINTERN int
SwigPyBuiltin_ssizessizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(d ? 3 : 2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
if (d) {
Py_INCREF(d);
PyTuple_SET_ITEM(tuple, 2, d);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_DECREF(tuple);
Py_XDECREF(resultobj);
return result;
}
#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_funpack_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_funpack_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *arg, *result;
arg = _PyLong_FromSsize_t(b);
result = wrapper(a, arg);
Py_DECREF(arg);
return result;
}
#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizeobjargproc_closure(PyObject *a, Py_ssize_t b, PyObject *c) { \
return SwigPyBuiltin_ssizeobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_ssizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
PyObject *tuple;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
pyresult = wrapper(a, tuple);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_funpack_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_funpack_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
pyresult = wrapper(a, b);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjargproc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_objobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_objobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(c ? 2 : 1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
if (c) {
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_REPRFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_reprfunc_closure(PyObject *a) { \
return SwigPyBuiltin_reprfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_reprfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_HASHFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_hash_t \
wrapper##_hashfunc_closure(PyObject *a) { \
return SwigPyBuiltin_hashfunc_closure(wrapper, a); \
}
SWIGINTERN Py_hash_t
SwigPyBuiltin_hashfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
Py_hash_t result;
pyresult = wrapper(a, NULL);
if (!pyresult)
return -1;
result = SWIG_PyNumber_AsPyHash(pyresult);
Py_DECREF(pyresult);
return result;
}
#define SWIGPY_ITERNEXTFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_iternextfunc_closure(PyObject *a) { \
return SwigPyBuiltin_iternextfunc_closure(wrapper, a);\
}
SWIGINTERN PyObject *
SwigPyBuiltin_iternextfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
/* End of callback function macros for use in PyTypeObject */
#ifdef __cplusplus
}
#endif
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_CameraAbilities swig_types[0]
#define SWIGTYPE_p_CameraDriverStatus swig_types[1]
#define SWIGTYPE_p_CameraFileOperation swig_types[2]
#define SWIGTYPE_p_CameraFolderOperation swig_types[3]
#define SWIGTYPE_p_CameraOperation swig_types[4]
#define SWIGTYPE_p_GPPortType swig_types[5]
#define SWIGTYPE_p_GphotoDeviceType swig_types[6]
#define SWIGTYPE_p_SwigPyObject swig_types[7]
#define SWIGTYPE_p__CameraAbilitiesList swig_types[8]
#define SWIGTYPE_p__CameraList swig_types[9]
#define SWIGTYPE_p__GPContext swig_types[10]
#define SWIGTYPE_p__GPContextFeedback swig_types[11]
#define SWIGTYPE_p__GPPortInfo swig_types[12]
#define SWIGTYPE_p__GPPortInfoList swig_types[13]
#define SWIGTYPE_p_char swig_types[14]
#define SWIGTYPE_p_p__CameraAbilitiesList swig_types[15]
static swig_type_info *swig_types[17];
static swig_module_info swig_module = {swig_types, 16, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery
/*-----------------------------------------------
@(target):= _abilities_list.so
------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_init PyInit__abilities_list
#else
# define SWIG_init init_abilities_list
#endif
#define SWIG_name "_abilities_list"
#define SWIG_as_voidptr(a) (void *)((const void *)(a))
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
#include
#include "gphoto2/gphoto2.h"
PyObject *PyExc_GPhoto2Error = NULL;
SWIGINTERN struct _CameraAbilitiesList *new__CameraAbilitiesList(void){
struct _CameraAbilitiesList *result;
int error = gp_abilities_list_new(&result);
if (error < GP_OK)
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
return result;
}
SWIGINTERN void delete__CameraAbilitiesList(struct _CameraAbilitiesList *self){
int error = gp_abilities_list_free(self);
if (error < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
}
SWIGINTERN int _CameraAbilitiesList___len__(struct _CameraAbilitiesList *self){
int result = gp_abilities_list_count (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
return result;
}
SWIGINTERNINLINE PyObject*
SWIG_From_int (int value)
{
return PyInt_FromLong((long) value);
}
#include
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
# define LLONG_MAX __LONG_LONG_MAX__
# define LLONG_MIN (-LLONG_MAX - 1LL)
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif
SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
int res = SWIG_TypeError;
if (PyFloat_Check(obj)) {
if (val) *val = PyFloat_AsDouble(obj);
return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
} else if (PyInt_Check(obj)) {
if (val) *val = (double) PyInt_AsLong(obj);
return SWIG_OK;
#endif
} else if (PyLong_Check(obj)) {
double v = PyLong_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
double d = PyFloat_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = d;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
} else {
PyErr_Clear();
}
}
}
#endif
return res;
}
#include
#include
SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
double x = *d;
if ((min <= x && x <= max)) {
double fx = floor(x);
double cx = ceil(x);
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
if ((errno == EDOM) || (errno == ERANGE)) {
errno = 0;
} else {
double summ, reps, diff;
if (rd < x) {
diff = x - rd;
} else if (rd > x) {
diff = rd - x;
} else {
return 1;
}
summ = rd + x;
reps = diff/summ;
if (reps < 8*DBL_EPSILON) {
*d = rd;
return 1;
}
}
}
return 0;
}
SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
} else
#endif
if (PyLong_Check(obj)) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
return SWIG_OverflowError;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
long v = PyInt_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
if (val) *val = (long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
long v;
int res = SWIG_AsVal_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v < INT_MIN || v > INT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = (int)(v);
}
}
return res;
}
SWIGINTERN void _CameraAbilitiesList___getitem__(struct _CameraAbilitiesList *self,int idx,CameraAbilities *abilities){
if (idx < 0 || idx >= gp_abilities_list_count(self)) {
PyErr_SetString(PyExc_IndexError, "CameraAbilitiesList index out of range");
return;
}
{
int error = gp_abilities_list_get_abilities(self, idx, abilities);
if (error < GP_OK) {
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
return;
}
}
}
SWIGINTERN void _CameraAbilitiesList_load(struct _CameraAbilitiesList *self,GPContext *context){
int result = gp_abilities_list_load (self, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
static int init = 0;
static swig_type_info* info = 0;
if (!init) {
info = SWIG_TypeQuery("_p_char");
init = 1;
}
return info;
}
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (PyBytes_Check(obj))
#else
if (PyUnicode_Check(obj))
#endif
#else
if (PyString_Check(obj))
#endif
{
char *cstr; Py_ssize_t len;
int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (!alloc && cptr) {
/* We can't allow converting without allocation, since the internal
representation of string in Python 3 is UCS-2/UCS-4 but we require
a UTF-8 representation.
TODO(bhy) More detailed explanation */
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (alloc)
*alloc = SWIG_NEWOBJ;
#endif
if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#else
if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#endif
if (cptr) {
if (alloc) {
if (*alloc == SWIG_NEWOBJ) {
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
*alloc = SWIG_NEWOBJ;
} else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
}
} else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
*cptr = PyBytes_AsString(obj);
#else
assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
*cptr = SWIG_Python_str_AsChar(obj);
if (!*cptr)
ret = SWIG_TypeError;
#endif
}
}
if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
Py_XDECREF(obj);
#endif
return ret;
} else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
if (PyUnicode_Check(obj)) {
char *cstr; Py_ssize_t len;
if (!alloc && cptr) {
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
if (cptr) {
if (alloc) *alloc = SWIG_NEWOBJ;
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
}
if (psize) *psize = len + 1;
Py_XDECREF(obj);
return SWIG_OK;
} else {
Py_XDECREF(obj);
}
}
#endif
#endif
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
if (pchar_descriptor) {
void* vptr = 0;
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
if (cptr) *cptr = (char *) vptr;
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
if (alloc) *alloc = SWIG_OLDOBJ;
return SWIG_OK;
}
}
}
return SWIG_TypeError;
}
SWIGINTERN void _CameraAbilitiesList_load_dir(struct _CameraAbilitiesList *self,char const *dir,GPContext *context){
int result = gp_abilities_list_load_dir (self, dir, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraAbilitiesList_reset(struct _CameraAbilitiesList *self){
int result = gp_abilities_list_reset (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraAbilitiesList_detect(struct _CameraAbilitiesList *self,GPPortInfoList *info_list,CameraList *l,GPContext *context){
int result = gp_abilities_list_detect (self, info_list, l, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraAbilitiesList_append(struct _CameraAbilitiesList *self,CameraAbilities abilities){
int result = gp_abilities_list_append (self, abilities);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN int _CameraAbilitiesList_count(struct _CameraAbilitiesList *self){
int result = gp_abilities_list_count (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
return result;
}
SWIGINTERN int _CameraAbilitiesList_lookup_model(struct _CameraAbilitiesList *self,char const *model){
int result = gp_abilities_list_lookup_model (self, model);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
return result;
}
SWIGINTERN void _CameraAbilitiesList_get_abilities(struct _CameraAbilitiesList *self,int index,CameraAbilities *abilities){
int result = gp_abilities_list_get_abilities (self, index, abilities);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
#if GPHOTO2_VERSION < 0x02051e00
static int gp_init_localedir(const char *localedir) {
return GP_ERROR_NOT_SUPPORTED;
}
#endif
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
if (carray) {
if (size > INT_MAX) {
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
return pchar_descriptor ?
SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
} else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
#else
return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
#endif
#else
return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
#endif
}
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN size_t
SWIG_strnlen(const char* s, size_t maxlen)
{
const char *p;
for (p = s; maxlen-- && *p; p++)
;
return p - s;
}
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtr(const char *cptr)
{
return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN int _wrap_new_CameraAbilitiesList(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
struct _CameraAbilitiesList *result = 0 ;
(void)self;
if (!SWIG_Python_CheckNoKeywords(kwargs, "new_CameraAbilitiesList")) SWIG_fail;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "new_CameraAbilitiesList takes no arguments");
{
result = (struct _CameraAbilitiesList *)new__CameraAbilitiesList();
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraAbilitiesList, SWIG_BUILTIN_INIT | 0 );
return resultobj == Py_None ? -1 : 0;
fail:
return -1;
}
SWIGINTERN PyObject *_wrap_delete_CameraAbilitiesList(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraAbilitiesList *arg1 = (struct _CameraAbilitiesList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CameraAbilitiesList takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraAbilitiesList, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraAbilitiesList" "', argument " "1"" of type '" "struct _CameraAbilitiesList *""'");
}
arg1 = (struct _CameraAbilitiesList *)(argp1);
{
delete__CameraAbilitiesList(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilitiesList___len__(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraAbilitiesList *arg1 = (struct _CameraAbilitiesList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilitiesList___len__ takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilitiesList___len__" "', argument " "1"" of type '" "struct _CameraAbilitiesList *""'");
}
arg1 = (struct _CameraAbilitiesList *)(argp1);
{
result = (int)_CameraAbilitiesList___len__(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilitiesList___getitem__(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraAbilitiesList *arg1 = (struct _CameraAbilitiesList *) 0 ;
int arg2 ;
CameraAbilities *arg3 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
{
arg3 = (CameraAbilities *)calloc(1, sizeof(CameraAbilities));
if (arg3 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraAbilities");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "CameraAbilitiesList___getitem__", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilitiesList___getitem__" "', argument " "1"" of type '" "struct _CameraAbilitiesList *""'");
}
arg1 = (struct _CameraAbilitiesList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraAbilitiesList___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
{
_CameraAbilitiesList___getitem__(arg1,arg2,arg3);
if (PyErr_Occurred() != NULL) goto fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg3, SWIGTYPE_p_CameraAbilities, SWIG_POINTER_OWN));
arg3 = NULL;
}
{
free(arg3);
}
return resultobj;
fail:
{
free(arg3);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilitiesList_load(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraAbilitiesList *arg1 = (struct _CameraAbilitiesList *) 0 ;
GPContext *arg2 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj1 = 0 ;
{
arg2 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "CameraAbilitiesList_load", 0, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilitiesList_load" "', argument " "1"" of type '" "struct _CameraAbilitiesList *""'");
}
arg1 = (struct _CameraAbilitiesList *)(argp1);
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraAbilitiesList_load" "', argument " "2"" of type '" "GPContext *""'");
}
arg2 = (GPContext *)(argp2);
}
{
_CameraAbilitiesList_load(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilitiesList_load_dir(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraAbilitiesList *arg1 = (struct _CameraAbilitiesList *) 0 ;
char *arg2 = (char *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
arg3 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "CameraAbilitiesList_load_dir", 1, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilitiesList_load_dir" "', argument " "1"" of type '" "struct _CameraAbilitiesList *""'");
}
arg1 = (struct _CameraAbilitiesList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraAbilitiesList_load_dir" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CameraAbilitiesList_load_dir" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
_CameraAbilitiesList_load_dir(arg1,(char const *)arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilitiesList_reset(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraAbilitiesList *arg1 = (struct _CameraAbilitiesList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilitiesList_reset takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilitiesList_reset" "', argument " "1"" of type '" "struct _CameraAbilitiesList *""'");
}
arg1 = (struct _CameraAbilitiesList *)(argp1);
{
_CameraAbilitiesList_reset(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilitiesList_detect(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraAbilitiesList *arg1 = (struct _CameraAbilitiesList *) 0 ;
GPPortInfoList *arg2 = (GPPortInfoList *) 0 ;
CameraList *arg3 = (CameraList *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
arg4 = NULL;
}
{
int error = gp_list_new(&arg3);
if (error < GP_OK) {
arg3 = NULL;
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "CameraAbilitiesList_detect", 1, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilitiesList_detect" "', argument " "1"" of type '" "struct _CameraAbilitiesList *""'");
}
arg1 = (struct _CameraAbilitiesList *)(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraAbilitiesList_detect" "', argument " "2"" of type '" "GPPortInfoList *""'");
}
arg2 = (GPPortInfoList *)(argp2);
if (obj2) {
res4 = SWIG_ConvertPtr(obj2, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CameraAbilitiesList_detect" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
_CameraAbilitiesList_detect(arg1,arg2,arg3,arg4);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg3, SWIGTYPE_p__CameraList, SWIG_POINTER_OWN));
arg3 = NULL;
}
{
if (arg3 != NULL) {
gp_list_unref(arg3);
}
}
return resultobj;
fail:
{
if (arg3 != NULL) {
gp_list_unref(arg3);
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilitiesList_append(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraAbilitiesList *arg1 = (struct _CameraAbilitiesList *) 0 ;
CameraAbilities arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraAbilitiesList_append", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilitiesList_append" "', argument " "1"" of type '" "struct _CameraAbilitiesList *""'");
}
arg1 = (struct _CameraAbilitiesList *)(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CameraAbilities, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraAbilitiesList_append" "', argument " "2"" of type '" "CameraAbilities""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CameraAbilitiesList_append" "', argument " "2"" of type '" "CameraAbilities""'");
} else {
arg2 = *((CameraAbilities *)(argp2));
}
}
{
if (PyErr_WarnEx(PyExc_DeprecationWarning,"_CameraAbilitiesList::append"" is deprecated and"
" will be removed in a future release", 1) < 0) SWIG_fail;
_CameraAbilitiesList_append(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilitiesList_count(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraAbilitiesList *arg1 = (struct _CameraAbilitiesList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilitiesList_count takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilitiesList_count" "', argument " "1"" of type '" "struct _CameraAbilitiesList *""'");
}
arg1 = (struct _CameraAbilitiesList *)(argp1);
{
result = (int)_CameraAbilitiesList_count(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilitiesList_lookup_model(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraAbilitiesList *arg1 = (struct _CameraAbilitiesList *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraAbilitiesList_lookup_model", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilitiesList_lookup_model" "', argument " "1"" of type '" "struct _CameraAbilitiesList *""'");
}
arg1 = (struct _CameraAbilitiesList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraAbilitiesList_lookup_model" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
{
result = (int)_CameraAbilitiesList_lookup_model(arg1,(char const *)arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilitiesList_get_abilities(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraAbilitiesList *arg1 = (struct _CameraAbilitiesList *) 0 ;
int arg2 ;
CameraAbilities *arg3 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
{
arg3 = (CameraAbilities *)calloc(1, sizeof(CameraAbilities));
if (arg3 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraAbilities");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "CameraAbilitiesList_get_abilities", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilitiesList_get_abilities" "', argument " "1"" of type '" "struct _CameraAbilitiesList *""'");
}
arg1 = (struct _CameraAbilitiesList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraAbilitiesList_get_abilities" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
{
_CameraAbilitiesList_get_abilities(arg1,arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg3, SWIGTYPE_p_CameraAbilities, SWIG_POINTER_OWN));
arg3 = NULL;
}
{
free(arg3);
}
return resultobj;
fail:
{
free(arg3);
}
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraAbilitiesList) /* defines _wrap_delete_CameraAbilitiesList_destructor_closure */
SWIGPY_LENFUNC_CLOSURE(_wrap_CameraAbilitiesList___len__) /* defines _wrap_CameraAbilitiesList___len___lenfunc_closure */
SWIGPY_SSIZEARGFUNC_CLOSURE(_wrap_CameraAbilitiesList___getitem__) /* defines _wrap_CameraAbilitiesList___getitem___ssizeargfunc_closure */
SWIGINTERN PyObject *_wrap_CameraAbilities_model_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_model_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_model_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (char *)(char *) ((arg1)->model);
{
size_t size = SWIG_strnlen(result, 128);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_status_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraDriverStatus result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_status_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_status_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (CameraDriverStatus) ((arg1)->status);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_port_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
GPPortType result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_port_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_port_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (GPPortType) ((arg1)->port);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_speed_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_speed_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_speed_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int *)(int *) ((arg1)->speed);
{
int *value = result;
resultobj = PyList_New(0);
while (*value) {
PyObject* temp = PyInt_FromLong(*value);
PyList_Append(resultobj, temp);
Py_DECREF(temp);
value++;
}
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_operations_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraOperation result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_operations_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_operations_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (CameraOperation) ((arg1)->operations);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_file_operations_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraFileOperation result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_file_operations_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_file_operations_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (CameraFileOperation) ((arg1)->file_operations);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_folder_operations_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraFolderOperation result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_folder_operations_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_folder_operations_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (CameraFolderOperation) ((arg1)->folder_operations);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_usb_vendor_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_usb_vendor_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_usb_vendor_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int) ((arg1)->usb_vendor);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_usb_product_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_usb_product_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_usb_product_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int) ((arg1)->usb_product);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_usb_class_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_usb_class_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_usb_class_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int) ((arg1)->usb_class);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_usb_subclass_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_usb_subclass_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_usb_subclass_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int) ((arg1)->usb_subclass);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_usb_protocol_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_usb_protocol_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_usb_protocol_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int) ((arg1)->usb_protocol);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_library_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_library_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_library_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (char *)(char *) ((arg1)->library);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_id_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_id_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_id_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (char *)(char *) ((arg1)->id);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_device_type_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
GphotoDeviceType result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_device_type_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_device_type_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (GphotoDeviceType) ((arg1)->device_type);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_reserved2_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_reserved2_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_reserved2_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int) ((arg1)->reserved2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_reserved3_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_reserved3_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_reserved3_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int) ((arg1)->reserved3);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_reserved4_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_reserved4_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_reserved4_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int) ((arg1)->reserved4);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_reserved5_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_reserved5_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_reserved5_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int) ((arg1)->reserved5);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_reserved6_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_reserved6_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_reserved6_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int) ((arg1)->reserved6);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_reserved7_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_reserved7_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_reserved7_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int) ((arg1)->reserved7);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraAbilities_reserved8_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraAbilities_reserved8_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraAbilities_reserved8_get" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
result = (int) ((arg1)->reserved8);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CameraAbilities(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilities *arg1 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CameraAbilities takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraAbilities, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraAbilities" "', argument " "1"" of type '" "CameraAbilities *""'");
}
arg1 = (CameraAbilities *)(argp1);
free((char *) arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraAbilities) /* defines _wrap_delete_CameraAbilities_destructor_closure */
SWIGINTERN PyObject *_wrap_gp_abilities_list_new(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilitiesList **arg1 = (CameraAbilitiesList **) 0 ;
CameraAbilitiesList *temp1 ;
int result;
{
temp1 = NULL;
arg1 = &temp1;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_abilities_list_new", 0, 0)) SWIG_fail;
result = (int)gp_abilities_list_new(arg1);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg1, SWIGTYPE_p__CameraAbilitiesList, SWIG_POINTER_OWN));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_abilities_list_load(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilitiesList *arg1 = (CameraAbilitiesList *) 0 ;
GPContext *arg2 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
arg2 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_abilities_list_load", 1, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_abilities_list_load" "', argument " "1"" of type '" "CameraAbilitiesList *""'");
}
arg1 = (CameraAbilitiesList *)(argp1);
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_abilities_list_load" "', argument " "2"" of type '" "GPContext *""'");
}
arg2 = (GPContext *)(argp2);
}
result = (int)gp_abilities_list_load(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_abilities_list_load_dir(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilitiesList *arg1 = (CameraAbilitiesList *) 0 ;
char *arg2 = (char *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
{
arg3 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_abilities_list_load_dir", 2, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_abilities_list_load_dir" "', argument " "1"" of type '" "CameraAbilitiesList *""'");
}
arg1 = (CameraAbilitiesList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_abilities_list_load_dir" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_abilities_list_load_dir" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
result = (int)gp_abilities_list_load_dir(arg1,(char const *)arg2,arg3);
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_abilities_list_reset(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilitiesList *arg1 = (CameraAbilitiesList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_abilities_list_reset", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_abilities_list_reset" "', argument " "1"" of type '" "CameraAbilitiesList *""'");
}
arg1 = (CameraAbilitiesList *)(argp1);
result = (int)gp_abilities_list_reset(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_abilities_list_detect(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilitiesList *arg1 = (CameraAbilitiesList *) 0 ;
GPPortInfoList *arg2 = (GPPortInfoList *) 0 ;
CameraList *arg3 = (CameraList *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
{
arg4 = NULL;
}
{
int error = gp_list_new(&arg3);
if (error < GP_OK) {
arg3 = NULL;
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_abilities_list_detect", 2, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_abilities_list_detect" "', argument " "1"" of type '" "CameraAbilitiesList *""'");
}
arg1 = (CameraAbilitiesList *)(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_abilities_list_detect" "', argument " "2"" of type '" "GPPortInfoList *""'");
}
arg2 = (GPPortInfoList *)(argp2);
if (obj2) {
res4 = SWIG_ConvertPtr(obj2, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gp_abilities_list_detect" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
result = (int)gp_abilities_list_detect(arg1,arg2,arg3,arg4);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg3, SWIGTYPE_p__CameraList, SWIG_POINTER_OWN));
arg3 = NULL;
}
{
if (arg3 != NULL) {
gp_list_unref(arg3);
}
}
return resultobj;
fail:
{
if (arg3 != NULL) {
gp_list_unref(arg3);
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_abilities_list_append(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilitiesList *arg1 = (CameraAbilitiesList *) 0 ;
CameraAbilities arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_abilities_list_append", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_abilities_list_append" "', argument " "1"" of type '" "CameraAbilitiesList *""'");
}
arg1 = (CameraAbilitiesList *)(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CameraAbilities, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_abilities_list_append" "', argument " "2"" of type '" "CameraAbilities""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gp_abilities_list_append" "', argument " "2"" of type '" "CameraAbilities""'");
} else {
arg2 = *((CameraAbilities *)(argp2));
}
}
{
if (PyErr_WarnEx(PyExc_DeprecationWarning,"gp_abilities_list_append"" is deprecated and"
" will be removed in a future release", 1) < 0) SWIG_fail;
result = (int)gp_abilities_list_append(arg1,arg2);
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_abilities_list_count(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilitiesList *arg1 = (CameraAbilitiesList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_abilities_list_count", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_abilities_list_count" "', argument " "1"" of type '" "CameraAbilitiesList *""'");
}
arg1 = (CameraAbilitiesList *)(argp1);
result = (int)gp_abilities_list_count(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_abilities_list_lookup_model(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilitiesList *arg1 = (CameraAbilitiesList *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_abilities_list_lookup_model", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_abilities_list_lookup_model" "', argument " "1"" of type '" "CameraAbilitiesList *""'");
}
arg1 = (CameraAbilitiesList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_abilities_list_lookup_model" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
result = (int)gp_abilities_list_lookup_model(arg1,(char const *)arg2);
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_abilities_list_get_abilities(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraAbilitiesList *arg1 = (CameraAbilitiesList *) 0 ;
int arg2 ;
CameraAbilities *arg3 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
arg3 = (CameraAbilities *)calloc(1, sizeof(CameraAbilities));
if (arg3 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraAbilities");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_abilities_list_get_abilities", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraAbilitiesList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_abilities_list_get_abilities" "', argument " "1"" of type '" "CameraAbilitiesList *""'");
}
arg1 = (CameraAbilitiesList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gp_abilities_list_get_abilities" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
result = (int)gp_abilities_list_get_abilities(arg1,arg2,arg3);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg3, SWIGTYPE_p_CameraAbilities, SWIG_POINTER_OWN));
arg3 = NULL;
}
{
free(arg3);
}
return resultobj;
fail:
{
free(arg3);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_message_codeset(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_message_codeset", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_message_codeset" "', argument " "1"" of type '" "char const *""'");
}
arg1 = (char *)(buf1);
result = (char *)gp_message_codeset((char const *)arg1);
resultobj = SWIG_FromCharPtr((const char *)result);
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_init_localedir(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_init_localedir", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_init_localedir" "', argument " "1"" of type '" "char const *""'");
}
arg1 = (char *)(buf1);
result = (int)gp_init_localedir((char const *)arg1);
resultobj = SWIG_From_int((int)(result));
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
static PyMethodDef SwigMethods[] = {
{ "gp_abilities_list_new", _wrap_gp_abilities_list_new, METH_VARARGS, "\n"
"gp_abilities_list_new() -> int\n"
"Allocate the memory for a new abilities list. \n"
"\n"
"Function to allocate the memory for a new abilities list. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" CameraAbilitiesList object to initialize \n"
"\n"
"Returns\n"
"-------\n"
"gphoto2 error code \n"
"\n"
"You would then call gp_abilities_list_load() in order to populate it.\n"
"\n"
"See also gphoto2.CameraAbilitiesList\n"
""},
{ "gp_abilities_list_load", _wrap_gp_abilities_list_load, METH_VARARGS, "\n"
"gp_abilities_list_load(list, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraAbilitiesList\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Scans the system for camera drivers. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraAbilitiesList \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"All supported camera models will then be added to the list.\n"
"\n"
"See also gphoto2.CameraAbilitiesList.load\n"
""},
{ "gp_abilities_list_load_dir", _wrap_gp_abilities_list_load_dir, METH_VARARGS, "\n"
"gp_abilities_list_load_dir(list, dir, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraAbilitiesList\n"
"dir: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
""},
{ "gp_abilities_list_reset", _wrap_gp_abilities_list_reset, METH_VARARGS, "\n"
"gp_abilities_list_reset(list) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraAbilitiesList\n"
"\n"
"Reset the list. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraAbilitiesList \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.CameraAbilitiesList.reset\n"
""},
{ "gp_abilities_list_detect", _wrap_gp_abilities_list_detect, METH_VARARGS, "\n"
"gp_abilities_list_detect(list, info_list, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraAbilitiesList\n"
"info_list: gphoto2.GPPortInfoList\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraAbilitiesList \n"
"* `info_list` : \n"
" the GPPortInfoList of ports to use for detection \n"
"* `l` : \n"
" a CameraList that contains the autodetected cameras after the call \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Tries to detect any camera connected to the computer using the supplied\n"
"list of supported cameras and the supplied info_list of ports. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.CameraAbilitiesList.detect\n"
""},
{ "gp_abilities_list_append", _wrap_gp_abilities_list_append, METH_VARARGS, "\n"
"gp_abilities_list_append(list, abilities) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraAbilitiesList\n"
"abilities: gphoto2.CameraAbilities\n"
"\n"
"This function is deprecated and will be removed in a future release.\n"
""},
{ "gp_abilities_list_count", _wrap_gp_abilities_list_count, METH_VARARGS, "\n"
"gp_abilities_list_count(list) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraAbilitiesList\n"
"\n"
"Count the entries in the supplied list. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraAbilitiesList \n"
"\n"
"Returns\n"
"-------\n"
"The number of entries or a gphoto2 error code\n"
"\n"
"See also gphoto2.CameraAbilitiesList.count\n"
""},
{ "gp_abilities_list_lookup_model", _wrap_gp_abilities_list_lookup_model, METH_VARARGS, "\n"
"gp_abilities_list_lookup_model(list, model) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraAbilitiesList\n"
"model: str\n"
"\n"
"Search the list for an entry of given model name. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraAbilitiesList \n"
"* `model` : \n"
" a camera model name \n"
"\n"
"Returns\n"
"-------\n"
"Index of entry or gphoto2 error code\n"
"\n"
"See also gphoto2.CameraAbilitiesList.lookup_model\n"
""},
{ "gp_abilities_list_get_abilities", _wrap_gp_abilities_list_get_abilities, METH_VARARGS, "\n"
"gp_abilities_list_get_abilities(list, index) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraAbilitiesList\n"
"index: int\n"
"\n"
"Retrieve the camera abilities of entry with supplied index number. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraAbilitiesList \n"
"* `index` : \n"
" index \n"
"* `abilities` : \n"
" pointer to CameraAbilities for returned data. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"Retrieves the camera abilities of entry with supplied index number.\n"
"Typically, you would call gp_camera_set_abilities() afterwards in order\n"
"to prepare the initialization of a camera.\n"
"\n"
"See also gphoto2.CameraAbilitiesList.get_abilities\n"
""},
{ "gp_message_codeset", _wrap_gp_message_codeset, METH_VARARGS, "\n"
"gp_message_codeset(arg1) -> char const *\n"
"\n"
"Parameters\n"
"----------\n"
"arg1: str\n"
"\n"
"Set the current character codeset libgphoto2 is operating in. \n"
"\n"
"Set the codeset for all messages returned by libgphoto2. \n"
"\n"
"Parameters\n"
"----------\n"
"* `codeset` : \n"
" New codeset for the messages. For instance \"utf-8\". \n"
"\n"
"Returns\n"
"-------\n"
"old codeset as returned from bind_textdomain_codeset().\n"
""},
{ "gp_init_localedir", _wrap_gp_init_localedir, METH_VARARGS, "\n"
"gp_init_localedir(localedir) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"localedir: str\n"
"\n"
"Initialize the localedir directory for the libgphoto2 gettext domain. \n"
"\n"
"Override the localedir directory libgphoto2 uses for its message\n"
"translations. \n"
"\n"
"You only need to call this if you have a non-standard installation where\n"
"the locale files are at a location which differs from the compiled in\n"
"default location. \n"
"\n"
"If you do need to call this function, call it before calling any non-\n"
"initialization function. \n"
"\n"
"Internally, this will make sure bindtextdomain() is called for the\n"
"relevant gettext text domain(s). \n"
"\n"
"Parameters\n"
"----------\n"
"* `localedir` : \n"
" Root directory of libgphoto2's localization files. If NULL, use the\n"
" compiled in default value, which will be something like\n"
" \"/usr/share/locale\". \n"
"\n"
"Returns\n"
"-------\n"
"gphoto2 error code.\n"
""},
{ NULL, NULL, 0, NULL }
};
static SwigPyGetSet CameraAbilitiesList___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin___CameraAbilitiesList_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"_CameraAbilitiesList", &CameraAbilitiesList___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___CameraAbilitiesList_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___CameraAbilitiesList_methods[] = {
{ "__len__", _wrap_CameraAbilitiesList___len__, METH_VARARGS, "__len__(self) -> int" },
{ "__getitem__", _wrap_CameraAbilitiesList___getitem__, METH_VARARGS, "\n"
"__getitem__(self, idx)\n"
"\n"
"Parameters\n"
"----------\n"
"idx: int\n"
"\n"
"" },
{ "load", _wrap_CameraAbilitiesList_load, METH_VARARGS, "\n"
"load(self, context)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Scans the system for camera drivers. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraAbilitiesList \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"All supported camera models will then be added to the list.\n"
"\n"
"See also gphoto2.gp_abilities_list_load\n"
"" },
{ "load_dir", _wrap_CameraAbilitiesList_load_dir, METH_VARARGS, "\n"
"load_dir(self, dir, context)\n"
"\n"
"Parameters\n"
"----------\n"
"dir: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"" },
{ "reset", _wrap_CameraAbilitiesList_reset, METH_VARARGS, "\n"
"reset(self)\n"
"Reset the list. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraAbilitiesList \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_abilities_list_reset\n"
"" },
{ "detect", _wrap_CameraAbilitiesList_detect, METH_VARARGS, "\n"
"detect(self, info_list, context)\n"
"\n"
"Parameters\n"
"----------\n"
"info_list: gphoto2.GPPortInfoList\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraAbilitiesList \n"
"* `info_list` : \n"
" the GPPortInfoList of ports to use for detection \n"
"* `l` : \n"
" a CameraList that contains the autodetected cameras after the call \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Tries to detect any camera connected to the computer using the supplied\n"
"list of supported cameras and the supplied info_list of ports. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_abilities_list_detect\n"
"" },
{ "append", _wrap_CameraAbilitiesList_append, METH_VARARGS, "\n"
"append(self, abilities)\n"
"\n"
"Parameters\n"
"----------\n"
"abilities: gphoto2.CameraAbilities\n"
"\n"
"This function is deprecated and will be removed in a future release.\n"
"" },
{ "count", _wrap_CameraAbilitiesList_count, METH_VARARGS, "\n"
"count(self) -> int\n"
"Count the entries in the supplied list. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraAbilitiesList \n"
"\n"
"Returns\n"
"-------\n"
"The number of entries or a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_abilities_list_count\n"
"" },
{ "lookup_model", _wrap_CameraAbilitiesList_lookup_model, METH_VARARGS, "\n"
"lookup_model(self, model) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"model: str\n"
"\n"
"Search the list for an entry of given model name. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraAbilitiesList \n"
"* `model` : \n"
" a camera model name \n"
"\n"
"Returns\n"
"-------\n"
"Index of entry or gphoto2 error code\n"
"\n"
"See also gphoto2.gp_abilities_list_lookup_model\n"
"" },
{ "get_abilities", _wrap_CameraAbilitiesList_get_abilities, METH_VARARGS, "\n"
"get_abilities(self, index)\n"
"\n"
"Parameters\n"
"----------\n"
"index: int\n"
"\n"
"Retrieve the camera abilities of entry with supplied index number. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraAbilitiesList \n"
"* `index` : \n"
" index \n"
"* `abilities` : \n"
" pointer to CameraAbilities for returned data. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"Retrieves the camera abilities of entry with supplied index number.\n"
"Typically, you would call gp_camera_set_abilities() afterwards in order\n"
"to prepare the initialization of a camera.\n"
"\n"
"See also gphoto2.gp_abilities_list_get_abilities\n"
"" },
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___CameraAbilitiesList_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.abilities_list.CameraAbilitiesList", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CameraAbilitiesList_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___CameraAbilitiesList_type.as_number, /* tp_as_number */
&SwigPyBuiltin___CameraAbilitiesList_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___CameraAbilitiesList_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___CameraAbilitiesList_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"::_CameraAbilitiesList", /* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___CameraAbilitiesList_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___CameraAbilitiesList_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___CameraAbilitiesList_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
_wrap_new_CameraAbilitiesList, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
_wrap_CameraAbilitiesList___len___lenfunc_closure, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
_wrap_CameraAbilitiesList___getitem___ssizeargfunc_closure, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___CameraAbilitiesList_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___CameraAbilitiesList_type};
static SwigPyGetSet CameraAbilities_folder_operations_getset = { _wrap_CameraAbilities_folder_operations_get, 0 };
static SwigPyGetSet CameraAbilities_status_getset = { _wrap_CameraAbilities_status_get, 0 };
static SwigPyGetSet CameraAbilities_device_type_getset = { _wrap_CameraAbilities_device_type_get, 0 };
static SwigPyGetSet CameraAbilities_reserved3_getset = { _wrap_CameraAbilities_reserved3_get, 0 };
static SwigPyGetSet CameraAbilities_port_getset = { _wrap_CameraAbilities_port_get, 0 };
static SwigPyGetSet CameraAbilities_speed_getset = { _wrap_CameraAbilities_speed_get, 0 };
static SwigPyGetSet CameraAbilities_reserved4_getset = { _wrap_CameraAbilities_reserved4_get, 0 };
static SwigPyGetSet CameraAbilities___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet CameraAbilities_reserved5_getset = { _wrap_CameraAbilities_reserved5_get, 0 };
static SwigPyGetSet CameraAbilities_model_getset = { _wrap_CameraAbilities_model_get, 0 };
static SwigPyGetSet CameraAbilities_reserved6_getset = { _wrap_CameraAbilities_reserved6_get, 0 };
static SwigPyGetSet CameraAbilities_reserved7_getset = { _wrap_CameraAbilities_reserved7_get, 0 };
static SwigPyGetSet CameraAbilities_operations_getset = { _wrap_CameraAbilities_operations_get, 0 };
static SwigPyGetSet CameraAbilities_reserved8_getset = { _wrap_CameraAbilities_reserved8_get, 0 };
static SwigPyGetSet CameraAbilities_usb_vendor_getset = { _wrap_CameraAbilities_usb_vendor_get, 0 };
static SwigPyGetSet CameraAbilities_usb_class_getset = { _wrap_CameraAbilities_usb_class_get, 0 };
static SwigPyGetSet CameraAbilities_library_getset = { _wrap_CameraAbilities_library_get, 0 };
static SwigPyGetSet CameraAbilities_usb_subclass_getset = { _wrap_CameraAbilities_usb_subclass_get, 0 };
static SwigPyGetSet CameraAbilities_file_operations_getset = { _wrap_CameraAbilities_file_operations_get, 0 };
static SwigPyGetSet CameraAbilities_usb_product_getset = { _wrap_CameraAbilities_usb_product_get, 0 };
static SwigPyGetSet CameraAbilities_id_getset = { _wrap_CameraAbilities_id_get, 0 };
static SwigPyGetSet CameraAbilities_usb_protocol_getset = { _wrap_CameraAbilities_usb_protocol_get, 0 };
static SwigPyGetSet CameraAbilities_reserved2_getset = { _wrap_CameraAbilities_reserved2_get, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CameraAbilities_getset[] = {
{ (char *)"folder_operations", SwigPyBuiltin_GetterClosure, 0, (char *)"folder_operations", &CameraAbilities_folder_operations_getset },
{ (char *)"status", SwigPyBuiltin_GetterClosure, 0, (char *)"status", &CameraAbilities_status_getset },
{ (char *)"device_type", SwigPyBuiltin_GetterClosure, 0, (char *)"device_type", &CameraAbilities_device_type_getset },
{ (char *)"reserved3", SwigPyBuiltin_GetterClosure, 0, (char *)"reserved3", &CameraAbilities_reserved3_getset },
{ (char *)"port", SwigPyBuiltin_GetterClosure, 0, (char *)"port", &CameraAbilities_port_getset },
{ (char *)"speed", SwigPyBuiltin_GetterClosure, 0, (char *)"speed", &CameraAbilities_speed_getset },
{ (char *)"reserved4", SwigPyBuiltin_GetterClosure, 0, (char *)"reserved4", &CameraAbilities_reserved4_getset },
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"model", &CameraAbilities___dict___getset },
{ (char *)"reserved5", SwigPyBuiltin_GetterClosure, 0, (char *)"reserved5", &CameraAbilities_reserved5_getset },
{ (char *)"model", SwigPyBuiltin_GetterClosure, 0, (char *)"model", &CameraAbilities_model_getset },
{ (char *)"reserved6", SwigPyBuiltin_GetterClosure, 0, (char *)"reserved6", &CameraAbilities_reserved6_getset },
{ (char *)"reserved7", SwigPyBuiltin_GetterClosure, 0, (char *)"reserved7", &CameraAbilities_reserved7_getset },
{ (char *)"operations", SwigPyBuiltin_GetterClosure, 0, (char *)"operations", &CameraAbilities_operations_getset },
{ (char *)"reserved8", SwigPyBuiltin_GetterClosure, 0, (char *)"reserved8", &CameraAbilities_reserved8_getset },
{ (char *)"usb_vendor", SwigPyBuiltin_GetterClosure, 0, (char *)"usb_vendor", &CameraAbilities_usb_vendor_getset },
{ (char *)"usb_class", SwigPyBuiltin_GetterClosure, 0, (char *)"usb_class", &CameraAbilities_usb_class_getset },
{ (char *)"library", SwigPyBuiltin_GetterClosure, 0, (char *)"library", &CameraAbilities_library_getset },
{ (char *)"usb_subclass", SwigPyBuiltin_GetterClosure, 0, (char *)"usb_subclass", &CameraAbilities_usb_subclass_getset },
{ (char *)"file_operations", SwigPyBuiltin_GetterClosure, 0, (char *)"file_operations", &CameraAbilities_file_operations_getset },
{ (char *)"usb_product", SwigPyBuiltin_GetterClosure, 0, (char *)"usb_product", &CameraAbilities_usb_product_getset },
{ (char *)"id", SwigPyBuiltin_GetterClosure, 0, (char *)"id", &CameraAbilities_id_getset },
{ (char *)"usb_protocol", SwigPyBuiltin_GetterClosure, 0, (char *)"usb_protocol", &CameraAbilities_usb_protocol_getset },
{ (char *)"reserved2", SwigPyBuiltin_GetterClosure, 0, (char *)"reserved2", &CameraAbilities_reserved2_getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin__CameraAbilities_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin__CameraAbilities_methods[] = {
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin__CameraAbilities_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.abilities_list.CameraAbilities", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CameraAbilities_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin__CameraAbilities_type.as_number, /* tp_as_number */
&SwigPyBuiltin__CameraAbilities_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin__CameraAbilities_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin__CameraAbilities_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"\n"
"Describes the properties of a specific camera. \n"
"\n"
"The internals of this structures are used extensively by the camlibs,\n"
"but the status regarding use by frontends is questionable. \n"
"\n"
"C++ includes: gphoto2-abilities-list.h\n"
"",/* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin__CameraAbilities_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin__CameraAbilities_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin__CameraAbilities_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
SwigPyBuiltin_BadInit, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin__CameraAbilities_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CameraAbilities_type};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_CameraAbilities = {"_p_CameraAbilities", "CameraAbilities *", 0, 0, (void*)&SwigPyBuiltin__CameraAbilities_clientdata, 0};
static swig_type_info _swigt__p_CameraDriverStatus = {"_p_CameraDriverStatus", "CameraDriverStatus *|enum CameraDriverStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFileOperation = {"_p_CameraFileOperation", "CameraFileOperation *|enum CameraFileOperation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFolderOperation = {"_p_CameraFolderOperation", "CameraFolderOperation *|enum CameraFolderOperation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraOperation = {"_p_CameraOperation", "CameraOperation *|enum CameraOperation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GPPortType = {"_p_GPPortType", "GPPortType *|enum GPPortType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GphotoDeviceType = {"_p_GphotoDeviceType", "GphotoDeviceType *|enum GphotoDeviceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwigPyObject = {"_p_SwigPyObject", "SwigPyObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraAbilitiesList = {"_p__CameraAbilitiesList", "CameraAbilitiesList *|struct _CameraAbilitiesList *|_CameraAbilitiesList *", 0, 0, (void*)&SwigPyBuiltin___CameraAbilitiesList_clientdata, 0};
static swig_type_info _swigt__p__CameraList = {"_p__CameraList", "CameraList *|struct _CameraList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPContext = {"_p__GPContext", "GPContext *|struct _GPContext *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPContextFeedback = {"_p__GPContextFeedback", "GPContextFeedback *|enum _GPContextFeedback *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortInfo = {"_p__GPPortInfo", "_GPPortInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortInfoList = {"_p__GPPortInfoList", "GPPortInfoList *|struct _GPPortInfoList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__CameraAbilitiesList = {"_p_p__CameraAbilitiesList", "CameraAbilitiesList **|struct _CameraAbilitiesList **", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_CameraAbilities,
&_swigt__p_CameraDriverStatus,
&_swigt__p_CameraFileOperation,
&_swigt__p_CameraFolderOperation,
&_swigt__p_CameraOperation,
&_swigt__p_GPPortType,
&_swigt__p_GphotoDeviceType,
&_swigt__p_SwigPyObject,
&_swigt__p__CameraAbilitiesList,
&_swigt__p__CameraList,
&_swigt__p__GPContext,
&_swigt__p__GPContextFeedback,
&_swigt__p__GPPortInfo,
&_swigt__p__GPPortInfoList,
&_swigt__p_char,
&_swigt__p_p__CameraAbilitiesList,
};
static swig_cast_info _swigc__p_CameraAbilities[] = { {&_swigt__p_CameraAbilities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraDriverStatus[] = { {&_swigt__p_CameraDriverStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFileOperation[] = { {&_swigt__p_CameraFileOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFolderOperation[] = { {&_swigt__p_CameraFolderOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraOperation[] = { {&_swigt__p_CameraOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GPPortType[] = { {&_swigt__p_GPPortType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GphotoDeviceType[] = { {&_swigt__p_GphotoDeviceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwigPyObject[] = { {&_swigt__p_SwigPyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraAbilitiesList[] = { {&_swigt__p__CameraAbilitiesList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraList[] = { {&_swigt__p__CameraList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPContext[] = { {&_swigt__p__GPContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPContextFeedback[] = { {&_swigt__p__GPContextFeedback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortInfo[] = { {&_swigt__p__GPPortInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortInfoList[] = { {&_swigt__p__GPPortInfoList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__CameraAbilitiesList[] = { {&_swigt__p_p__CameraAbilitiesList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_CameraAbilities,
_swigc__p_CameraDriverStatus,
_swigc__p_CameraFileOperation,
_swigc__p_CameraFolderOperation,
_swigc__p_CameraOperation,
_swigc__p_GPPortType,
_swigc__p_GphotoDeviceType,
_swigc__p_SwigPyObject,
_swigc__p__CameraAbilitiesList,
_swigc__p__CameraList,
_swigc__p__GPContext,
_swigc__p__GPContextFeedback,
_swigc__p__GPPortInfo,
_swigc__p__GPPortInfoList,
_swigc__p_char,
_swigc__p_p__CameraAbilitiesList,
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};
#ifdef __cplusplus
}
#endif
static PyTypeObject *builtin_bases[2];
/* -----------------------------------------------------------------------------
* Type initialization:
* This problem is tough by the requirement that no dynamic
* memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
* to swig_type_info structures, we need some lookup code at initialization.
* The idea is that swig generates all the structures that are needed.
* The runtime then collects these partially filled structures.
* The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
* The generated swig_type_info structures are assigned statically to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
* cast linked list. The cast data is initially stored in something like a
* two-dimensional array. Each row corresponds to a type (there are the same
* number of rows as there are in the swig_type_initial array). Each entry in
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
* we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
* First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
* 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
* swig_cast_info to the linked list (because the cast->type) pointer will
* be correct.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif
#if 0
#define SWIGRUNTIME_DEBUG
#endif
#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif
SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
size_t i;
swig_module_info *module_head, *iter;
int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* Initialize the swig_module */
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
init = 1;
} else {
init = 0;
}
/* Try and load any already created modules */
module_head = SWIG_GetModule(clientdata);
if (!module_head) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
iter=module_head;
do {
if (iter==&swig_module) {
/* Our module is already in the list, so there's nothing more to do. */
return;
}
iter=iter->next;
} while (iter!= module_head);
/* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpreters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
if (init == 0) return;
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
if (swig_module.next != &swig_module) {
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
}
if (type) {
/* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
if (swig_module.type_initial[i]->clientdata) {
type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
}
} else {
type = swig_module.type_initial[i];
}
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
if (swig_module.next != &swig_module) {
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
}
if (ret) {
if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
cast->type = ret;
ret = 0;
} else {
/* Check for casting already in the list */
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
if (!ocast) ret = 0;
}
}
if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
if (type->cast) {
type->cast->prev = cast;
cast->next = type->cast;
}
type->cast = cast;
}
cast++;
}
/* Set entry in modules->types array equal to the type */
swig_module.types[i] = type;
}
swig_module.types[i] = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("**** SWIG_InitializeModule: Cast List ******\n");
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
++j;
}
printf("---- Total casts: %d\n",j);
}
printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}
/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types. It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
size_t i;
swig_cast_info *equiv;
static int init_run = 0;
if (init_run) return;
init_run = 1;
for (i = 0; i < swig_module.size; i++) {
if (swig_module.types[i]->clientdata) {
equiv = swig_module.types[i]->cast;
while (equiv) {
if (!equiv->converter) {
if (equiv->type && !equiv->type->clientdata)
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
}
equiv = equiv->next;
}
}
}
}
#ifdef __cplusplus
#if 0
{
/* c-mode */
#endif
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* constants/methods manipulation
* ----------------------------------------------------------------------------- */
/* Install Constants */
SWIGINTERN void
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
PyObject *obj = 0;
size_t i;
for (i = 0; constants[i].type; ++i) {
switch(constants[i].type) {
case SWIG_PY_POINTER:
obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_PY_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
break;
default:
obj = 0;
break;
}
if (obj) {
PyDict_SetItemString(d, constants[i].name, obj);
Py_DECREF(obj);
}
}
}
/* -----------------------------------------------------------------------------
* Patch %callback methods' docstrings to hold the callback ptrs
* -----------------------------------------------------------------------------*/
SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
size_t i;
for (i = 0; methods[i].ml_name; ++i) {
const char *c = methods[i].ml_doc;
if (!c) continue;
c = strstr(c, "swig_ptr: ");
if (c) {
int j;
const swig_const_info *ci = 0;
const char *name = c + 10;
for (j = 0; const_table[j].type; ++j) {
if (strncmp(const_table[j].name, name,
strlen(const_table[j].name)) == 0) {
ci = &(const_table[j]);
break;
}
}
if (ci) {
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
if (ptr) {
size_t shift = (ci->ptype) - types;
swig_type_info *ty = types_initial[shift];
size_t ldoc = (c - methods[i].ml_doc);
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
char *ndoc = (char*)malloc(ldoc + lptr + 10);
if (ndoc) {
char *buff = ndoc;
memcpy(buff, methods[i].ml_doc, ldoc);
buff += ldoc;
memcpy(buff, "swig_ptr: ", 10);
buff += 10;
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
methods[i].ml_doc = ndoc;
}
}
}
}
}
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------*
* Partial Init method
* -----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
PyObject *m, *d, *md, *globals;
#if PY_VERSION_HEX >= 0x03000000
static struct PyModuleDef SWIG_module = {
PyModuleDef_HEAD_INIT,
SWIG_name,
NULL,
-1,
SwigMethods,
NULL,
NULL,
NULL,
NULL
};
#endif
#if defined(SWIGPYTHON_BUILTIN)
static SwigPyClientData SwigPyObject_clientdata = {
0, 0, 0, 0, 0, 0, 0
};
static PyGetSetDef this_getset_def = {
(char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
};
static SwigPyGetSet thisown_getset_closure = {
SwigPyObject_own,
SwigPyObject_own
};
static PyGetSetDef thisown_getset_def = {
(char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
};
PyTypeObject *builtin_pytype;
int builtin_base_count;
swig_type_info *builtin_basetype;
PyObject *tuple;
PyGetSetDescrObject *static_getset;
PyTypeObject *metatype;
PyTypeObject *swigpyobject;
SwigPyClientData *cd;
PyObject *public_interface, *public_symbol;
PyObject *this_descr;
PyObject *thisown_descr;
PyObject *self = 0;
int i;
(void)builtin_pytype;
(void)builtin_base_count;
(void)builtin_basetype;
(void)tuple;
(void)static_getset;
(void)self;
/* Metaclass is used to implement static member variables */
metatype = SwigPyObjectType();
assert(metatype);
#endif
(void)globals;
/* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
SWIG_This();
SWIG_Python_TypeCache();
SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
SwigPyObject_type();
#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
#if PY_VERSION_HEX >= 0x03000000
m = PyModule_Create(&SWIG_module);
#else
m = Py_InitModule(SWIG_name, SwigMethods);
#endif
md = d = PyModule_GetDict(m);
(void)md;
SWIG_InitializeModule(0);
#ifdef SWIGPYTHON_BUILTIN
swigpyobject = SwigPyObject_TypeOnce();
SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
if (!cd) {
SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
SwigPyObject_clientdata.pytype = swigpyobject;
} else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
return NULL;
# else
return;
# endif
}
/* All objects have a 'this' attribute */
this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
(void)this_descr;
/* All objects have a 'thisown' attribute */
thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
(void)thisown_descr;
public_interface = PyList_New(0);
public_symbol = 0;
(void)public_symbol;
PyDict_SetItemString(md, "__all__", public_interface);
Py_DECREF(public_interface);
for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
for (i = 0; swig_const_table[i].name != 0; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
SWIG_InstallConstants(d,swig_const_table);
{
PyObject *module = PyImport_ImportModule("gphoto2");
if (module != NULL) {
PyExc_GPhoto2Error = PyObject_GetAttrString(module, "GPhoto2Error");
Py_DECREF(module);
}
if (PyExc_GPhoto2Error == NULL)
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
/* type '::_CameraAbilitiesList' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___CameraAbilitiesList_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraAbilitiesList'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CameraAbilitiesList", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraAbilitiesList");
d = md;
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_DRIVER_STATUS_PRODUCTION",SWIG_From_int((int)(GP_DRIVER_STATUS_PRODUCTION)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_DRIVER_STATUS_TESTING",SWIG_From_int((int)(GP_DRIVER_STATUS_TESTING)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_DRIVER_STATUS_EXPERIMENTAL",SWIG_From_int((int)(GP_DRIVER_STATUS_EXPERIMENTAL)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_DRIVER_STATUS_DEPRECATED",SWIG_From_int((int)(GP_DRIVER_STATUS_DEPRECATED)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_DEVICE_STILL_CAMERA",SWIG_From_int((int)(GP_DEVICE_STILL_CAMERA)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_DEVICE_AUDIO_PLAYER",SWIG_From_int((int)(GP_DEVICE_AUDIO_PLAYER)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_OPERATION_NONE",SWIG_From_int((int)(GP_OPERATION_NONE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_OPERATION_CAPTURE_IMAGE",SWIG_From_int((int)(GP_OPERATION_CAPTURE_IMAGE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_OPERATION_CAPTURE_VIDEO",SWIG_From_int((int)(GP_OPERATION_CAPTURE_VIDEO)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_OPERATION_CAPTURE_AUDIO",SWIG_From_int((int)(GP_OPERATION_CAPTURE_AUDIO)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_OPERATION_CAPTURE_PREVIEW",SWIG_From_int((int)(GP_OPERATION_CAPTURE_PREVIEW)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_OPERATION_CONFIG",SWIG_From_int((int)(GP_OPERATION_CONFIG)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_OPERATION_TRIGGER_CAPTURE",SWIG_From_int((int)(GP_OPERATION_TRIGGER_CAPTURE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_OPERATION_NONE",SWIG_From_int((int)(GP_FILE_OPERATION_NONE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_OPERATION_DELETE",SWIG_From_int((int)(GP_FILE_OPERATION_DELETE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_OPERATION_PREVIEW",SWIG_From_int((int)(GP_FILE_OPERATION_PREVIEW)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_OPERATION_RAW",SWIG_From_int((int)(GP_FILE_OPERATION_RAW)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_OPERATION_AUDIO",SWIG_From_int((int)(GP_FILE_OPERATION_AUDIO)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_OPERATION_EXIF",SWIG_From_int((int)(GP_FILE_OPERATION_EXIF)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FOLDER_OPERATION_NONE",SWIG_From_int((int)(GP_FOLDER_OPERATION_NONE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FOLDER_OPERATION_DELETE_ALL",SWIG_From_int((int)(GP_FOLDER_OPERATION_DELETE_ALL)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FOLDER_OPERATION_PUT_FILE",SWIG_From_int((int)(GP_FOLDER_OPERATION_PUT_FILE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FOLDER_OPERATION_MAKE_DIR",SWIG_From_int((int)(GP_FOLDER_OPERATION_MAKE_DIR)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FOLDER_OPERATION_REMOVE_DIR",SWIG_From_int((int)(GP_FOLDER_OPERATION_REMOVE_DIR)));
/* type '::CameraAbilities' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CameraAbilities_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraAbilities'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CameraAbilities", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraAbilities");
d = md;
#if PY_VERSION_HEX >= 0x03000000
return m;
#else
return;
#endif
}
python-gphoto2-2.5.1/src/swig-gp2_5_31/camera.py 0000664 0000000 0000000 00000001113 14703210004 0021162 0 ustar 00root root 0000000 0000000 # This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
import gphoto2.abilities_list
import gphoto2.context
import gphoto2.list
import gphoto2.port_info_list
import gphoto2.filesys
import gphoto2.file
import gphoto2.widget
# Pull in all the attributes from the low-level C/C++ module
if __package__ or "." in __name__:
from ._camera import *
else:
from _camera import *
python-gphoto2-2.5.1/src/swig-gp2_5_31/camera_wrap.c 0000664 0000000 0000000 00001372571 14703210004 0022031 0 ustar 00root root 0000000 0000000 /* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (https://www.swig.org).
* Version 4.1.1
*
* Do not make changes to this file unless you know what you are doing - modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
#define SWIG_VERSION 0x040101
#define SWIGPYTHON
#define SWIG_PYTHON_THREADS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_BUILTIN
#define SWIGPYTHON_FASTPROXY
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if defined(__GNUC__)
# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
/* Intel's compiler complains if a variable which was never initialised is
* cast to void, which is a common idiom which we use to indicate that we
* are aware a variable isn't used. So we just silence that warning.
* See: https://github.com/swig/swig/issues/192 for more discussion.
*/
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include
#endif
#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
* See https://github.com/swig/swig/issues/2090 */
# include
#endif
# undef _DEBUG
# include
# define _DEBUG 1
#else
# include
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
creating a static or dynamic library from the SWIG runtime code.
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
But only do this if strictly necessary, ie, if you have problems
with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif
#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif
/* Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
#define SWIG_POINTER_NO_NULL 0x4
#define SWIG_POINTER_CLEAR 0x8
#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
if (SWIG_IsOK(res)) {
// success code
if (SWIG_IsNewObj(res) {
...
delete *ptr;
} else {
...
}
} else {
// fail code
}
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if () {
if () {
*ptr = ;
return SWIG_NEWOBJ;
} else {
*ptr = ;
return SWIG_OLDOBJ;
}
} else {
return SWIG_BADOBJ;
}
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows returning the 'cast rank', for example, if you have this
int food(double)
int fooi(int);
and you call
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
*/
#define SWIG_OK (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ (SWIG_ERROR)
#define SWIG_OLDOBJ (SWIG_OK)
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
# define SWIG_TypeRank unsigned long
# endif
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
# define SWIG_MAXCASTRANK (2)
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
# define SWIG_AddCast(r) (r)
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
#include
#ifdef __cplusplus
extern "C" {
#endif
typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
void *clientdata; /* language specific type data */
int owndata; /* flag if the structure owns the clientdata */
} swig_type_info;
/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
swig_type_info *type; /* pointer to type that is equivalent to this type */
swig_converter_func converter; /* function to cast the void pointers */
struct swig_cast_info *next; /* pointer to next cast in linked list */
struct swig_cast_info *prev; /* pointer to the previous cast */
} swig_cast_info;
/* Structure used to store module information
* Each module generates one structure like this, and the runtime collects
* all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
size_t size; /* Number of types in this module */
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
swig_type_info **type_initial; /* Array of initially generated type structures */
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
void *clientdata; /* Language specific module data */
} swig_module_info;
/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class" == "Class", etc.
Return 0 when the two name types are equivalent, as in
strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
const char *f2, const char *l2) {
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
while ((*f1 == ' ') && (f1 != l1)) ++f1;
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
return (int)((l1 - f1) - (l2 - f2));
}
/*
Check type equivalence in a name list like ||...
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
}
/*
Check type equivalence in a name list like ||...
Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (strcmp(iter->type->name, c) == 0) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (iter->type == from) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
swig_type_info *lastty = ty;
if (!ty || !ty->dcast) return ty;
while (ty && (ty->dcast)) {
ty = (*ty->dcast)(ptr);
if (ty) lastty = ty;
}
return lastty;
}
/*
Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
return ty->name;
}
/*
Return the pretty name associated with this type,
that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
/* The "str" field contains the equivalent pretty names of the
type, separated by vertical-bar characters. Choose the last
name. It should be the most specific; a fully resolved name
but not necessarily with default template parameters expanded. */
if (!type) return NULL;
if (type->str != NULL) {
const char *last_name = type->str;
const char *s;
for (s = type->str; *s; s++)
if (*s == '|') last_name = s+1;
return last_name;
}
else
return type->name;
}
/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
}
cast = cast->next;
}
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
size_t l = 0;
size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
r = i - 1;
} else {
break;
}
} else if (compare > 0) {
l = i + 1;
}
} else {
break; /* should never happen */
}
} while (l <= r);
}
iter = iter->next;
} while (iter != end);
return 0;
}
/*
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
if (ret) {
return ret;
} else {
/* STEP 2: If the type hasn't been found, do a complete search
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
}
iter = iter->next;
} while (iter != end);
}
/* neither found a match */
return 0;
}
/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
const unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
char d = *(c++);
unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
uu = (unsigned char)((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
uu |= (unsigned char)(d - ('a'-10));
else
return (char *) 0;
*u = uu;
}
return c;
}
/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
char *r = buff;
if ((2*sizeof(void *) + 2) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,&ptr,sizeof(void *));
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
strcpy(r,name);
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
*ptr = (void *) 0;
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sizeof(void *));
}
SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
char *r = buff;
size_t lname = (name ? strlen(name) : 0);
if ((2*sz + 2 + lname) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
if (lname) {
strncpy(r,name,lname+1);
} else {
*r = 0;
}
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
memset(ptr,0,sz);
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sz);
}
#ifdef __cplusplus
}
#endif
/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
#endif
#ifndef Py_TYPE
# define Py_TYPE(op) ((op)->ob_type)
#endif
/* SWIG APIs for compatibility of both Python 2 & 3 */
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
# define SWIG_Python_str_FromFormat PyString_FromFormat
#endif
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03030000
return (char *)PyUnicode_AsUTF8(str);
#else
return PyString_AsString(str);
#endif
}
/* Was useful for Python 3.0.x-3.2.x - now provided only for compatibility
* with any uses in user interface files. */
#define SWIG_Python_str_DelForPy3(x)
SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromString(c);
#else
return PyString_FromString(c);
#endif
}
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif
/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif
/* -----------------------------------------------------------------------------
* error manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
PyObject* type = 0;
switch(code) {
case SWIG_MemoryError:
type = PyExc_MemoryError;
break;
case SWIG_IOError:
type = PyExc_IOError;
break;
case SWIG_RuntimeError:
type = PyExc_RuntimeError;
break;
case SWIG_IndexError:
type = PyExc_IndexError;
break;
case SWIG_TypeError:
type = PyExc_TypeError;
break;
case SWIG_DivisionByZero:
type = PyExc_ZeroDivisionError;
break;
case SWIG_OverflowError:
type = PyExc_OverflowError;
break;
case SWIG_SyntaxError:
type = PyExc_SyntaxError;
break;
case SWIG_ValueError:
type = PyExc_ValueError;
break;
case SWIG_SystemError:
type = PyExc_SystemError;
break;
case SWIG_AttributeError:
type = PyExc_AttributeError;
break;
default:
type = PyExc_RuntimeError;
}
return type;
}
SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
if (PyErr_Occurred())
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
PyErr_Clear();
Py_XINCREF(type);
if (tmp)
PyErr_Format(type, "%s %s", tmp, mesg);
else
PyErr_Format(type, "%s", mesg);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
PyErr_SetString(PyExc_RuntimeError, mesg);
}
}
SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
PyObject *error;
if (obj)
return 0;
error = PyErr_Occurred();
return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}
SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
if (SWIG_Python_TypeErrorOccurred(NULL)) {
/* Use existing TypeError to preserve stacktrace and enhance with given message */
PyObject *newvalue;
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
if (newvalue) {
Py_XDECREF(value);
PyErr_Restore(type, newvalue, traceback);
} else {
PyErr_Restore(type, value, traceback);
}
} else {
/* Raise TypeError using given message */
PyErr_SetString(PyExc_TypeError, message);
}
}
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
# undef SWIG_PYTHON_THREADS
# endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
# define SWIG_PYTHON_USE_GIL
# endif
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# if PY_VERSION_HEX < 0x03070000
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
# else
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# endif
# ifdef __cplusplus /* C++ code */
class SWIG_Python_Thread_Block {
bool status;
PyGILState_STATE state;
public:
void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block() { end(); }
};
class SWIG_Python_Thread_Allow {
bool status;
PyThreadState *save;
public:
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow() { end(); }
};
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
# else /* C code */
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
# endif
# else /* Old thread way, not implemented, user must provide it */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
# define SWIG_PYTHON_THREAD_END_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# endif
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
# define SWIG_PYTHON_THREAD_END_ALLOW
# endif
# endif
#else /* No thread support */
# define SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# define SWIG_PYTHON_THREAD_END_BLOCK
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# define SWIG_PYTHON_THREAD_END_ALLOW
#endif
/* -----------------------------------------------------------------------------
* Python API portion that goes into the runtime
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* Constant declarations
* ----------------------------------------------------------------------------- */
/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY 5
/* Constant information structure */
typedef struct swig_const_info {
int type;
const char *name;
long lvalue;
double dvalue;
void *pvalue;
swig_type_info **ptype;
} swig_const_info;
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* pyrun.swg
*
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* type checking.
*
* ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif
#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#endif
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif
#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
#define SWIG_fail goto fail
/* Runtime API implementation */
/* Error manipulation */
SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetObject(errtype, obj);
Py_DECREF(obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetString(errtype, msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
/* Set a constant value */
#if defined(SWIGPYTHON_BUILTIN)
SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
PyObject *s = PyString_InternFromString(key);
PyList_Append(seq, s);
Py_DECREF(s);
}
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
if (public_interface)
SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}
#else
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
}
#endif
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyList_Check(result)) {
PyObject *o2 = result;
result = PyList_New(1);
if (result) {
PyList_SET_ITEM(result, 0, o2);
} else {
Py_DECREF(obj);
return o2;
}
}
PyList_Append(result,obj);
Py_DECREF(obj);
}
return result;
}
/* Unpack the argument tuple */
SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
if (!PyTuple_Check(args)) {
if (min <= 1 && max >= 1) {
Py_ssize_t i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
}
return 2;
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
Py_ssize_t i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
for (; l < max; ++l) {
objs[l] = 0;
}
return i + 1;
}
}
}
SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
int no_kwargs = 1;
if (kwargs) {
assert(PyDict_Check(kwargs));
if (PyDict_Size(kwargs) > 0) {
PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
no_kwargs = 0;
}
}
return no_kwargs;
}
/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
/*
Helper for static pointer initialization for both C and C++ code, for example
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var) var
#else
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Python-specific SWIG API */
#define SWIG_newvarlink() SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
/* -----------------------------------------------------------------------------
* global variable support code.
* ----------------------------------------------------------------------------- */
typedef struct swig_globalvar {
char *name; /* Name of global variable */
PyObject *(*get_attr)(void); /* Return the current value */
int (*set_attr)(PyObject *); /* Set the value */
struct swig_globalvar *next;
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar *vars;
} swig_varlinkobject;
SWIGINTERN PyObject *
swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_InternFromString("");
#else
return PyString_FromString("");
#endif
}
SWIGINTERN PyObject *
swig_varlink_str(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
PyObject *str = PyUnicode_InternFromString("(");
PyObject *tail;
PyObject *joined;
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
tail = PyUnicode_FromString(var->name);
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
if (var->next) {
tail = PyUnicode_InternFromString(", ");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
}
}
tail = PyUnicode_InternFromString(")");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
#else
PyObject *str = PyString_FromString("(");
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
return str;
}
SWIGINTERN void
swig_varlink_dealloc(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
swig_globalvar *var = v->vars;
while (var) {
swig_globalvar *n = var->next;
free(var->name);
free(var);
var = n;
}
}
SWIGINTERN PyObject *
swig_varlink_getattr(PyObject *o, char *n) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
PyObject *res = NULL;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->get_attr)();
break;
}
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN int
swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
int res = 1;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->set_attr)(p);
break;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
static char varlink__doc__[] = "Swig var link object";
static PyTypeObject varlink_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"swigvarlink", /* tp_name */
sizeof(swig_varlinkobject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) swig_varlink_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc) swig_varlink_getattr, /* tp_getattr */
(setattrfunc) swig_varlink_setattr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc) swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
varlink__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
varlink_type = tmp;
type_init = 1;
if (PyType_Ready(&varlink_type) < 0)
return NULL;
}
return &varlink_type;
}
/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
if (result) {
result->vars = 0;
}
return ((PyObject*) result);
}
SWIGINTERN void
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
memcpy(gv->name, name, size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
}
}
v->vars = gv;
}
static PyObject *Swig_Globals_global = NULL;
SWIGINTERN PyObject *
SWIG_globals(void) {
if (Swig_Globals_global == NULL) {
Swig_Globals_global = SWIG_newvarlink();
}
return Swig_Globals_global;
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* Pointer declarations
* ----------------------------------------------------------------------------- */
/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
#ifdef __cplusplus
extern "C" {
#endif
/* The python void return value */
SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)
{
PyObject *none = Py_None;
Py_INCREF(none);
return none;
}
/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
PyTypeObject *pytype;
} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
int fail = data ? data->implicitconv : 0;
if (fail)
PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
return fail;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
/* the newraw method and newargs arguments used to create a new raw instance */
if (PyClass_Check(obj)) {
data->newraw = 0;
Py_INCREF(obj);
data->newargs = obj;
} else {
data->newraw = PyObject_GetAttrString(data->klass, "__new__");
if (data->newraw) {
data->newargs = PyTuple_New(1);
if (data->newargs) {
Py_INCREF(obj);
PyTuple_SET_ITEM(data->newargs, 0, obj);
} else {
Py_DECREF(data->newraw);
Py_DECREF(data->klass);
free(data);
return 0;
}
} else {
Py_INCREF(obj);
data->newargs = obj;
}
}
/* the destroy method, aka as the C++ delete method */
data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
}
if (data->destroy) {
data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
} else {
data->delargs = 0;
}
data->implicitconv = 0;
data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData *data)
{
Py_XDECREF(data->klass);
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
free(data);
}
/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
PyObject *dict;
#endif
} SwigPyObject;
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
if (!sobj->dict)
sobj->dict = PyDict_New();
Py_XINCREF(sobj->dict);
return sobj->dict;
}
#endif
SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
PyObject *val = SwigPyObject_long(v);
if (val) {
PyObject *ofmt;
PyTuple_SET_ITEM(args, 0, val);
ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
res = PyUnicode_Format(ofmt,args);
#else
res = PyString_Format(ofmt,args);
#endif
Py_DECREF(ofmt);
}
}
Py_DECREF(args);
}
return res;
}
SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v);
if (repr && v->next) {
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
PyObject *joined = PyUnicode_Concat(repr, nrep);
Py_DecRef(repr);
Py_DecRef(nrep);
repr = joined;
# else
PyString_ConcatAndDel(&repr,nrep);
# endif
} else {
Py_DecRef(repr);
repr = NULL;
}
}
return repr;
}
/* We need a version taking two PyObject* parameters so it's a valid
* PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
return SwigPyObject_repr((SwigPyObject*)v);
}
SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
PyObject* res;
if( op != Py_EQ && op != Py_NE ) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
return res;
}
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
SwigPyClientData *cd;
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
assert(cd);
assert(cd->pytype);
return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
#endif
SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
PyTypeObject *target_tp = SwigPyObject_type();
if (PyType_IsSubtype(op->ob_type, target_tp))
return 1;
return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
return (Py_TYPE(op) == SwigPyObject_type())
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
static PyObject* Swig_Capsule_global = NULL;
SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
/* PyObject_CallFunction() has the potential to silently drop
the active exception. In cases of unnamed temporary
variable or where we just finished iterating over a generator
StopIteration will be active right now, and this needs to
remain true upon return from SwigPyObject_dealloc. So save
and restore. */
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
if (data->delargs) {
/* we need to create a temporary object to carry the destroy operation */
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
if (tmp) {
res = SWIG_Python_CallFunctor(destroy, tmp);
} else {
res = 0;
}
Py_XDECREF(tmp);
} else {
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
PyObject *mself = PyCFunction_GET_SELF(destroy);
res = ((*meth)(mself, v));
}
if (!res)
PyErr_WriteUnraisable(destroy);
PyErr_Restore(type, value, traceback);
Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
else {
const char *name = SWIG_TypePrettyName(ty);
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
#endif
Py_XDECREF(Swig_Capsule_global);
}
Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
Py_XDECREF(sobj->dict);
#endif
PyObject_DEL(v);
}
SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject* v, PyObject* next)
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (!SwigPyObject_Check(next)) {
PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
((SwigPyObject *)next)->next = sobj->next;
sobj->next = next;
Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
return NULL;
} else {
SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
if (PyObject_IsTrue(val)) {
Py_DECREF(SwigPyObject_acquire(v,args));
} else {
Py_DECREF(SwigPyObject_disown(v,args));
}
}
return obj;
}
}
static PyMethodDef
swigobject_methods[] = {
{"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
{"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
{"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
{"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
{"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
{"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
{0, 0, 0, 0}
};
SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
/* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
#endif
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
(unaryfunc)0, /*nb_negative*/
(unaryfunc)0, /*nb_positive*/
(unaryfunc)0, /*nb_absolute*/
(inquiry)0, /*nb_nonzero*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
0, /*nb_coerce*/
#endif
(unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_long, /*nb_long*/
#else
0, /*nb_reserved*/
#endif
(unaryfunc)0, /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
};
static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyObject", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
(cmpfunc)SwigPyObject_compare, /* tp_compare */
#endif
(reprfunc)SwigPyObject_repr, /* tp_repr */
&SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigobject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
(richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
swigobject_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobject_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpyobject_type) != 0)
return NULL;
}
return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
sobj->own = own;
sobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
sobj->dict = 0;
#endif
if (own == SWIG_POINTER_OWN) {
/* Obtain a reference to the Python capsule wrapping the module information, so that the
* module information is correctly destroyed after all SWIG python objects have been freed
* by the GC (and corresponding destructors invoked) */
Py_XINCREF(Swig_Capsule_global);
}
}
return (PyObject *)sobj;
}
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
void *pack;
swig_type_info *ty;
size_t size;
} SwigPyPacked;
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return SWIG_Python_str_FromFormat("", result, v->ty->name);
} else {
return SWIG_Python_str_FromFormat("", v->ty->name);
}
}
SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}
SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
return ((op)->ob_type == SwigPyPacked_TypeOnce())
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
if (SwigPyPacked_Check(v)) {
SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyPacked", /* tp_name */
sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
0, /* tp_reserved in 3.0.1 */
#else
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
#endif
(reprfunc)SwigPyPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigpacked_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpypacked_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpypacked_type) != 0)
return NULL;
}
return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
memcpy(pack, ptr, size);
sobj->pack = pack;
sobj->ty = ty;
sobj->size = size;
} else {
PyObject_DEL((PyObject *) sobj);
sobj = 0;
}
}
return (PyObject *) sobj;
}
SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (SwigPyPacked_Check(obj)) {
SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
} else {
return 0;
}
}
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
static PyObject *Swig_This_global = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
if (Swig_This_global == NULL)
Swig_This_global = SWIG_Python_str_FromChar("this");
return Swig_This_global;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS
#endif
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
PyObject *obj;
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
#ifdef SWIGPYTHON_BUILTIN
(void)obj;
# ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
pyobj = PyWeakref_GET_OBJECT(pyobj);
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
# endif
return NULL;
#else
obj = 0;
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
}
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
#endif
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
return oldown;
}
}
return 0;
}
/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
int res;
SwigPyObject *sobj;
int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
if (!obj)
return SWIG_ERROR;
if (obj == Py_None && !implicit_conv) {
if (ptr)
*ptr = 0;
return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
}
res = SWIG_ERROR;
sobj = SWIG_Python_GetSwigThis(obj);
if (own)
*own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
swig_type_info *to = sobj->ty;
if (to == ty) {
/* no type cast needed */
if (ptr) *ptr = vptr;
break;
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
sobj = (SwigPyObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
if (own)
*own = *own | SWIG_CAST_NEW_MEMORY;
}
}
break;
}
}
} else {
if (ptr) *ptr = vptr;
break;
}
}
if (sobj) {
if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
res = SWIG_ERROR_RELEASE_NOT_OWNED;
} else {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
if (flags & SWIG_POINTER_CLEAR) {
sobj->ptr = 0;
}
res = SWIG_OK;
}
} else {
if (implicit_conv) {
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
PyObject *impconv;
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
impconv = SWIG_Python_CallFunctor(klass, obj);
data->implicitconv = 0;
if (PyErr_Occurred()) {
PyErr_Clear();
impconv = 0;
}
if (impconv) {
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
if (SWIG_IsOK(res)) {
if (ptr) {
*ptr = vptr;
/* transfer the ownership to 'ptr' */
iobj->own = 0;
res = SWIG_AddCast(res);
res = SWIG_AddNewMask(res);
} else {
res = SWIG_AddCast(res);
}
}
}
Py_DECREF(impconv);
}
}
}
if (!SWIG_IsOK(res) && obj == Py_None) {
if (ptr)
*ptr = 0;
if (PyErr_Occurred())
PyErr_Clear();
res = SWIG_OK;
}
}
}
return res;
}
/* Convert a function ptr value */
SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
if (!PyCFunction_Check(obj)) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
swig_cast_info *tc;
/* here we get the method pointer for callbacks */
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
if (!desc)
return SWIG_ERROR;
tc = SWIG_TypeCheck(desc,ty);
if (tc) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
} else {
return SWIG_ERROR;
}
return SWIG_OK;
}
}
/* Convert a packed pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
/* check type cast? */
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* -----------------------------------------------------------------------------
* Create a new pointer object
* ----------------------------------------------------------------------------- */
/*
Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
inst = PyObject_Call(newraw, data->newargs, NULL);
if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
Py_DECREF(inst);
inst = 0;
}
}
#else
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
}
#endif
}
} else {
#if PY_VERSION_HEX >= 0x03000000
PyObject *empty_args = PyTuple_New(0);
if (empty_args) {
PyObject *empty_kwargs = PyDict_New();
if (empty_kwargs) {
inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
Py_DECREF(empty_kwargs);
if (inst) {
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
} else {
PyType_Modified(Py_TYPE(inst));
}
}
}
Py_DECREF(empty_args);
}
#else
PyObject *dict = PyDict_New();
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
}
#endif
}
return inst;
}
SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
return PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
return -1;
}
}
#endif
return PyObject_SetAttr(inst, SWIG_This(), swig_this);
}
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
return NULL;
} else {
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
} else {
if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
return NULL;
}
return SWIG_Py_Void();
}
}
/* Create a new pointer object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
SwigPyClientData *clientdata;
PyObject * robj;
int own;
if (!ptr)
return SWIG_Py_Void();
clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
if (clientdata && clientdata->pytype) {
SwigPyObject *newobj;
if (flags & SWIG_BUILTIN_TP_INIT) {
newobj = (SwigPyObject*) self;
if (newobj->ptr) {
PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
while (newobj->next)
newobj = (SwigPyObject *) newobj->next;
newobj->next = next_self;
newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
newobj->dict = 0;
#endif
}
} else {
newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
if (newobj) {
newobj->dict = 0;
}
#endif
}
if (newobj) {
newobj->ptr = ptr;
newobj->ty = type;
newobj->own = own;
newobj->next = 0;
return (PyObject*) newobj;
}
return SWIG_Py_Void();
}
assert(!(flags & SWIG_BUILTIN_TP_INIT));
robj = SwigPyObject_New(ptr, type, own);
if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
Py_DECREF(robj);
robj = inst;
}
return robj;
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
* Get type list
* -----------------------------------------------------------------------------*/
#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif
static PyObject *Swig_TypeCache_global = NULL;
/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
if (Swig_TypeCache_global == NULL) {
Swig_TypeCache_global = PyDict_New();
}
return Swig_TypeCache_global;
}
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
}
#else
void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
}
#endif
return (swig_module_info *) type_pointer;
}
static int interpreter_counter = 0; // how many (sub-)interpreters are using swig_module's types
SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
swig_type_info **types = swig_module->types;
size_t i;
if (--interpreter_counter != 0) // another sub-interpreter may still be using the swig_module's types
return;
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
ty->clientdata = 0;
if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
Swig_This_global = NULL;
Py_DECREF(SWIG_globals());
Swig_Globals_global = NULL;
Py_DECREF(SWIG_Python_TypeCache());
Swig_TypeCache_global = NULL;
Swig_Capsule_global = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
/* Add a dummy module object into sys.modules */
PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && module) {
if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
++interpreter_counter;
Swig_Capsule_global = pointer;
} else {
Py_DECREF(pointer);
}
} else {
Py_XDECREF(pointer);
}
}
SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
PyObject *key = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
} else {
swig_module_info *swig_module = SWIG_GetModule(0);
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
obj = PyCapsule_New((void*) descriptor, NULL, NULL);
if (obj) {
PyDict_SetItem(cache, key, obj);
Py_DECREF(obj);
}
}
}
Py_DECREF(key);
return descriptor;
}
/*
For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION 0
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
const char *errmesg = tmp ? tmp : "Invalid error message";
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, errmesg);
} else {
PyErr_Format(type, "%s %s", errmesg, mesg);
}
Py_DECREF(old_str);
}
return 1;
} else {
return 0;
}
}
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
if (PyErr_Occurred()) {
/* add information about failing argument */
char mesg[256];
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
} else {
return 0;
}
}
SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : "";
}
SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
if (obj && SwigPyObject_Check(obj)) {
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
type, otype);
return;
}
} else
#endif
{
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
}
Py_XDECREF(str);
return;
}
}
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
} else {
PyErr_Format(PyExc_TypeError, "unexpected type is received");
}
}
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
}
return result;
}
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
PyTypeObject *tp = obj->ob_type;
PyObject *descr;
PyObject *encoded_name;
descrsetfunc f;
int res = -1;
# ifdef Py_USING_UNICODE
if (PyString_Check(name)) {
name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
if (!name)
return -1;
} else if (!PyUnicode_Check(name))
# else
if (!PyString_Check(name))
# endif
{
PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
return -1;
} else {
Py_INCREF(name);
}
if (!tp->tp_dict) {
if (PyType_Ready(tp) != 0)
goto done;
}
descr = _PyType_Lookup(tp, name);
f = NULL;
if (descr != NULL)
f = descr->ob_type->tp_descr_set;
if (!f) {
if (PyString_Check(name)) {
encoded_name = name;
Py_INCREF(name);
} else {
encoded_name = PyUnicode_AsUTF8String(name);
if (!encoded_name)
goto done;
}
PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
Py_DECREF(encoded_name);
} else {
res = f(descr, obj, value);
}
done:
Py_DECREF(name);
return res;
}
#endif
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN Py_hash_t
SwigPyObject_hash(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
void *ptr = sobj->ptr;
#if PY_VERSION_HEX < 0x03020000
return (Py_hash_t)(Py_ssize_t)ptr;
#else
return (Py_hash_t)ptr;
#endif
}
SWIGINTERN Py_hash_t
SWIG_PyNumber_AsPyHash(PyObject *obj) {
Py_hash_t result = -1;
#if PY_VERSION_HEX < 0x03020000
if (PyInt_Check(obj))
result = PyInt_AsLong(obj);
else if (PyLong_Check(obj))
result = PyLong_AsLong(obj);
#else
if (PyNumber_Check(obj))
result = PyNumber_AsSsize_t(obj, NULL);
#endif
else
PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
return PyErr_Occurred() ? -1 : result;
}
SWIGINTERN int
SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
return -1;
}
SWIGINTERN void
SwigPyBuiltin_BadDealloc(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
if (sobj->own) {
PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", obj->ob_type->tp_name);
}
}
typedef struct {
PyCFunction get;
PyCFunction set;
} SwigPyGetSet;
SWIGINTERN PyObject *
SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
tuple = PyTuple_New(0);
assert(tuple);
result = (*getset->get)(obj, tuple);
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyObject *
SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
result = (*getset->get)(obj, NULL);
return result;
}
SWIGINTERN int
SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(val);
PyTuple_SET_ITEM(tuple, 0, val);
result = (*getset->set)(obj, tuple);
Py_DECREF(tuple);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN int
SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
result = (*getset->set)(obj, val);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN void
SwigPyStaticVar_dealloc(PyDescrObject *descr) {
PyObject_GC_UnTrack(descr);
Py_XDECREF(PyDescr_TYPE(descr));
Py_XDECREF(PyDescr_NAME(descr));
PyObject_GC_Del(descr);
}
SWIGINTERN PyObject *
SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromFormat("", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
return PyString_FromFormat("", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
}
SWIGINTERN int
SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
PyDescrObject *descr;
descr = (PyDescrObject *)self;
Py_VISIT((PyObject*) PyDescr_TYPE(descr));
return 0;
}
SWIGINTERN PyObject *
SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
if (descr->d_getset->get != NULL)
return descr->d_getset->get(obj, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return NULL;
}
SWIGINTERN int
SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
if (descr->d_getset->set != NULL)
return descr->d_getset->set(obj, value, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return -1;
}
SWIGINTERN int
SwigPyObjectType_setattro(PyObject *typeobject, PyObject *name, PyObject *value) {
PyObject *attribute;
PyTypeObject *type;
descrsetfunc local_set;
assert(PyType_Check(typeobject));
type = (PyTypeObject *)typeobject;
attribute = _PyType_Lookup(type, name);
if (attribute != NULL) {
/* Implement descriptor functionality, if any */
local_set = attribute->ob_type->tp_descr_set;
if (local_set != NULL)
return local_set(attribute, (PyObject *)type, value);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
} else {
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
}
return -1;
}
SWIGINTERN PyTypeObject*
SwigPyStaticVar_Type(void) {
static PyTypeObject staticvar_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"swig_static_var_getset_descriptor", /* tp_name */
sizeof(PyGetSetDescrObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyStaticVar_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
(reprfunc)SwigPyStaticVar_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
0, /* tp_doc */
SwigPyStaticVar_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc)SwigPyStaticVar_get, /* tp_descr_get */
(descrsetfunc)SwigPyStaticVar_set, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
staticvar_type = tmp;
type_init = 1;
if (PyType_Ready(&staticvar_type) < 0)
return NULL;
}
return &staticvar_type;
}
SWIGINTERN PyTypeObject*
SwigPyObjectType(void) {
static char swigpyobjecttype_doc[] = "Metaclass for SWIG wrapped types";
static PyTypeObject swigpyobjecttype_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"SwigPyObjectType", /* tp_name */
PyType_Type.tp_basicsize, /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
SwigPyObjectType_setattro, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
swigpyobjecttype_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobjecttype_type = tmp;
type_init = 1;
swigpyobjecttype_type.tp_base = &PyType_Type;
if (PyType_Ready(&swigpyobjecttype_type) < 0)
return NULL;
}
return &swigpyobjecttype_type;
}
SWIGINTERN PyGetSetDescrObject *
SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
PyGetSetDescrObject *descr;
descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
assert(descr);
Py_XINCREF(type);
PyDescr_TYPE(descr) = type;
PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
descr->d_getset = getset;
if (PyDescr_NAME(descr) == NULL) {
Py_DECREF(descr);
descr = NULL;
}
return descr;
}
SWIGINTERN void
SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
Py_ssize_t base_count = 0;
PyTypeObject **b;
PyObject *tuple;
Py_ssize_t i;
if (!bases[0]) {
bases[0] = SwigPyObject_type();
bases[1] = NULL;
}
type->tp_base = bases[0];
Py_INCREF((PyObject *)bases[0]);
for (b = bases; *b != NULL; ++b)
++base_count;
tuple = PyTuple_New(base_count);
for (i = 0; i < base_count; ++i) {
Py_INCREF((PyObject *)bases[i]);
PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
}
type->tp_bases = tuple;
}
SWIGINTERN PyObject *
SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
PyObject *result;
result = (PyObject *)SWIG_Python_GetSwigThis(self);
Py_XINCREF(result);
return result;
}
SWIGINTERN void
SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
{
#if PY_VERSION_HEX >= 0x030900a4
Py_SET_TYPE(type, metatype);
#else
Py_TYPE(type) = metatype;
#endif
}
/* Start of callback function macros for use in PyTypeObject */
typedef PyObject *(*SwigPyWrapperFunction)(PyObject *, PyObject *);
#define SWIGPY_UNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_unaryfunc_closure(PyObject *a) { \
return SwigPyBuiltin_unaryfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_unaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper) \
SWIGINTERN void \
wrapper##_destructor_closure(PyObject *a) { \
SwigPyBuiltin_destructor_closure(wrapper, #wrapper, a); \
}
SWIGINTERN void
SwigPyBuiltin_destructor_closure(SwigPyWrapperFunction wrapper, const char *wrappername, PyObject *a) {
SwigPyObject *sobj;
sobj = (SwigPyObject *)a;
Py_XDECREF(sobj->dict);
if (sobj->own) {
PyObject *o;
PyObject *type = 0, *value = 0, *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
o = wrapper(a, NULL);
if (!o) {
PyObject *deallocname = PyString_FromString(wrappername);
PyErr_WriteUnraisable(deallocname);
Py_DECREF(deallocname);
}
PyErr_Restore(type, value, traceback);
Py_XDECREF(o);
}
if (PyType_IS_GC(a->ob_type)) {
PyObject_GC_Del(a);
} else {
PyObject_Del(a);
}
}
#define SWIGPY_INQUIRY_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_inquiry_closure(PyObject *a) { \
return SwigPyBuiltin_inquiry_closure(wrapper, a); \
}
SWIGINTERN int
SwigPyBuiltin_inquiry_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
int result;
pyresult = wrapper(a, NULL);
result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_GETITERFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_getiterfunc_closure(PyObject *a) { \
return SwigPyBuiltin_getiterfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_getiterfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_BINARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_binaryfunc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_binaryfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_binaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
typedef ternaryfunc ternarycallfunc;
#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternaryfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternaryfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternarycallfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternarycallfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternarycallfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
(void) c;
return wrapper(a, b);
}
#define SWIGPY_LENFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_ssize_t \
wrapper##_lenfunc_closure(PyObject *a) { \
return SwigPyBuiltin_lenfunc_closure(wrapper, a); \
}
SWIGINTERN Py_ssize_t
SwigPyBuiltin_lenfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *resultobj;
Py_ssize_t result;
resultobj = wrapper(a, NULL);
result = PyNumber_AsSsize_t(resultobj, NULL);
Py_DECREF(resultobj);
return result;
}
#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizessizeargfunc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) { \
return SwigPyBuiltin_ssizessizeargfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizessizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizessizeobjargproc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
return SwigPyBuiltin_ssizessizeobjargproc_closure(wrapper, a, b, c, d); \
}
SWIGINTERN int
SwigPyBuiltin_ssizessizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(d ? 3 : 2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
if (d) {
Py_INCREF(d);
PyTuple_SET_ITEM(tuple, 2, d);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_DECREF(tuple);
Py_XDECREF(resultobj);
return result;
}
#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_funpack_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_funpack_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *arg, *result;
arg = _PyLong_FromSsize_t(b);
result = wrapper(a, arg);
Py_DECREF(arg);
return result;
}
#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizeobjargproc_closure(PyObject *a, Py_ssize_t b, PyObject *c) { \
return SwigPyBuiltin_ssizeobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_ssizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
PyObject *tuple;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
pyresult = wrapper(a, tuple);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_funpack_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_funpack_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
pyresult = wrapper(a, b);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjargproc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_objobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_objobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(c ? 2 : 1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
if (c) {
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_REPRFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_reprfunc_closure(PyObject *a) { \
return SwigPyBuiltin_reprfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_reprfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_HASHFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_hash_t \
wrapper##_hashfunc_closure(PyObject *a) { \
return SwigPyBuiltin_hashfunc_closure(wrapper, a); \
}
SWIGINTERN Py_hash_t
SwigPyBuiltin_hashfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
Py_hash_t result;
pyresult = wrapper(a, NULL);
if (!pyresult)
return -1;
result = SWIG_PyNumber_AsPyHash(pyresult);
Py_DECREF(pyresult);
return result;
}
#define SWIGPY_ITERNEXTFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_iternextfunc_closure(PyObject *a) { \
return SwigPyBuiltin_iternextfunc_closure(wrapper, a);\
}
SWIGINTERN PyObject *
SwigPyBuiltin_iternextfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
/* End of callback function macros for use in PyTypeObject */
#ifdef __cplusplus
}
#endif
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_CameraAbilities swig_types[0]
#define SWIGTYPE_p_CameraCaptureType swig_types[1]
#define SWIGTYPE_p_CameraDriverStatus swig_types[2]
#define SWIGTYPE_p_CameraEventType swig_types[3]
#define SWIGTYPE_p_CameraFileAccessType swig_types[4]
#define SWIGTYPE_p_CameraFileInfoFields swig_types[5]
#define SWIGTYPE_p_CameraFileOperation swig_types[6]
#define SWIGTYPE_p_CameraFilePath swig_types[7]
#define SWIGTYPE_p_CameraFilePermissions swig_types[8]
#define SWIGTYPE_p_CameraFileStatus swig_types[9]
#define SWIGTYPE_p_CameraFileType swig_types[10]
#define SWIGTYPE_p_CameraFolderOperation swig_types[11]
#define SWIGTYPE_p_CameraOperation swig_types[12]
#define SWIGTYPE_p_CameraStorageAccessType swig_types[13]
#define SWIGTYPE_p_CameraStorageFilesystemType swig_types[14]
#define SWIGTYPE_p_CameraStorageInfoFields swig_types[15]
#define SWIGTYPE_p_CameraStorageType swig_types[16]
#define SWIGTYPE_p_CameraText swig_types[17]
#define SWIGTYPE_p_CameraWidgetType swig_types[18]
#define SWIGTYPE_p_GPPortType swig_types[19]
#define SWIGTYPE_p_GphotoDeviceType swig_types[20]
#define SWIGTYPE_p_SwigPyObject swig_types[21]
#define SWIGTYPE_p__Camera swig_types[22]
#define SWIGTYPE_p__CameraAbilitiesList swig_types[23]
#define SWIGTYPE_p__CameraFile swig_types[24]
#define SWIGTYPE_p__CameraFileHandler swig_types[25]
#define SWIGTYPE_p__CameraFileInfo swig_types[26]
#define SWIGTYPE_p__CameraFileInfoAudio swig_types[27]
#define SWIGTYPE_p__CameraFileInfoFile swig_types[28]
#define SWIGTYPE_p__CameraFileInfoPreview swig_types[29]
#define SWIGTYPE_p__CameraFunctions swig_types[30]
#define SWIGTYPE_p__CameraList swig_types[31]
#define SWIGTYPE_p__CameraPrivateCore swig_types[32]
#define SWIGTYPE_p__CameraPrivateLibrary swig_types[33]
#define SWIGTYPE_p__CameraStorageInformation swig_types[34]
#define SWIGTYPE_p__CameraWidget swig_types[35]
#define SWIGTYPE_p__GPContext swig_types[36]
#define SWIGTYPE_p__GPContextFeedback swig_types[37]
#define SWIGTYPE_p__GPPortInfo swig_types[38]
#define SWIGTYPE_p__GPPortInfoList swig_types[39]
#define SWIGTYPE_p_char swig_types[40]
#define SWIGTYPE_p_int swig_types[41]
#define SWIGTYPE_p_long swig_types[42]
#define SWIGTYPE_p_long_long swig_types[43]
#define SWIGTYPE_p_p__Camera swig_types[44]
#define SWIGTYPE_p_p__CameraStorageInformation swig_types[45]
#define SWIGTYPE_p_p__CameraWidget swig_types[46]
#define SWIGTYPE_p_p__GPPortInfo swig_types[47]
#define SWIGTYPE_p_p_void swig_types[48]
#define SWIGTYPE_p_short swig_types[49]
#define SWIGTYPE_p_signed_char swig_types[50]
#define SWIGTYPE_p_unsigned_char swig_types[51]
#define SWIGTYPE_p_unsigned_int swig_types[52]
#define SWIGTYPE_p_unsigned_long_long swig_types[53]
#define SWIGTYPE_p_unsigned_short swig_types[54]
static swig_type_info *swig_types[56];
static swig_module_info swig_module = {swig_types, 55, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery
/*-----------------------------------------------
@(target):= _camera.so
------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_init PyInit__camera
#else
# define SWIG_init init_camera
#endif
#define SWIG_name "_camera"
#define SWIG_as_voidptr(a) (void *)((const void *)(a))
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
#include
#include "gphoto2/gphoto2.h"
PyObject *PyExc_GPhoto2Error = NULL;
#include // Use the C99 official header
SWIGINTERNINLINE PyObject*
SWIG_From_int (int value)
{
return PyInt_FromLong((long) value);
}
#if GPHOTO2_VERSION < 0x02051100
unsigned int GP_EVENT_FILE_CHANGED = GP_EVENT_CAPTURE_COMPLETE + 1;
#endif
SWIGINTERN char *CameraText___str__(CameraText *self){
return self->text;
}
SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
static int init = 0;
static swig_type_info* info = 0;
if (!init) {
info = SWIG_TypeQuery("_p_char");
init = 1;
}
return info;
}
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
if (carray) {
if (size > INT_MAX) {
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
return pchar_descriptor ?
SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
} else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
#else
return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
#endif
#else
return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
#endif
}
} else {
return SWIG_Py_Void();
}
}
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtr(const char *cptr)
{
return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}
SWIGINTERN size_t
SWIG_strnlen(const char* s, size_t maxlen)
{
const char *p;
for (p = s; maxlen-- && *p; p++)
;
return p - s;
}
SWIGINTERN struct _Camera *new__Camera(void){
struct _Camera *result;
int error = gp_camera_new(&result);
if (error < GP_OK)
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
return result;
}
SWIGINTERN void delete__Camera(struct _Camera *self){
int error = gp_camera_unref(self);
if (error < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
}
SWIGINTERN void _Camera_autodetect(CameraList *list,GPContext *context){
int result = gp_camera_autodetect (list, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_set_abilities(struct _Camera *self,CameraAbilities abilities){
int result = gp_camera_set_abilities (self, abilities);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_get_abilities(struct _Camera *self,CameraAbilities *abilities){
int result = gp_camera_get_abilities (self, abilities);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_set_port_info(struct _Camera *self,GPPortInfo info){
int result = gp_camera_set_port_info (self, info);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_get_port_info(struct _Camera *self,GPPortInfo *info){
int result = gp_camera_get_port_info (self, info);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
#include
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
# define LLONG_MAX __LONG_LONG_MAX__
# define LLONG_MIN (-LLONG_MAX - 1LL)
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif
SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
int res = SWIG_TypeError;
if (PyFloat_Check(obj)) {
if (val) *val = PyFloat_AsDouble(obj);
return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
} else if (PyInt_Check(obj)) {
if (val) *val = (double) PyInt_AsLong(obj);
return SWIG_OK;
#endif
} else if (PyLong_Check(obj)) {
double v = PyLong_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
double d = PyFloat_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = d;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
} else {
PyErr_Clear();
}
}
}
#endif
return res;
}
#include
#include
SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
double x = *d;
if ((min <= x && x <= max)) {
double fx = floor(x);
double cx = ceil(x);
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
if ((errno == EDOM) || (errno == ERANGE)) {
errno = 0;
} else {
double summ, reps, diff;
if (rd < x) {
diff = x - rd;
} else if (rd > x) {
diff = rd - x;
} else {
return 1;
}
summ = rd + x;
reps = diff/summ;
if (reps < 8*DBL_EPSILON) {
*d = rd;
return 1;
}
}
}
return 0;
}
SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
} else
#endif
if (PyLong_Check(obj)) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
return SWIG_OverflowError;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
long v = PyInt_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
if (val) *val = (long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
long v;
int res = SWIG_AsVal_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v < INT_MIN || v > INT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = (int)(v);
}
}
return res;
}
SWIGINTERN void _Camera_set_port_speed(struct _Camera *self,int speed){
int result = gp_camera_set_port_speed (self, speed);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN int _Camera_get_port_speed(struct _Camera *self){
int result = gp_camera_get_port_speed (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
return result;
}
SWIGINTERN void _Camera_init(struct _Camera *self,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_init (self, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_exit(struct _Camera *self,GPContext *context){
int result = gp_camera_exit (self, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_get_config(struct _Camera *self,CameraWidget **window,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_get_config (self, window, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_list_config(struct _Camera *self,CameraList *list,GPContext *context){
int result = gp_camera_list_config (self, list, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (PyBytes_Check(obj))
#else
if (PyUnicode_Check(obj))
#endif
#else
if (PyString_Check(obj))
#endif
{
char *cstr; Py_ssize_t len;
int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (!alloc && cptr) {
/* We can't allow converting without allocation, since the internal
representation of string in Python 3 is UCS-2/UCS-4 but we require
a UTF-8 representation.
TODO(bhy) More detailed explanation */
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (alloc)
*alloc = SWIG_NEWOBJ;
#endif
if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#else
if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#endif
if (cptr) {
if (alloc) {
if (*alloc == SWIG_NEWOBJ) {
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
*alloc = SWIG_NEWOBJ;
} else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
}
} else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
*cptr = PyBytes_AsString(obj);
#else
assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
*cptr = SWIG_Python_str_AsChar(obj);
if (!*cptr)
ret = SWIG_TypeError;
#endif
}
}
if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
Py_XDECREF(obj);
#endif
return ret;
} else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
if (PyUnicode_Check(obj)) {
char *cstr; Py_ssize_t len;
if (!alloc && cptr) {
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
if (cptr) {
if (alloc) *alloc = SWIG_NEWOBJ;
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
}
if (psize) *psize = len + 1;
Py_XDECREF(obj);
return SWIG_OK;
} else {
Py_XDECREF(obj);
}
}
#endif
#endif
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
if (pchar_descriptor) {
void* vptr = 0;
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
if (cptr) *cptr = (char *) vptr;
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
if (alloc) *alloc = SWIG_OLDOBJ;
return SWIG_OK;
}
}
}
return SWIG_TypeError;
}
SWIGINTERN void _Camera_get_single_config(struct _Camera *self,char const *name,CameraWidget **widget,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_get_single_config (self, name, widget, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_set_config(struct _Camera *self,CameraWidget *window,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_set_config (self, window, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_set_single_config(struct _Camera *self,char const *name,CameraWidget *widget,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_set_single_config (self, name, widget, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_get_summary(struct _Camera *self,CameraText *summary,GPContext *context){
int result = gp_camera_get_summary (self, summary, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_get_manual(struct _Camera *self,CameraText *manual,GPContext *context){
int result = gp_camera_get_manual (self, manual, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_get_about(struct _Camera *self,CameraText *about,GPContext *context){
int result = gp_camera_get_about (self, about, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_capture(struct _Camera *self,CameraCaptureType type,CameraFilePath *path,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_capture (self, type, path, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_trigger_capture(struct _Camera *self,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_trigger_capture (self, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_capture_preview(struct _Camera *self,CameraFile *camera_file,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_capture_preview (self, camera_file, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_wait_for_event(struct _Camera *self,int timeout,CameraEventType *eventtype,void **eventdata,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_wait_for_event (self, timeout, eventtype, eventdata, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_get_storageinfo(struct _Camera *self,CameraStorageInformation **sifs,int *nrofsifs,GPContext *context){
int result = gp_camera_get_storageinfo (self, sifs, nrofsifs, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_folder_list_files(struct _Camera *self,char const *folder,CameraList *list,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_folder_list_files (self, folder, list, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_folder_list_folders(struct _Camera *self,char const *folder,CameraList *list,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_folder_list_folders (self, folder, list, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_folder_delete_all(struct _Camera *self,char const *folder,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_folder_delete_all (self, folder, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_folder_put_file(struct _Camera *self,char const *folder,char const *filename,CameraFileType type,CameraFile *file,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_folder_put_file (self, folder, filename, type, file, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_folder_make_dir(struct _Camera *self,char const *folder,char const *name,GPContext *context){
int result = gp_camera_folder_make_dir (self, folder, name, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_folder_remove_dir(struct _Camera *self,char const *folder,char const *name,GPContext *context){
int result = gp_camera_folder_remove_dir (self, folder, name, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_file_get_info(struct _Camera *self,char const *folder,char const *file,CameraFileInfo *info,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_file_get_info (self, folder, file, info, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_file_set_info(struct _Camera *self,char const *folder,char const *file,CameraFileInfo info,GPContext *context){
int result = gp_camera_file_set_info (self, folder, file, info, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_file_get(struct _Camera *self,char const *folder,char const *file,CameraFileType type,CameraFile *camera_file,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_file_get (self, folder, file, type, camera_file, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
{
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
long v = PyInt_AsLong(obj);
if (v >= 0) {
if (val) *val = v;
return SWIG_OK;
} else {
return SWIG_OverflowError;
}
} else
#endif
if (PyLong_Check(obj)) {
unsigned long v = PyLong_AsUnsignedLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
return SWIG_OverflowError;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
unsigned long v = PyLong_AsUnsignedLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
if (val) *val = (unsigned long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
# define SWIG_LONG_LONG_AVAILABLE
#endif
#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
int res = SWIG_TypeError;
if (PyLong_Check(obj)) {
unsigned long long v = PyLong_AsUnsignedLongLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
res = SWIG_OverflowError;
}
} else {
unsigned long v;
res = SWIG_AsVal_unsigned_SS_long (obj,&v);
if (SWIG_IsOK(res)) {
if (val) *val = v;
return res;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
const double mant_max = 1LL << DBL_MANT_DIG;
double d;
res = SWIG_AsVal_double (obj,&d);
if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
return SWIG_OverflowError;
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
if (val) *val = (unsigned long long)(d);
return SWIG_AddCast(res);
}
res = SWIG_TypeError;
}
#endif
return res;
}
#endif
SWIGINTERN void _Camera_file_read(struct _Camera *self,char const *folder,char const *file,CameraFileType type,uint64_t offset,char *buf,uint64_t *size,GPContext *context){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_camera_file_read (self, folder, file, type, offset, buf, size, context);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _Camera_file_delete(struct _Camera *self,char const *folder,char const *file,GPContext *context){
int result = gp_camera_file_delete (self, folder, file, context);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_gp_camera_capture_preview(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
CameraFile *arg2 = (CameraFile *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
int new_file2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
arg2 = NULL;
{
arg3 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_capture_preview", 1, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_capture_preview" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_capture_preview" "', argument " "2"" of type '" "CameraFile *""'");
}
arg2 = (CameraFile *)(argp2);
}
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_capture_preview" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
if (!arg2) {
int error = gp_file_new(&arg2);
if (error < GP_OK) {
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
new_file2 = 1;
}
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_capture_preview(arg1,arg2,arg3);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
if (new_file2) {
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg2, SWIGTYPE_p__CameraFile, SWIG_POINTER_OWN));
new_file2 = 0;
}
if (new_file2) gp_file_unref(arg2);
return resultobj;
fail:
if (new_file2) gp_file_unref(arg2);
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraText___str__(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraText *arg1 = (CameraText *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraText___str__ takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraText, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraText___str__" "', argument " "1"" of type '" "CameraText *""'");
}
arg1 = (CameraText *)(argp1);
result = (char *)CameraText___str__(arg1);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraText_text_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraText *arg1 = (CameraText *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraText_text_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraText, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraText_text_get" "', argument " "1"" of type '" "CameraText *""'");
}
arg1 = (CameraText *)(argp1);
result = (char *)(char *) ((arg1)->text);
{
size_t size = SWIG_strnlen(result, 32*1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CameraText(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraText *arg1 = (CameraText *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CameraText takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraText, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraText" "', argument " "1"" of type '" "CameraText *""'");
}
arg1 = (CameraText *)(argp1);
free((char *) arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGPY_REPRFUNC_CLOSURE(_wrap_CameraText___str__) /* defines _wrap_CameraText___str___reprfunc_closure */
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraText) /* defines _wrap_delete_CameraText_destructor_closure */
SWIGINTERN PyObject *_wrap_CameraFilePath_name_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFilePath *arg1 = (CameraFilePath *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFilePath_name_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraFilePath, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFilePath_name_get" "', argument " "1"" of type '" "CameraFilePath *""'");
}
arg1 = (CameraFilePath *)(argp1);
result = (char *)(char *) ((arg1)->name);
{
size_t size = SWIG_strnlen(result, 128);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFilePath_folder_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFilePath *arg1 = (CameraFilePath *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFilePath_folder_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraFilePath, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFilePath_folder_get" "', argument " "1"" of type '" "CameraFilePath *""'");
}
arg1 = (CameraFilePath *)(argp1);
result = (char *)(char *) ((arg1)->folder);
{
size_t size = SWIG_strnlen(result, 1024);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CameraFilePath(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFilePath *arg1 = (CameraFilePath *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CameraFilePath takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraFilePath, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraFilePath" "', argument " "1"" of type '" "CameraFilePath *""'");
}
arg1 = (CameraFilePath *)(argp1);
free((char *) arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraFilePath) /* defines _wrap_delete_CameraFilePath_destructor_closure */
SWIGINTERN int _wrap_new_Camera(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
struct _Camera *result = 0 ;
(void)self;
if (!SWIG_Python_CheckNoKeywords(kwargs, "new_Camera")) SWIG_fail;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "new_Camera takes no arguments");
{
result = (struct _Camera *)new__Camera();
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__Camera, SWIG_BUILTIN_INIT | 0 );
return resultobj == Py_None ? -1 : 0;
fail:
return -1;
}
SWIGINTERN PyObject *_wrap_delete_Camera(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_Camera takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Camera" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
{
delete__Camera(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_autodetect(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList *arg1 = (CameraList *) 0 ;
GPContext *arg2 = (GPContext *) 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
{
arg2 = NULL;
}
{
int error = gp_list_new(&arg1);
if (error < GP_OK) {
arg1 = NULL;
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_autodetect", 0, 1, &obj0)) SWIG_fail;
if (obj0) {
res2 = SWIG_ConvertPtr(obj0, &argp2,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_autodetect" "', argument " "2"" of type '" "GPContext *""'");
}
arg2 = (GPContext *)(argp2);
}
{
_Camera_autodetect(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg1, SWIGTYPE_p__CameraList, SWIG_POINTER_OWN));
arg1 = NULL;
}
{
if (arg1 != NULL) {
gp_list_unref(arg1);
}
}
return resultobj;
fail:
{
if (arg1 != NULL) {
gp_list_unref(arg1);
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_set_abilities(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
CameraAbilities arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_set_abilities", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_set_abilities" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CameraAbilities, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_set_abilities" "', argument " "2"" of type '" "CameraAbilities""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Camera_set_abilities" "', argument " "2"" of type '" "CameraAbilities""'");
} else {
arg2 = *((CameraAbilities *)(argp2));
}
}
{
_Camera_set_abilities(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_get_abilities(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
CameraAbilities *arg2 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
{
arg2 = (CameraAbilities *)calloc(1, sizeof(CameraAbilities));
if (arg2 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraAbilities");
SWIG_fail;
}
}
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "Camera_get_abilities takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_get_abilities" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
{
_Camera_get_abilities(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg2, SWIGTYPE_p_CameraAbilities, SWIG_POINTER_OWN));
arg2 = NULL;
}
{
free(arg2);
}
return resultobj;
fail:
{
free(arg2);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_set_port_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
GPPortInfo arg2 = (GPPortInfo) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_set_port_info", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_set_port_info" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPPortInfo, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_set_port_info" "', argument " "2"" of type '" "GPPortInfo""'");
}
arg2 = (GPPortInfo)(argp2);
{
_Camera_set_port_info(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_get_port_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
GPPortInfo *arg2 = (GPPortInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
GPPortInfo temp2 ;
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "Camera_get_port_info takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_get_port_info" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
{
_Camera_get_port_info(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p__GPPortInfo, 0));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_set_port_speed(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_set_port_speed", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_set_port_speed" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Camera_set_port_speed" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
{
_Camera_set_port_speed(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_get_port_speed(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "Camera_get_port_speed takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_get_port_speed" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
{
result = (int)_Camera_get_port_speed(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_init(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
GPContext *arg2 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj1 = 0 ;
{
arg2 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_init", 0, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_init" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_init" "', argument " "2"" of type '" "GPContext *""'");
}
arg2 = (GPContext *)(argp2);
}
{
_Camera_init(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_exit(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
GPContext *arg2 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj1 = 0 ;
{
arg2 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_exit", 0, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_exit" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_exit" "', argument " "2"" of type '" "GPContext *""'");
}
arg2 = (GPContext *)(argp2);
}
{
_Camera_exit(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_get_config(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
CameraWidget **arg2 = (CameraWidget **) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraWidget *temp2 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj1 = 0 ;
{
arg3 = NULL;
}
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_get_config", 0, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_get_config" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
if (obj1) {
res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_get_config" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
_Camera_get_config(arg1,arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
// Append result to output object
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p__CameraWidget, SWIG_POINTER_OWN));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_list_config(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
CameraList *arg2 = (CameraList *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj1 = 0 ;
{
arg3 = NULL;
}
{
int error = gp_list_new(&arg2);
if (error < GP_OK) {
arg2 = NULL;
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_list_config", 0, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_list_config" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
if (obj1) {
res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_list_config" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
_Camera_list_config(arg1,arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg2, SWIGTYPE_p__CameraList, SWIG_POINTER_OWN));
arg2 = NULL;
}
{
if (arg2 != NULL) {
gp_list_unref(arg2);
}
}
return resultobj;
fail:
{
if (arg2 != NULL) {
gp_list_unref(arg2);
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_get_single_config(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
CameraWidget **arg3 = (CameraWidget **) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
CameraWidget *temp3 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
arg4 = NULL;
}
{
temp3 = NULL;
arg3 = &temp3;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_get_single_config", 1, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_get_single_config" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_get_single_config" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (obj2) {
res4 = SWIG_ConvertPtr(obj2, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Camera_get_single_config" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
_Camera_get_single_config(arg1,(char const *)arg2,arg3,arg4);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
// Append result to output object
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p__CameraWidget, SWIG_POINTER_OWN));
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_set_config(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
CameraWidget *arg2 = (CameraWidget *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
arg3 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_set_config", 1, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_set_config" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__CameraWidget, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_set_config" "', argument " "2"" of type '" "CameraWidget *""'");
}
arg2 = (CameraWidget *)(argp2);
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_set_config" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
_Camera_set_config(arg1,arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_set_single_config(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
CameraWidget *arg3 = (CameraWidget *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
{
arg4 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_set_single_config", 2, 3, &obj1, &obj2, &obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_set_single_config" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_set_single_config" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__CameraWidget, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_set_single_config" "', argument " "3"" of type '" "CameraWidget *""'");
}
arg3 = (CameraWidget *)(argp3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Camera_set_single_config" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
_Camera_set_single_config(arg1,(char const *)arg2,arg3,arg4);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_get_summary(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
CameraText *arg2 = (CameraText *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj1 = 0 ;
{
arg3 = NULL;
}
{
arg2 = (CameraText *)calloc(1, sizeof(CameraText));
if (arg2 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraText");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_get_summary", 0, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_get_summary" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
if (obj1) {
res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_get_summary" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
_Camera_get_summary(arg1,arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg2, SWIGTYPE_p_CameraText, SWIG_POINTER_OWN));
arg2 = NULL;
}
{
free(arg2);
}
return resultobj;
fail:
{
free(arg2);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_get_manual(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
CameraText *arg2 = (CameraText *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj1 = 0 ;
{
arg3 = NULL;
}
{
arg2 = (CameraText *)calloc(1, sizeof(CameraText));
if (arg2 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraText");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_get_manual", 0, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_get_manual" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
if (obj1) {
res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_get_manual" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
_Camera_get_manual(arg1,arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg2, SWIGTYPE_p_CameraText, SWIG_POINTER_OWN));
arg2 = NULL;
}
{
free(arg2);
}
return resultobj;
fail:
{
free(arg2);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_get_about(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
CameraText *arg2 = (CameraText *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj1 = 0 ;
{
arg3 = NULL;
}
{
arg2 = (CameraText *)calloc(1, sizeof(CameraText));
if (arg2 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraText");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_get_about", 0, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_get_about" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
if (obj1) {
res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_get_about" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
_Camera_get_about(arg1,arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg2, SWIGTYPE_p_CameraText, SWIG_POINTER_OWN));
arg2 = NULL;
}
{
free(arg2);
}
return resultobj;
fail:
{
free(arg2);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_capture(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
CameraCaptureType arg2 ;
CameraFilePath *arg3 = (CameraFilePath *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
arg4 = NULL;
}
{
arg3 = (CameraFilePath *)calloc(1, sizeof(CameraFilePath));
if (arg3 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraFilePath");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_capture", 1, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_capture" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Camera_capture" "', argument " "2"" of type '" "CameraCaptureType""'");
}
arg2 = (CameraCaptureType)(val2);
if (obj2) {
res4 = SWIG_ConvertPtr(obj2, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Camera_capture" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
_Camera_capture(arg1,arg2,arg3,arg4);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg3, SWIGTYPE_p_CameraFilePath, SWIG_POINTER_OWN));
arg3 = NULL;
}
{
free(arg3);
}
return resultobj;
fail:
{
free(arg3);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_trigger_capture(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
GPContext *arg2 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj1 = 0 ;
{
arg2 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_trigger_capture", 0, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_trigger_capture" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_trigger_capture" "', argument " "2"" of type '" "GPContext *""'");
}
arg2 = (GPContext *)(argp2);
}
{
_Camera_trigger_capture(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_capture_preview(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
CameraFile *arg2 = (CameraFile *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
int new_file2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
arg2 = NULL;
{
arg3 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_capture_preview", 0, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_capture_preview" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_capture_preview" "', argument " "2"" of type '" "CameraFile *""'");
}
arg2 = (CameraFile *)(argp2);
}
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_capture_preview" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
if (!arg2) {
int error = gp_file_new(&arg2);
if (error < GP_OK) {
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
new_file2 = 1;
}
}
{
_Camera_capture_preview(arg1,arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (new_file2) {
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg2, SWIGTYPE_p__CameraFile, SWIG_POINTER_OWN));
new_file2 = 0;
}
if (new_file2) gp_file_unref(arg2);
return resultobj;
fail:
if (new_file2) gp_file_unref(arg2);
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_wait_for_event(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
int arg2 ;
CameraEventType *arg3 = (CameraEventType *) 0 ;
void **arg4 = (void **) 0 ;
GPContext *arg5 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
CameraEventType temp_type3 ;
void *temp_data3 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
arg5 = NULL;
}
{
temp_type3 = -1;
temp_data3 = NULL;
arg3 = &temp_type3;
arg4 = &temp_data3;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_wait_for_event", 1, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_wait_for_event" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Camera_wait_for_event" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
if (obj2) {
res5 = SWIG_ConvertPtr(obj2, &argp5,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Camera_wait_for_event" "', argument " "5"" of type '" "GPContext *""'");
}
arg5 = (GPContext *)(argp5);
}
{
_Camera_wait_for_event(arg1,arg2,arg3,arg4,arg5);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong(*arg3));
if (*arg3 == GP_EVENT_FILE_ADDED || *arg3 == GP_EVENT_FOLDER_ADDED
|| *arg3 == GP_EVENT_FILE_CHANGED) {
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg4, SWIGTYPE_p_CameraFilePath, SWIG_POINTER_OWN));
}
else if (*arg3 == GP_EVENT_UNKNOWN && *arg4 != NULL) {
resultobj = SWIG_Python_AppendOutput(resultobj, PyString_FromString(*arg4));
free(*arg4);
}
else {
Py_INCREF(Py_None);
resultobj = SWIG_Python_AppendOutput(resultobj, Py_None);
if (*arg4 != NULL)
free(*arg4);
}
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_get_storageinfo(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
CameraStorageInformation **arg2 = (CameraStorageInformation **) 0 ;
int *arg3 = (int *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraStorageInformation *temp_ptr2 ;
int temp_cnt2 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj1 = 0 ;
{
arg4 = NULL;
}
{
temp_ptr2 = NULL;
temp_cnt2 = 0;
arg2 = &temp_ptr2;
arg3 = &temp_cnt2;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_get_storageinfo", 0, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_get_storageinfo" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
if (obj1) {
res4 = SWIG_ConvertPtr(obj1, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Camera_get_storageinfo" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
_Camera_get_storageinfo(arg1,arg2,arg3,arg4);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
// copy single array of CameraStorageInformation to individual Python objects
PyObject* out_list = PyList_New(*arg3);
int n;
for (n = 0; n < *arg3; n++) {
CameraStorageInformation* new_sif = malloc(sizeof(CameraStorageInformation));
if (new_sif == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraStorageInformation *");
SWIG_fail;
}
memcpy(new_sif, &(*arg2)[n], sizeof(CameraStorageInformation));
PyList_SetItem(out_list, n,
SWIG_NewPointerObj(new_sif, SWIGTYPE_p__CameraStorageInformation, SWIG_POINTER_OWN));
}
resultobj = SWIG_Python_AppendOutput(resultobj, out_list);
}
{
// deallocate CameraStorageInformation array allocated by gp_camera_get_storageinfo
free(*arg2);
}
return resultobj;
fail:
{
// deallocate CameraStorageInformation array allocated by gp_camera_get_storageinfo
free(*arg2);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_folder_list_files(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
CameraList *arg3 = (CameraList *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
arg4 = NULL;
}
{
int error = gp_list_new(&arg3);
if (error < GP_OK) {
arg3 = NULL;
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_folder_list_files", 1, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_folder_list_files" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_folder_list_files" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (obj2) {
res4 = SWIG_ConvertPtr(obj2, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Camera_folder_list_files" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
_Camera_folder_list_files(arg1,(char const *)arg2,arg3,arg4);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg3, SWIGTYPE_p__CameraList, SWIG_POINTER_OWN));
arg3 = NULL;
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
{
if (arg3 != NULL) {
gp_list_unref(arg3);
}
}
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
{
if (arg3 != NULL) {
gp_list_unref(arg3);
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_folder_list_folders(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
CameraList *arg3 = (CameraList *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
arg4 = NULL;
}
{
int error = gp_list_new(&arg3);
if (error < GP_OK) {
arg3 = NULL;
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_folder_list_folders", 1, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_folder_list_folders" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_folder_list_folders" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (obj2) {
res4 = SWIG_ConvertPtr(obj2, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Camera_folder_list_folders" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
_Camera_folder_list_folders(arg1,(char const *)arg2,arg3,arg4);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg3, SWIGTYPE_p__CameraList, SWIG_POINTER_OWN));
arg3 = NULL;
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
{
if (arg3 != NULL) {
gp_list_unref(arg3);
}
}
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
{
if (arg3 != NULL) {
gp_list_unref(arg3);
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_folder_delete_all(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
arg3 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_folder_delete_all", 1, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_folder_delete_all" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_folder_delete_all" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_folder_delete_all" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
_Camera_folder_delete_all(arg1,(char const *)arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_folder_put_file(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
CameraFileType arg4 ;
CameraFile *arg5 = (CameraFile *) 0 ;
GPContext *arg6 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
{
arg6 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_folder_put_file", 4, 5, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_folder_put_file" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_folder_put_file" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_folder_put_file" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Camera_folder_put_file" "', argument " "4"" of type '" "CameraFileType""'");
}
arg4 = (CameraFileType)(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Camera_folder_put_file" "', argument " "5"" of type '" "CameraFile *""'");
}
arg5 = (CameraFile *)(argp5);
if (obj5) {
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Camera_folder_put_file" "', argument " "6"" of type '" "GPContext *""'");
}
arg6 = (GPContext *)(argp6);
}
{
_Camera_folder_put_file(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_folder_make_dir(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
{
arg4 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_folder_make_dir", 2, 3, &obj1, &obj2, &obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_folder_make_dir" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_folder_make_dir" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_folder_make_dir" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Camera_folder_make_dir" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
_Camera_folder_make_dir(arg1,(char const *)arg2,(char const *)arg3,arg4);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_folder_remove_dir(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
{
arg4 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_folder_remove_dir", 2, 3, &obj1, &obj2, &obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_folder_remove_dir" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_folder_remove_dir" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_folder_remove_dir" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Camera_folder_remove_dir" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
_Camera_folder_remove_dir(arg1,(char const *)arg2,(char const *)arg3,arg4);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_file_get_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
CameraFileInfo *arg4 = (CameraFileInfo *) 0 ;
GPContext *arg5 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
{
arg5 = NULL;
}
{
arg4 = (CameraFileInfo *)calloc(1, sizeof(CameraFileInfo));
if (arg4 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraFileInfo");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_file_get_info", 2, 3, &obj1, &obj2, &obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_file_get_info" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_file_get_info" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_file_get_info" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
if (obj3) {
res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Camera_file_get_info" "', argument " "5"" of type '" "GPContext *""'");
}
arg5 = (GPContext *)(argp5);
}
{
_Camera_file_get_info(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg4, SWIGTYPE_p__CameraFileInfo, SWIG_POINTER_OWN));
arg4 = NULL;
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
{
free(arg4);
}
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
{
free(arg4);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_file_set_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
CameraFileInfo arg4 ;
GPContext *arg5 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
void *argp4 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
{
arg5 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_file_set_info", 3, 4, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_file_set_info" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_file_set_info" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_file_set_info" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p__CameraFileInfo, 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Camera_file_set_info" "', argument " "4"" of type '" "CameraFileInfo""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Camera_file_set_info" "', argument " "4"" of type '" "CameraFileInfo""'");
} else {
arg4 = *((CameraFileInfo *)(argp4));
}
}
if (obj4) {
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Camera_file_set_info" "', argument " "5"" of type '" "GPContext *""'");
}
arg5 = (GPContext *)(argp5);
}
{
_Camera_file_set_info(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_file_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
CameraFileType arg4 ;
CameraFile *arg5 = (CameraFile *) 0 ;
GPContext *arg6 = (GPContext *) 0 ;
int new_file5 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
arg5 = NULL;
{
arg6 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_file_get", 3, 5, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_file_get" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_file_get" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_file_get" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Camera_file_get" "', argument " "4"" of type '" "CameraFileType""'");
}
arg4 = (CameraFileType)(val4);
if (obj4) {
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Camera_file_get" "', argument " "5"" of type '" "CameraFile *""'");
}
arg5 = (CameraFile *)(argp5);
}
if (obj5) {
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Camera_file_get" "', argument " "6"" of type '" "GPContext *""'");
}
arg6 = (GPContext *)(argp6);
}
{
if (!arg5) {
int error = gp_file_new(&arg5);
if (error < GP_OK) {
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
new_file5 = 1;
}
}
{
_Camera_file_get(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (new_file5) {
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg5, SWIGTYPE_p__CameraFile, SWIG_POINTER_OWN));
new_file5 = 0;
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
if (new_file5) gp_file_unref(arg5);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
if (new_file5) gp_file_unref(arg5);
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_file_read(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
CameraFileType arg4 ;
uint64_t arg5 ;
char *arg6 = (char *) 0 ;
uint64_t *arg7 = (uint64_t *) 0 ;
GPContext *arg8 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int val4 ;
int ecode4 = 0 ;
unsigned long long val5 ;
int ecode5 = 0 ;
uint64_t temp6 ;
void *argp8 = 0 ;
int res8 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
{
arg8 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_file_read", 5, 6, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_file_read" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_file_read" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_file_read" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Camera_file_read" "', argument " "4"" of type '" "CameraFileType""'");
}
arg4 = (CameraFileType)(val4);
ecode5 = SWIG_AsVal_unsigned_SS_long_SS_long(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Camera_file_read" "', argument " "5"" of type '" "uint64_t""'");
}
arg5 = (uint64_t)(val5);
{
Py_buffer view;
if (PyObject_CheckBuffer(obj5) != 1) {
PyErr_SetString(
PyExc_TypeError,
"in method 'Camera_file_read', argument 6 does not support the buffer interface");
SWIG_fail;
}
if (PyObject_GetBuffer(obj5, &view, PyBUF_SIMPLE | PyBUF_WRITABLE) != 0) {
PyErr_SetString(
PyExc_TypeError,
"in method 'Camera_file_read', argument 6 does not export a writable buffer");
SWIG_fail;
}
arg6 = view.buf;
temp6 = view.len;
arg7 = &temp6;
PyBuffer_Release(&view);
}
if (obj6) {
res8 = SWIG_ConvertPtr(obj6, &argp8,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Camera_file_read" "', argument " "8"" of type '" "GPContext *""'");
}
arg8 = (GPContext *)(argp8);
}
{
_Camera_file_read(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj, PyLong_FromUnsignedLongLong(*arg7));
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_Camera_file_delete(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _Camera *arg1 = (struct _Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
{
arg4 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Camera_file_delete", 2, 3, &obj1, &obj2, &obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_file_delete" "', argument " "1"" of type '" "struct _Camera *""'");
}
arg1 = (struct _Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Camera_file_delete" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Camera_file_delete" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Camera_file_delete" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
_Camera_file_delete(arg1,(char const *)arg2,(char const *)arg3,arg4);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_Camera) /* defines _wrap_delete_Camera_destructor_closure */
SWIGINTERN PyObject *_wrap_gp_camera_new(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera **arg1 = (Camera **) 0 ;
Camera *temp1 ;
int result;
{
temp1 = NULL;
arg1 = &temp1;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_new", 0, 0)) SWIG_fail;
result = (int)gp_camera_new(arg1);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg1, SWIGTYPE_p__Camera, SWIG_POINTER_OWN));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_set_abilities(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
CameraAbilities arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_set_abilities", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_set_abilities" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CameraAbilities, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_set_abilities" "', argument " "2"" of type '" "CameraAbilities""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gp_camera_set_abilities" "', argument " "2"" of type '" "CameraAbilities""'");
} else {
arg2 = *((CameraAbilities *)(argp2));
}
}
result = (int)gp_camera_set_abilities(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_get_abilities(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
CameraAbilities *arg2 = (CameraAbilities *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
{
arg2 = (CameraAbilities *)calloc(1, sizeof(CameraAbilities));
if (arg2 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraAbilities");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_get_abilities", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_get_abilities" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
result = (int)gp_camera_get_abilities(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg2, SWIGTYPE_p_CameraAbilities, SWIG_POINTER_OWN));
arg2 = NULL;
}
{
free(arg2);
}
return resultobj;
fail:
{
free(arg2);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_set_port_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
GPPortInfo arg2 = (GPPortInfo) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_set_port_info", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_set_port_info" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPPortInfo, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_set_port_info" "', argument " "2"" of type '" "GPPortInfo""'");
}
arg2 = (GPPortInfo)(argp2);
result = (int)gp_camera_set_port_info(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_get_port_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
GPPortInfo *arg2 = (GPPortInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
GPPortInfo temp2 ;
PyObject * obj0 = 0 ;
int result;
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_get_port_info", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_get_port_info" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
result = (int)gp_camera_get_port_info(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p__GPPortInfo, 0));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_set_port_speed(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_set_port_speed", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_set_port_speed" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gp_camera_set_port_speed" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
result = (int)gp_camera_set_port_speed(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_get_port_speed(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_get_port_speed", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_get_port_speed" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
result = (int)gp_camera_get_port_speed(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_autodetect(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList *arg1 = (CameraList *) 0 ;
GPContext *arg2 = (GPContext *) 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
int result;
{
arg2 = NULL;
}
{
int error = gp_list_new(&arg1);
if (error < GP_OK) {
arg1 = NULL;
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_autodetect", 0, 1, &obj0)) SWIG_fail;
if (obj0) {
res2 = SWIG_ConvertPtr(obj0, &argp2,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_autodetect" "', argument " "2"" of type '" "GPContext *""'");
}
arg2 = (GPContext *)(argp2);
}
result = (int)gp_camera_autodetect(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg1, SWIGTYPE_p__CameraList, SWIG_POINTER_OWN));
arg1 = NULL;
}
{
if (arg1 != NULL) {
gp_list_unref(arg1);
}
}
return resultobj;
fail:
{
if (arg1 != NULL) {
gp_list_unref(arg1);
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_init(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
GPContext *arg2 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
arg2 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_init", 1, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_init" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_init" "', argument " "2"" of type '" "GPContext *""'");
}
arg2 = (GPContext *)(argp2);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_init(arg1,arg2);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_exit(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
GPContext *arg2 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
arg2 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_exit", 1, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_exit" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_exit" "', argument " "2"" of type '" "GPContext *""'");
}
arg2 = (GPContext *)(argp2);
}
result = (int)gp_camera_exit(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_get_config(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
CameraWidget **arg2 = (CameraWidget **) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraWidget *temp2 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
arg3 = NULL;
}
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_get_config", 1, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_get_config" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
if (obj1) {
res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_get_config" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_get_config(arg1,arg2,arg3);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
{
// Append result to output object
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p__CameraWidget, SWIG_POINTER_OWN));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_list_config(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
CameraList *arg2 = (CameraList *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
arg3 = NULL;
}
{
int error = gp_list_new(&arg2);
if (error < GP_OK) {
arg2 = NULL;
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_list_config", 1, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_list_config" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
if (obj1) {
res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_list_config" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
result = (int)gp_camera_list_config(arg1,arg2,arg3);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg2, SWIGTYPE_p__CameraList, SWIG_POINTER_OWN));
arg2 = NULL;
}
{
if (arg2 != NULL) {
gp_list_unref(arg2);
}
}
return resultobj;
fail:
{
if (arg2 != NULL) {
gp_list_unref(arg2);
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_get_single_config(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
CameraWidget **arg3 = (CameraWidget **) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
CameraWidget *temp3 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
{
arg4 = NULL;
}
{
temp3 = NULL;
arg3 = &temp3;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_get_single_config", 2, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_get_single_config" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_get_single_config" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (obj2) {
res4 = SWIG_ConvertPtr(obj2, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gp_camera_get_single_config" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_get_single_config(arg1,(char const *)arg2,arg3,arg4);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
{
// Append result to output object
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p__CameraWidget, SWIG_POINTER_OWN));
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_set_config(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
CameraWidget *arg2 = (CameraWidget *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
{
arg3 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_set_config", 2, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_set_config" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__CameraWidget, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_set_config" "', argument " "2"" of type '" "CameraWidget *""'");
}
arg2 = (CameraWidget *)(argp2);
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_set_config" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_set_config(arg1,arg2,arg3);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_set_single_config(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
CameraWidget *arg3 = (CameraWidget *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
{
arg4 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_set_single_config", 3, 4, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_set_single_config" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_set_single_config" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__CameraWidget, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_set_single_config" "', argument " "3"" of type '" "CameraWidget *""'");
}
arg3 = (CameraWidget *)(argp3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gp_camera_set_single_config" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_set_single_config(arg1,(char const *)arg2,arg3,arg4);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_get_summary(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
CameraText *arg2 = (CameraText *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
arg3 = NULL;
}
{
arg2 = (CameraText *)calloc(1, sizeof(CameraText));
if (arg2 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraText");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_get_summary", 1, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_get_summary" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
if (obj1) {
res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_get_summary" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
result = (int)gp_camera_get_summary(arg1,arg2,arg3);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg2, SWIGTYPE_p_CameraText, SWIG_POINTER_OWN));
arg2 = NULL;
}
{
free(arg2);
}
return resultobj;
fail:
{
free(arg2);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_get_manual(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
CameraText *arg2 = (CameraText *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
arg3 = NULL;
}
{
arg2 = (CameraText *)calloc(1, sizeof(CameraText));
if (arg2 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraText");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_get_manual", 1, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_get_manual" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
if (obj1) {
res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_get_manual" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
result = (int)gp_camera_get_manual(arg1,arg2,arg3);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg2, SWIGTYPE_p_CameraText, SWIG_POINTER_OWN));
arg2 = NULL;
}
{
free(arg2);
}
return resultobj;
fail:
{
free(arg2);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_get_about(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
CameraText *arg2 = (CameraText *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
arg3 = NULL;
}
{
arg2 = (CameraText *)calloc(1, sizeof(CameraText));
if (arg2 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraText");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_get_about", 1, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_get_about" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
if (obj1) {
res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_get_about" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
result = (int)gp_camera_get_about(arg1,arg2,arg3);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg2, SWIGTYPE_p_CameraText, SWIG_POINTER_OWN));
arg2 = NULL;
}
{
free(arg2);
}
return resultobj;
fail:
{
free(arg2);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_capture(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
CameraCaptureType arg2 ;
CameraFilePath *arg3 = (CameraFilePath *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
{
arg4 = NULL;
}
{
arg3 = (CameraFilePath *)calloc(1, sizeof(CameraFilePath));
if (arg3 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraFilePath");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_capture", 2, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_capture" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gp_camera_capture" "', argument " "2"" of type '" "CameraCaptureType""'");
}
arg2 = (CameraCaptureType)(val2);
if (obj2) {
res4 = SWIG_ConvertPtr(obj2, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gp_camera_capture" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_capture(arg1,arg2,arg3,arg4);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg3, SWIGTYPE_p_CameraFilePath, SWIG_POINTER_OWN));
arg3 = NULL;
}
{
free(arg3);
}
return resultobj;
fail:
{
free(arg3);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_trigger_capture(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
GPContext *arg2 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
arg2 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_trigger_capture", 1, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_trigger_capture" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_trigger_capture" "', argument " "2"" of type '" "GPContext *""'");
}
arg2 = (GPContext *)(argp2);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_trigger_capture(arg1,arg2);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_wait_for_event(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
int arg2 ;
CameraEventType *arg3 = (CameraEventType *) 0 ;
void **arg4 = (void **) 0 ;
GPContext *arg5 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
CameraEventType temp_type3 ;
void *temp_data3 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
{
arg5 = NULL;
}
{
temp_type3 = -1;
temp_data3 = NULL;
arg3 = &temp_type3;
arg4 = &temp_data3;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_wait_for_event", 2, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_wait_for_event" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gp_camera_wait_for_event" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
if (obj2) {
res5 = SWIG_ConvertPtr(obj2, &argp5,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gp_camera_wait_for_event" "', argument " "5"" of type '" "GPContext *""'");
}
arg5 = (GPContext *)(argp5);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_wait_for_event(arg1,arg2,arg3,arg4,arg5);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong(*arg3));
if (*arg3 == GP_EVENT_FILE_ADDED || *arg3 == GP_EVENT_FOLDER_ADDED
|| *arg3 == GP_EVENT_FILE_CHANGED) {
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg4, SWIGTYPE_p_CameraFilePath, SWIG_POINTER_OWN));
}
else if (*arg3 == GP_EVENT_UNKNOWN && *arg4 != NULL) {
resultobj = SWIG_Python_AppendOutput(resultobj, PyString_FromString(*arg4));
free(*arg4);
}
else {
Py_INCREF(Py_None);
resultobj = SWIG_Python_AppendOutput(resultobj, Py_None);
if (*arg4 != NULL)
free(*arg4);
}
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_get_storageinfo(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
CameraStorageInformation **arg2 = (CameraStorageInformation **) 0 ;
int *arg3 = (int *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraStorageInformation *temp_ptr2 ;
int temp_cnt2 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
arg4 = NULL;
}
{
temp_ptr2 = NULL;
temp_cnt2 = 0;
arg2 = &temp_ptr2;
arg3 = &temp_cnt2;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_get_storageinfo", 1, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_get_storageinfo" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
if (obj1) {
res4 = SWIG_ConvertPtr(obj1, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gp_camera_get_storageinfo" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
result = (int)gp_camera_get_storageinfo(arg1,arg2,arg3,arg4);
resultobj = SWIG_From_int((int)(result));
{
// copy single array of CameraStorageInformation to individual Python objects
PyObject* out_list = PyList_New(*arg3);
int n;
for (n = 0; n < *arg3; n++) {
CameraStorageInformation* new_sif = malloc(sizeof(CameraStorageInformation));
if (new_sif == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraStorageInformation *");
SWIG_fail;
}
memcpy(new_sif, &(*arg2)[n], sizeof(CameraStorageInformation));
PyList_SetItem(out_list, n,
SWIG_NewPointerObj(new_sif, SWIGTYPE_p__CameraStorageInformation, SWIG_POINTER_OWN));
}
resultobj = SWIG_Python_AppendOutput(resultobj, out_list);
}
{
// deallocate CameraStorageInformation array allocated by gp_camera_get_storageinfo
free(*arg2);
}
return resultobj;
fail:
{
// deallocate CameraStorageInformation array allocated by gp_camera_get_storageinfo
free(*arg2);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_folder_list_files(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
CameraList *arg3 = (CameraList *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
{
arg4 = NULL;
}
{
int error = gp_list_new(&arg3);
if (error < GP_OK) {
arg3 = NULL;
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_folder_list_files", 2, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_folder_list_files" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_folder_list_files" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (obj2) {
res4 = SWIG_ConvertPtr(obj2, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gp_camera_folder_list_files" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_folder_list_files(arg1,(char const *)arg2,arg3,arg4);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg3, SWIGTYPE_p__CameraList, SWIG_POINTER_OWN));
arg3 = NULL;
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
{
if (arg3 != NULL) {
gp_list_unref(arg3);
}
}
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
{
if (arg3 != NULL) {
gp_list_unref(arg3);
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_folder_list_folders(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
CameraList *arg3 = (CameraList *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
{
arg4 = NULL;
}
{
int error = gp_list_new(&arg3);
if (error < GP_OK) {
arg3 = NULL;
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_folder_list_folders", 2, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_folder_list_folders" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_folder_list_folders" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (obj2) {
res4 = SWIG_ConvertPtr(obj2, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gp_camera_folder_list_folders" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_folder_list_folders(arg1,(char const *)arg2,arg3,arg4);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg3, SWIGTYPE_p__CameraList, SWIG_POINTER_OWN));
arg3 = NULL;
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
{
if (arg3 != NULL) {
gp_list_unref(arg3);
}
}
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
{
if (arg3 != NULL) {
gp_list_unref(arg3);
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_folder_delete_all(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
GPContext *arg3 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
{
arg3 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_folder_delete_all", 2, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_folder_delete_all" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_folder_delete_all" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_folder_delete_all" "', argument " "3"" of type '" "GPContext *""'");
}
arg3 = (GPContext *)(argp3);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_folder_delete_all(arg1,(char const *)arg2,arg3);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_folder_put_file(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
CameraFileType arg4 ;
CameraFile *arg5 = (CameraFile *) 0 ;
GPContext *arg6 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
int result;
{
arg6 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_folder_put_file", 5, 6, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_folder_put_file" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_folder_put_file" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_folder_put_file" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gp_camera_folder_put_file" "', argument " "4"" of type '" "CameraFileType""'");
}
arg4 = (CameraFileType)(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gp_camera_folder_put_file" "', argument " "5"" of type '" "CameraFile *""'");
}
arg5 = (CameraFile *)(argp5);
if (obj5) {
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gp_camera_folder_put_file" "', argument " "6"" of type '" "GPContext *""'");
}
arg6 = (GPContext *)(argp6);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_folder_put_file(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_folder_make_dir(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
{
arg4 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_folder_make_dir", 3, 4, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_folder_make_dir" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_folder_make_dir" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_folder_make_dir" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gp_camera_folder_make_dir" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
result = (int)gp_camera_folder_make_dir(arg1,(char const *)arg2,(char const *)arg3,arg4);
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_folder_remove_dir(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
{
arg4 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_folder_remove_dir", 3, 4, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_folder_remove_dir" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_folder_remove_dir" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_folder_remove_dir" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gp_camera_folder_remove_dir" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
result = (int)gp_camera_folder_remove_dir(arg1,(char const *)arg2,(char const *)arg3,arg4);
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_file_get_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
CameraFileInfo *arg4 = (CameraFileInfo *) 0 ;
GPContext *arg5 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
{
arg5 = NULL;
}
{
arg4 = (CameraFileInfo *)calloc(1, sizeof(CameraFileInfo));
if (arg4 == NULL) {
PyErr_SetString(PyExc_MemoryError, "Cannot allocate " "CameraFileInfo");
SWIG_fail;
}
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_file_get_info", 3, 4, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_file_get_info" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_file_get_info" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_file_get_info" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
if (obj3) {
res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gp_camera_file_get_info" "', argument " "5"" of type '" "GPContext *""'");
}
arg5 = (GPContext *)(argp5);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_file_get_info(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg4, SWIGTYPE_p__CameraFileInfo, SWIG_POINTER_OWN));
arg4 = NULL;
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
{
free(arg4);
}
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
{
free(arg4);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_file_set_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
CameraFileInfo arg4 ;
GPContext *arg5 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
void *argp4 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
int result;
{
arg5 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_file_set_info", 4, 5, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_file_set_info" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_file_set_info" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_file_set_info" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p__CameraFileInfo, 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gp_camera_file_set_info" "', argument " "4"" of type '" "CameraFileInfo""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gp_camera_file_set_info" "', argument " "4"" of type '" "CameraFileInfo""'");
} else {
arg4 = *((CameraFileInfo *)(argp4));
}
}
if (obj4) {
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gp_camera_file_set_info" "', argument " "5"" of type '" "GPContext *""'");
}
arg5 = (GPContext *)(argp5);
}
result = (int)gp_camera_file_set_info(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_file_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
CameraFileType arg4 ;
CameraFile *arg5 = (CameraFile *) 0 ;
GPContext *arg6 = (GPContext *) 0 ;
int new_file5 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
int result;
arg5 = NULL;
{
arg6 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_file_get", 4, 6, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_file_get" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_file_get" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_file_get" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gp_camera_file_get" "', argument " "4"" of type '" "CameraFileType""'");
}
arg4 = (CameraFileType)(val4);
if (obj4) {
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gp_camera_file_get" "', argument " "5"" of type '" "CameraFile *""'");
}
arg5 = (CameraFile *)(argp5);
}
if (obj5) {
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gp_camera_file_get" "', argument " "6"" of type '" "GPContext *""'");
}
arg6 = (GPContext *)(argp6);
}
{
if (!arg5) {
int error = gp_file_new(&arg5);
if (error < GP_OK) {
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
SWIG_fail;
}
new_file5 = 1;
}
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_file_get(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
if (new_file5) {
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(arg5, SWIGTYPE_p__CameraFile, SWIG_POINTER_OWN));
new_file5 = 0;
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
if (new_file5) gp_file_unref(arg5);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
if (new_file5) gp_file_unref(arg5);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_file_read(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
CameraFileType arg4 ;
uint64_t arg5 ;
char *arg6 = (char *) 0 ;
uint64_t *arg7 = (uint64_t *) 0 ;
GPContext *arg8 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int val4 ;
int ecode4 = 0 ;
unsigned long long val5 ;
int ecode5 = 0 ;
uint64_t temp6 ;
void *argp8 = 0 ;
int res8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
int result;
{
arg8 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_file_read", 6, 7, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_file_read" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_file_read" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_file_read" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gp_camera_file_read" "', argument " "4"" of type '" "CameraFileType""'");
}
arg4 = (CameraFileType)(val4);
ecode5 = SWIG_AsVal_unsigned_SS_long_SS_long(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gp_camera_file_read" "', argument " "5"" of type '" "uint64_t""'");
}
arg5 = (uint64_t)(val5);
{
Py_buffer view;
if (PyObject_CheckBuffer(obj5) != 1) {
PyErr_SetString(
PyExc_TypeError,
"in method 'gp_camera_file_read', argument 6 does not support the buffer interface");
SWIG_fail;
}
if (PyObject_GetBuffer(obj5, &view, PyBUF_SIMPLE | PyBUF_WRITABLE) != 0) {
PyErr_SetString(
PyExc_TypeError,
"in method 'gp_camera_file_read', argument 6 does not export a writable buffer");
SWIG_fail;
}
arg6 = view.buf;
temp6 = view.len;
arg7 = &temp6;
PyBuffer_Release(&view);
}
if (obj6) {
res8 = SWIG_ConvertPtr(obj6, &argp8,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "gp_camera_file_read" "', argument " "8"" of type '" "GPContext *""'");
}
arg8 = (GPContext *)(argp8);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_camera_file_read(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(resultobj, PyLong_FromUnsignedLongLong(*arg7));
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_camera_file_delete(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Camera *arg1 = (Camera *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
GPContext *arg4 = (GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
{
arg4 = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_camera_file_delete", 3, 4, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__Camera, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_camera_file_delete" "', argument " "1"" of type '" "Camera *""'");
}
arg1 = (Camera *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_camera_file_delete" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_camera_file_delete" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gp_camera_file_delete" "', argument " "4"" of type '" "GPContext *""'");
}
arg4 = (GPContext *)(argp4);
}
result = (int)gp_camera_file_delete(arg1,(char const *)arg2,(char const *)arg3,arg4);
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
static PyMethodDef SwigMethods[] = {
{ "gp_camera_capture_preview", _wrap_gp_camera_capture_preview, METH_VARARGS, "\n"
"gp_camera_capture_preview(camera, camera_file, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"camera_file: gphoto2.CameraFile (default=None)\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Captures a preview that won't be stored on the camera but returned in\n"
"supplied file. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `file` : \n"
" a CameraFile \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"For example, you could use gp_capture_preview() for taking some sample\n"
"pictures before calling gp_capture().\n"
"\n"
"See also gphoto2.Camera.capture_preview\n"
""},
{ "gp_camera_new", _wrap_gp_camera_new, METH_VARARGS, "\n"
"gp_camera_new() -> int\n"
"Allocates the memory for a Camera. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" the Camera object to initialize. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera\n"
""},
{ "gp_camera_set_abilities", _wrap_gp_camera_set_abilities, METH_VARARGS, "\n"
"gp_camera_set_abilities(camera, abilities) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"abilities: gphoto2.CameraAbilities\n"
"\n"
"Sets the camera abilities. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `abilities` : \n"
" the CameraAbilities to be set \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"You need to call this function before calling gp_camera_init the first\n"
"time unless you want gphoto2 to autodetect cameras and choose the first\n"
"detected one. By setting the `abilities`, you tell gphoto2 what model\n"
"the `camera` is and what camera driver should be used for accessing the\n"
"`camera`. You can get `abilities` by calling\n"
"gp_abilities_list_get_abilities.\n"
"\n"
"See also gphoto2.Camera.set_abilities\n"
""},
{ "gp_camera_get_abilities", _wrap_gp_camera_get_abilities, METH_VARARGS, "\n"
"gp_camera_get_abilities(camera) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"\n"
"Retrieve the `abilities` of the `camera`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `abilities` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.get_abilities\n"
""},
{ "gp_camera_set_port_info", _wrap_gp_camera_set_port_info, METH_VARARGS, "\n"
"gp_camera_set_port_info(camera, info) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"info: gphoto2.GPPortInfo\n"
"\n"
""},
{ "gp_camera_get_port_info", _wrap_gp_camera_get_port_info, METH_VARARGS, "\n"
"gp_camera_get_port_info(camera) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"\n"
""},
{ "gp_camera_set_port_speed", _wrap_gp_camera_set_port_speed, METH_VARARGS, "\n"
"gp_camera_set_port_speed(camera, speed) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"speed: int\n"
"\n"
"Set the camera speed. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `speed` : \n"
" the speed \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"This function is typically used prior first initialization using\n"
"gp_camera_init for debugging purposes. Normally, a camera driver will\n"
"try to figure out the current speed of the camera and set the speed to\n"
"the optimal one automatically. Note that this function only works with\n"
"serial ports. In other words, you have to set the camera's port to a\n"
"serial one (using #gp_camera_set_port_path or #gp_camera_set_port_name)\n"
"prior calling this function.\n"
"\n"
"See also gphoto2.Camera.set_port_speed\n"
""},
{ "gp_camera_get_port_speed", _wrap_gp_camera_get_port_speed, METH_VARARGS, "\n"
"gp_camera_get_port_speed(camera) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"\n"
"Retrieve the current speed. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"\n"
"Returns\n"
"-------\n"
"The current speed or a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.get_port_speed\n"
""},
{ "gp_camera_autodetect", _wrap_gp_camera_autodetect, METH_VARARGS, "\n"
"gp_camera_autodetect(context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Autodetect all detectable camera \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList that receives the autodetected cameras \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"the number of cameras detected (0 to n) or a gphoto2 error code (<0) \n"
"\n"
"This camera will autodetected all cameras that can be autodetected. This\n"
"will for instance detect all USB cameras. \n"
"\n"
"CameraList *list; gp_list_new (&list); gp_camera_autodetect (list,\n"
"context); ... done! ...\n"
"\n"
"See also gphoto2.Camera.autodetect\n"
""},
{ "gp_camera_init", _wrap_gp_camera_init, METH_VARARGS, "\n"
"gp_camera_init(camera, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Initiate a connection to the `camera`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"Before calling this function, the `camera` should be set up using\n"
"gp_camera_set_port_path() or gp_camera_set_port_name() and\n"
"gp_camera_set_abilities(). If that has been omitted, gphoto2 tries to\n"
"autodetect any cameras and chooses the first one if any cameras are\n"
"found. It is generally a good idea to call gp_camera_exit() after\n"
"transactions have been completed in order to give other applications the\n"
"chance to access the camera, too.\n"
"\n"
"See also gphoto2.Camera.init\n"
""},
{ "gp_camera_exit", _wrap_gp_camera_exit, METH_VARARGS, "\n"
"gp_camera_exit(camera, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Close connection to camera. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera object \n"
"* `context` : \n"
" a GPContext object \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code. \n"
"\n"
"Closes a connection to the camera and therefore gives other application\n"
"the possibility to access the camera, too. \n"
"\n"
"It is recommended that you call this function when you currently don't\n"
"need the camera. The camera will get reinitialized by gp_camera_init()\n"
"automatically if you try to access the camera again.\n"
"\n"
"See also gphoto2.Camera.exit\n"
""},
{ "gp_camera_get_config", _wrap_gp_camera_get_config, METH_VARARGS, "\n"
"gp_camera_get_config(camera, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieve a configuration `window` for the `camera`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `window` : \n"
" a CameraWidget \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"gphoto2 error code \n"
"\n"
"This `window` can be used for construction of a configuration dialog.\n"
"\n"
"See also gphoto2.Camera.get_config\n"
""},
{ "gp_camera_list_config", _wrap_gp_camera_list_config, METH_VARARGS, "\n"
"gp_camera_list_config(camera, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"context: gphoto2.Context (default=None)\n"
"\n"
""},
{ "gp_camera_get_single_config", _wrap_gp_camera_get_single_config, METH_VARARGS, "\n"
"gp_camera_get_single_config(camera, name, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"name: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieve a single configuration `widget` for the `camera`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `name` : \n"
" the name of a configuration widget \n"
"* `widget` : \n"
" a CameraWidget \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"gphoto2 error code \n"
"\n"
"This `widget` will then contain the current and the possible values and\n"
"the type.\n"
"\n"
"See also gphoto2.Camera.get_single_config\n"
""},
{ "gp_camera_set_config", _wrap_gp_camera_set_config, METH_VARARGS, "\n"
"gp_camera_set_config(camera, window, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"window: gphoto2.CameraWidget\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Sets the configuration. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `window` : \n"
" a CameraWidget \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"Typically, a `window` is retrieved using gp_camera_get_config and passed\n"
"to this function in order to adjust the settings on the camera.\n"
"\n"
"See also gphoto2.Camera.set_config\n"
""},
{ "gp_camera_set_single_config", _wrap_gp_camera_set_single_config, METH_VARARGS, "\n"
"gp_camera_set_single_config(camera, name, widget, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"name: str\n"
"widget: gphoto2.CameraWidget\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Set a single configuration `widget` for the `camera`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `name` : \n"
" the name of a configuration widget \n"
"* `widget` : \n"
" a CameraWidget \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"gphoto2 error code \n"
"\n"
"This `widget` contains the new value of the widget to set.\n"
"\n"
"See also gphoto2.Camera.set_single_config\n"
""},
{ "gp_camera_get_summary", _wrap_gp_camera_get_summary, METH_VARARGS, "\n"
"gp_camera_get_summary(camera, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieves a camera summary. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `summary` : \n"
" a CameraText \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"This summary typically contains information like manufacturer, pictures\n"
"taken, or generally information that is not configurable.\n"
"\n"
"See also gphoto2.Camera.get_summary\n"
""},
{ "gp_camera_get_manual", _wrap_gp_camera_get_manual, METH_VARARGS, "\n"
"gp_camera_get_manual(camera, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieves the `manual` for given `camera`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `manual` : \n"
" a CameraText \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"This manual typically contains information about using the camera.\n"
"\n"
"See also gphoto2.Camera.get_manual\n"
""},
{ "gp_camera_get_about", _wrap_gp_camera_get_about, METH_VARARGS, "\n"
"gp_camera_get_about(camera, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieves information about the camera driver. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `about` : \n"
" a CameraText \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"Typically, this information contains name and address of the author,\n"
"acknowledgements, etc.\n"
"\n"
"See also gphoto2.Camera.get_about\n"
""},
{ "gp_camera_capture", _wrap_gp_camera_capture, METH_VARARGS, "\n"
"gp_camera_capture(camera, type, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"type: CameraCaptureType (gphoto2.GP_CAPTURE_IMAGE etc.)\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Captures an image, movie, or sound clip depending on the given `type`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `type` : \n"
" a CameraCaptureType \n"
"* `path` : \n"
" a CameraFilePath \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"The resulting file will be stored on the camera. The location gets\n"
"stored in `path`. The file can then be downloaded using\n"
"gp_camera_file_get.\n"
"\n"
"See also gphoto2.Camera.capture\n"
""},
{ "gp_camera_trigger_capture", _wrap_gp_camera_trigger_capture, METH_VARARGS, "\n"
"gp_camera_trigger_capture(camera, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Triggers capture of one or more images. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"This functions just remotely causes the shutter release and returns\n"
"immediately. You will want to run #gp_camera_wait_event until a image is\n"
"added which can be downloaded using gp_camera_file_get.\n"
"\n"
"See also gphoto2.Camera.trigger_capture\n"
""},
{ "gp_camera_wait_for_event", _wrap_gp_camera_wait_for_event, METH_VARARGS, "\n"
"gp_camera_wait_for_event(camera, timeout, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"timeout: int\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Wait and retrieve an event from the camera. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `timeout` : \n"
" amount of time to wait in 1/1000 seconds \n"
"* `eventtype` : \n"
" received CameraEventType [out] \n"
"* `eventdata` : \n"
" received event specific data [out] \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"gphoto2 error code \n"
"\n"
"This function blocks and waits for an event to come from the camera. If\n"
"a timeout occurs before an event is received then eventtype will be\n"
"GP_EVENT_TIMEOUT and eventdata is left unchanged. \n"
"\n"
"If an event is received then eventtype is set to the type of event, and\n"
"eventdata is set to event specific data. See the CameraEventType enum to\n"
"see which eventtypes match to which types of eventdata. \n"
"\n"
"Note that this function will return one event after each other, you need\n"
"to be able to call it multiple times, e.g. in a loop, when waiting for\n"
"specific events.\n"
"\n"
"See also gphoto2.Camera.wait_for_event\n"
""},
{ "gp_camera_get_storageinfo", _wrap_gp_camera_get_storageinfo, METH_VARARGS, "\n"
"gp_camera_get_storageinfo(camera, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Gets information on the camera attached storage. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `sifs` : \n"
" Pointer to receive a pointer to/array of storage info items \n"
"* `nrofsifs` : \n"
" Pointer to receive number of array entries \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"Retrieves the storage information, like maximum and free space, for the\n"
"specified filesystem, if supported by the device. The storage\n"
"information is returned in an newly allocated array of\n"
"CameraStorageInformation objects, to which the pointer pointed to by\n"
"#sifs will be set. \n"
"\n"
"The variable pointed to by #nrofsifs will be set to the number of\n"
"elements in that array. \n"
"\n"
"It is the caller's responsibility to free the memory of the array.\n"
"\n"
"See also gphoto2.Camera.get_storageinfo\n"
""},
{ "gp_camera_folder_list_files", _wrap_gp_camera_folder_list_files, METH_VARARGS, "\n"
"gp_camera_folder_list_files(camera, folder, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"folder: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Lists the files in supplied `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `list` : \n"
" a CameraList \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.folder_list_files\n"
""},
{ "gp_camera_folder_list_folders", _wrap_gp_camera_folder_list_folders, METH_VARARGS, "\n"
"gp_camera_folder_list_folders(camera, folder, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"folder: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Lists the folders in supplied `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `list` : \n"
" a CameraList \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.folder_list_folders\n"
""},
{ "gp_camera_folder_delete_all", _wrap_gp_camera_folder_delete_all, METH_VARARGS, "\n"
"gp_camera_folder_delete_all(camera, folder, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"folder: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Deletes all files in a given `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.folder_delete_all\n"
""},
{ "gp_camera_folder_put_file", _wrap_gp_camera_folder_put_file, METH_VARARGS, "\n"
"gp_camera_folder_put_file(camera, folder, filename, type, file, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"folder: str\n"
"filename: str\n"
"type: CameraFileType (gphoto2.GP_FILE_TYPE_PREVIEW etc.)\n"
"file: gphoto2.CameraFile\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Uploads a file into given `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `file` : \n"
" a CameraFile \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.folder_put_file\n"
""},
{ "gp_camera_folder_make_dir", _wrap_gp_camera_folder_make_dir, METH_VARARGS, "\n"
"gp_camera_folder_make_dir(camera, folder, name, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"folder: str\n"
"name: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Creates a new directory called `name` in the given `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" the location where to create the new directory \n"
"* `name` : \n"
" the name of the directory to be created \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.folder_make_dir\n"
""},
{ "gp_camera_folder_remove_dir", _wrap_gp_camera_folder_remove_dir, METH_VARARGS, "\n"
"gp_camera_folder_remove_dir(camera, folder, name, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"folder: str\n"
"name: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Removes an (empty) directory called `name` from the given `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" the folder from which to remove the directory \n"
"* `name` : \n"
" the name of the directory to be removed \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.folder_remove_dir\n"
""},
{ "gp_camera_file_get_info", _wrap_gp_camera_file_get_info, METH_VARARGS, "\n"
"gp_camera_file_get_info(camera, folder, file, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"folder: str\n"
"file: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieves information about a file. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `file` : \n"
" the name of the file \n"
"* `info` : \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.file_get_info\n"
""},
{ "gp_camera_file_set_info", _wrap_gp_camera_file_set_info, METH_VARARGS, "\n"
"gp_camera_file_set_info(camera, folder, file, info, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"folder: str\n"
"file: str\n"
"info: gphoto2.CameraFileInfo\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Sets some file properties like name or permissions. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `file` : \n"
" the name of a file \n"
"* `info` : \n"
" the CameraFileInfo \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.file_set_info\n"
""},
{ "gp_camera_file_get", _wrap_gp_camera_file_get, METH_VARARGS, "\n"
"gp_camera_file_get(camera, folder, file, type, camera_file, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"folder: str\n"
"file: str\n"
"type: CameraFileType (gphoto2.GP_FILE_TYPE_PREVIEW etc.)\n"
"camera_file: gphoto2.CameraFile (default=None)\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieves a file from the Camera. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `file` : \n"
" the name of a file \n"
"* `type` : \n"
" the CameraFileType \n"
"* `camera_file` : \n"
" a CameraFile \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.file_get\n"
""},
{ "gp_camera_file_read", _wrap_gp_camera_file_read, METH_VARARGS, "\n"
"gp_camera_file_read(camera, folder, file, type, offset, buf, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"folder: str\n"
"file: str\n"
"type: CameraFileType (gphoto2.GP_FILE_TYPE_PREVIEW etc.)\n"
"offset: int\n"
"buf: writable buffer (e.g. memoryview)\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Reads a file partially from the Camera. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `file` : \n"
" the name of a file \n"
"* `type` : \n"
" the CameraFileType \n"
"* `offset` : \n"
" the offset into the camera file \n"
"* `data` : \n"
" the buffer receiving the data \n"
"* `size` : \n"
" the size to be read and that was read. (Note: size should not exceed\n"
" 32 bits) \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.file_read\n"
""},
{ "gp_camera_file_delete", _wrap_gp_camera_file_delete, METH_VARARGS, "\n"
"gp_camera_file_delete(camera, folder, file, context) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"camera: gphoto2.Camera\n"
"folder: str\n"
"file: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Deletes the file from `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `file` : \n"
" the name of a file \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.Camera.file_delete\n"
""},
{ NULL, NULL, 0, NULL }
};
static SwigPyGetSet CameraText___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet CameraText_text_getset = { _wrap_CameraText_text_get, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CameraText_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"\n"
"gp_camera_capture_preview\n"
"Captures a preview that won't be stored on the camera but returned in\n"
"supplied file. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `file` : \n"
" a CameraFile \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"For example, you could use gp_capture_preview() for taking some sample\n"
"pictures before calling gp_capture().\n"
"\n"
"See also gphoto2.Camera.capture_preview\n"
"", &CameraText___dict___getset },
{ (char *)"text", SwigPyBuiltin_GetterClosure, 0, (char *)"text", &CameraText_text_getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin__CameraText_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin__CameraText_methods[] = {
{ "__str__", _wrap_CameraText___str__, METH_VARARGS, "__str__(self) -> char *" },
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin__CameraText_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.camera.CameraText", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CameraText_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin__CameraText_type.as_number,/* tp_as_number */
&SwigPyBuiltin__CameraText_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin__CameraText_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
_wrap_CameraText___str___reprfunc_closure,/* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin__CameraText_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"\n"
"CameraText structure used in various functions. \n"
"\n"
"A text structure containing translated text returned by various\n"
"functions (about, manual, summary). You should not assume a size. \n"
"\n"
"C++ includes: gphoto2-camera.h\n"
"",/* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin__CameraText_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin__CameraText_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin__CameraText_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
SwigPyBuiltin_BadInit, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin__CameraText_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CameraText_type};
static SwigPyGetSet CameraFilePath_name_getset = { _wrap_CameraFilePath_name_get, 0 };
static SwigPyGetSet CameraFilePath_folder_getset = { _wrap_CameraFilePath_folder_get, 0 };
static SwigPyGetSet CameraFilePath___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CameraFilePath_getset[] = {
{ (char *)"name", SwigPyBuiltin_GetterClosure, 0, (char *)"name", &CameraFilePath_name_getset },
{ (char *)"folder", SwigPyBuiltin_GetterClosure, 0, (char *)"folder", &CameraFilePath_folder_getset },
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"name", &CameraFilePath___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin__CameraFilePath_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin__CameraFilePath_methods[] = {
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin__CameraFilePath_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.camera.CameraFilePath", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CameraFilePath_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin__CameraFilePath_type.as_number, /* tp_as_number */
&SwigPyBuiltin__CameraFilePath_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin__CameraFilePath_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin__CameraFilePath_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"\n"
"A structure created by the capture operation. \n"
"\n"
"A structure containing the folder and filename of an object after a\n"
"successful capture and is passed as reference to the gp_camera_capture()\n"
"function. \n"
"\n"
"C++ includes: gphoto2-camera.h\n"
"",/* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin__CameraFilePath_richcompare,/* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin__CameraFilePath_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin__CameraFilePath_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
SwigPyBuiltin_BadInit, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin__CameraFilePath_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CameraFilePath_type};
static SwigPyGetSet Camera___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin___Camera_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"_Camera", &Camera___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___Camera_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___Camera_methods[] = {
{ "autodetect", (PyCFunction)(void(*)(void))_wrap_Camera_autodetect, METH_STATIC|METH_VARARGS, "\n"
"autodetect(context)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Autodetect all detectable camera \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList that receives the autodetected cameras \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"the number of cameras detected (0 to n) or a gphoto2 error code (<0) \n"
"\n"
"This camera will autodetected all cameras that can be autodetected. This\n"
"will for instance detect all USB cameras. \n"
"\n"
"CameraList *list; gp_list_new (&list); gp_camera_autodetect (list,\n"
"context); ... done! ...\n"
"\n"
"See also gphoto2.gp_camera_autodetect\n"
"" },
{ "set_abilities", _wrap_Camera_set_abilities, METH_VARARGS, "\n"
"set_abilities(self, abilities)\n"
"\n"
"Parameters\n"
"----------\n"
"abilities: gphoto2.CameraAbilities\n"
"\n"
"Sets the camera abilities. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `abilities` : \n"
" the CameraAbilities to be set \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"You need to call this function before calling gp_camera_init the first\n"
"time unless you want gphoto2 to autodetect cameras and choose the first\n"
"detected one. By setting the `abilities`, you tell gphoto2 what model\n"
"the `camera` is and what camera driver should be used for accessing the\n"
"`camera`. You can get `abilities` by calling\n"
"gp_abilities_list_get_abilities.\n"
"\n"
"See also gphoto2.gp_camera_set_abilities\n"
"" },
{ "get_abilities", _wrap_Camera_get_abilities, METH_VARARGS, "\n"
"get_abilities(self)\n"
"Retrieve the `abilities` of the `camera`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `abilities` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_get_abilities\n"
"" },
{ "set_port_info", _wrap_Camera_set_port_info, METH_VARARGS, "\n"
"set_port_info(self, info)\n"
"\n"
"Parameters\n"
"----------\n"
"info: gphoto2.GPPortInfo\n"
"\n"
"" },
{ "get_port_info", _wrap_Camera_get_port_info, METH_VARARGS, "get_port_info(self)" },
{ "set_port_speed", _wrap_Camera_set_port_speed, METH_VARARGS, "\n"
"set_port_speed(self, speed)\n"
"\n"
"Parameters\n"
"----------\n"
"speed: int\n"
"\n"
"Set the camera speed. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `speed` : \n"
" the speed \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"This function is typically used prior first initialization using\n"
"gp_camera_init for debugging purposes. Normally, a camera driver will\n"
"try to figure out the current speed of the camera and set the speed to\n"
"the optimal one automatically. Note that this function only works with\n"
"serial ports. In other words, you have to set the camera's port to a\n"
"serial one (using #gp_camera_set_port_path or #gp_camera_set_port_name)\n"
"prior calling this function.\n"
"\n"
"See also gphoto2.gp_camera_set_port_speed\n"
"" },
{ "get_port_speed", _wrap_Camera_get_port_speed, METH_VARARGS, "\n"
"get_port_speed(self) -> int\n"
"Retrieve the current speed. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"\n"
"Returns\n"
"-------\n"
"The current speed or a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_get_port_speed\n"
"" },
{ "init", _wrap_Camera_init, METH_VARARGS, "\n"
"init(self, context)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Initiate a connection to the `camera`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"Before calling this function, the `camera` should be set up using\n"
"gp_camera_set_port_path() or gp_camera_set_port_name() and\n"
"gp_camera_set_abilities(). If that has been omitted, gphoto2 tries to\n"
"autodetect any cameras and chooses the first one if any cameras are\n"
"found. It is generally a good idea to call gp_camera_exit() after\n"
"transactions have been completed in order to give other applications the\n"
"chance to access the camera, too.\n"
"\n"
"See also gphoto2.gp_camera_init\n"
"" },
{ "exit", _wrap_Camera_exit, METH_VARARGS, "\n"
"exit(self, context)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Close connection to camera. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera object \n"
"* `context` : \n"
" a GPContext object \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code. \n"
"\n"
"Closes a connection to the camera and therefore gives other application\n"
"the possibility to access the camera, too. \n"
"\n"
"It is recommended that you call this function when you currently don't\n"
"need the camera. The camera will get reinitialized by gp_camera_init()\n"
"automatically if you try to access the camera again.\n"
"\n"
"See also gphoto2.gp_camera_exit\n"
"" },
{ "get_config", _wrap_Camera_get_config, METH_VARARGS, "\n"
"get_config(self, context)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieve a configuration `window` for the `camera`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `window` : \n"
" a CameraWidget \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"gphoto2 error code \n"
"\n"
"This `window` can be used for construction of a configuration dialog.\n"
"\n"
"See also gphoto2.gp_camera_get_config\n"
"" },
{ "list_config", _wrap_Camera_list_config, METH_VARARGS, "\n"
"list_config(self, context)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"" },
{ "get_single_config", _wrap_Camera_get_single_config, METH_VARARGS, "\n"
"get_single_config(self, name, context)\n"
"\n"
"Parameters\n"
"----------\n"
"name: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieve a single configuration `widget` for the `camera`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `name` : \n"
" the name of a configuration widget \n"
"* `widget` : \n"
" a CameraWidget \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"gphoto2 error code \n"
"\n"
"This `widget` will then contain the current and the possible values and\n"
"the type.\n"
"\n"
"See also gphoto2.gp_camera_get_single_config\n"
"" },
{ "set_config", _wrap_Camera_set_config, METH_VARARGS, "\n"
"set_config(self, window, context)\n"
"\n"
"Parameters\n"
"----------\n"
"window: gphoto2.CameraWidget\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Sets the configuration. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `window` : \n"
" a CameraWidget \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"Typically, a `window` is retrieved using gp_camera_get_config and passed\n"
"to this function in order to adjust the settings on the camera.\n"
"\n"
"See also gphoto2.gp_camera_set_config\n"
"" },
{ "set_single_config", _wrap_Camera_set_single_config, METH_VARARGS, "\n"
"set_single_config(self, name, widget, context)\n"
"\n"
"Parameters\n"
"----------\n"
"name: str\n"
"widget: gphoto2.CameraWidget\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Set a single configuration `widget` for the `camera`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `name` : \n"
" the name of a configuration widget \n"
"* `widget` : \n"
" a CameraWidget \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"gphoto2 error code \n"
"\n"
"This `widget` contains the new value of the widget to set.\n"
"\n"
"See also gphoto2.gp_camera_set_single_config\n"
"" },
{ "get_summary", _wrap_Camera_get_summary, METH_VARARGS, "\n"
"get_summary(self, context)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieves a camera summary. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `summary` : \n"
" a CameraText \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"This summary typically contains information like manufacturer, pictures\n"
"taken, or generally information that is not configurable.\n"
"\n"
"See also gphoto2.gp_camera_get_summary\n"
"" },
{ "get_manual", _wrap_Camera_get_manual, METH_VARARGS, "\n"
"get_manual(self, context)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieves the `manual` for given `camera`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `manual` : \n"
" a CameraText \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"This manual typically contains information about using the camera.\n"
"\n"
"See also gphoto2.gp_camera_get_manual\n"
"" },
{ "get_about", _wrap_Camera_get_about, METH_VARARGS, "\n"
"get_about(self, context)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieves information about the camera driver. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `about` : \n"
" a CameraText \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"Typically, this information contains name and address of the author,\n"
"acknowledgements, etc.\n"
"\n"
"See also gphoto2.gp_camera_get_about\n"
"" },
{ "capture", _wrap_Camera_capture, METH_VARARGS, "\n"
"capture(self, type, context)\n"
"\n"
"Parameters\n"
"----------\n"
"type: CameraCaptureType (gphoto2.GP_CAPTURE_IMAGE etc.)\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Captures an image, movie, or sound clip depending on the given `type`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `type` : \n"
" a CameraCaptureType \n"
"* `path` : \n"
" a CameraFilePath \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"The resulting file will be stored on the camera. The location gets\n"
"stored in `path`. The file can then be downloaded using\n"
"gp_camera_file_get.\n"
"\n"
"See also gphoto2.gp_camera_capture\n"
"" },
{ "trigger_capture", _wrap_Camera_trigger_capture, METH_VARARGS, "\n"
"trigger_capture(self, context)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Triggers capture of one or more images. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"This functions just remotely causes the shutter release and returns\n"
"immediately. You will want to run #gp_camera_wait_event until a image is\n"
"added which can be downloaded using gp_camera_file_get.\n"
"\n"
"See also gphoto2.gp_camera_trigger_capture\n"
"" },
{ "capture_preview", _wrap_Camera_capture_preview, METH_VARARGS, "\n"
"capture_preview(self, camera_file, context)\n"
"\n"
"Parameters\n"
"----------\n"
"camera_file: gphoto2.CameraFile (default=None)\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Captures a preview that won't be stored on the camera but returned in\n"
"supplied file. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `file` : \n"
" a CameraFile \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"For example, you could use gp_capture_preview() for taking some sample\n"
"pictures before calling gp_capture().\n"
"\n"
"See also gphoto2.gp_camera_capture_preview\n"
"" },
{ "wait_for_event", _wrap_Camera_wait_for_event, METH_VARARGS, "\n"
"wait_for_event(self, timeout, context)\n"
"\n"
"Parameters\n"
"----------\n"
"timeout: int\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Wait and retrieve an event from the camera. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `timeout` : \n"
" amount of time to wait in 1/1000 seconds \n"
"* `eventtype` : \n"
" received CameraEventType [out] \n"
"* `eventdata` : \n"
" received event specific data [out] \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"gphoto2 error code \n"
"\n"
"This function blocks and waits for an event to come from the camera. If\n"
"a timeout occurs before an event is received then eventtype will be\n"
"GP_EVENT_TIMEOUT and eventdata is left unchanged. \n"
"\n"
"If an event is received then eventtype is set to the type of event, and\n"
"eventdata is set to event specific data. See the CameraEventType enum to\n"
"see which eventtypes match to which types of eventdata. \n"
"\n"
"Note that this function will return one event after each other, you need\n"
"to be able to call it multiple times, e.g. in a loop, when waiting for\n"
"specific events.\n"
"\n"
"See also gphoto2.gp_camera_wait_for_event\n"
"" },
{ "get_storageinfo", _wrap_Camera_get_storageinfo, METH_VARARGS, "\n"
"get_storageinfo(self, context)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Gets information on the camera attached storage. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `sifs` : \n"
" Pointer to receive a pointer to/array of storage info items \n"
"* `nrofsifs` : \n"
" Pointer to receive number of array entries \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code \n"
"\n"
"Retrieves the storage information, like maximum and free space, for the\n"
"specified filesystem, if supported by the device. The storage\n"
"information is returned in an newly allocated array of\n"
"CameraStorageInformation objects, to which the pointer pointed to by\n"
"#sifs will be set. \n"
"\n"
"The variable pointed to by #nrofsifs will be set to the number of\n"
"elements in that array. \n"
"\n"
"It is the caller's responsibility to free the memory of the array.\n"
"\n"
"See also gphoto2.gp_camera_get_storageinfo\n"
"" },
{ "folder_list_files", _wrap_Camera_folder_list_files, METH_VARARGS, "\n"
"folder_list_files(self, folder, context)\n"
"\n"
"Parameters\n"
"----------\n"
"folder: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Lists the files in supplied `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `list` : \n"
" a CameraList \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_folder_list_files\n"
"" },
{ "folder_list_folders", _wrap_Camera_folder_list_folders, METH_VARARGS, "\n"
"folder_list_folders(self, folder, context)\n"
"\n"
"Parameters\n"
"----------\n"
"folder: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Lists the folders in supplied `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `list` : \n"
" a CameraList \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_folder_list_folders\n"
"" },
{ "folder_delete_all", _wrap_Camera_folder_delete_all, METH_VARARGS, "\n"
"folder_delete_all(self, folder, context)\n"
"\n"
"Parameters\n"
"----------\n"
"folder: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Deletes all files in a given `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_folder_delete_all\n"
"" },
{ "folder_put_file", _wrap_Camera_folder_put_file, METH_VARARGS, "\n"
"folder_put_file(self, folder, filename, type, file, context)\n"
"\n"
"Parameters\n"
"----------\n"
"folder: str\n"
"filename: str\n"
"type: CameraFileType (gphoto2.GP_FILE_TYPE_PREVIEW etc.)\n"
"file: gphoto2.CameraFile\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Uploads a file into given `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `file` : \n"
" a CameraFile \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_folder_put_file\n"
"" },
{ "folder_make_dir", _wrap_Camera_folder_make_dir, METH_VARARGS, "\n"
"folder_make_dir(self, folder, name, context)\n"
"\n"
"Parameters\n"
"----------\n"
"folder: str\n"
"name: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Creates a new directory called `name` in the given `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" the location where to create the new directory \n"
"* `name` : \n"
" the name of the directory to be created \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_folder_make_dir\n"
"" },
{ "folder_remove_dir", _wrap_Camera_folder_remove_dir, METH_VARARGS, "\n"
"folder_remove_dir(self, folder, name, context)\n"
"\n"
"Parameters\n"
"----------\n"
"folder: str\n"
"name: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Removes an (empty) directory called `name` from the given `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" the folder from which to remove the directory \n"
"* `name` : \n"
" the name of the directory to be removed \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_folder_remove_dir\n"
"" },
{ "file_get_info", _wrap_Camera_file_get_info, METH_VARARGS, "\n"
"file_get_info(self, folder, file, context)\n"
"\n"
"Parameters\n"
"----------\n"
"folder: str\n"
"file: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieves information about a file. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `file` : \n"
" the name of the file \n"
"* `info` : \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_file_get_info\n"
"" },
{ "file_set_info", _wrap_Camera_file_set_info, METH_VARARGS, "\n"
"file_set_info(self, folder, file, info, context)\n"
"\n"
"Parameters\n"
"----------\n"
"folder: str\n"
"file: str\n"
"info: gphoto2.CameraFileInfo\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Sets some file properties like name or permissions. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `file` : \n"
" the name of a file \n"
"* `info` : \n"
" the CameraFileInfo \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_file_set_info\n"
"" },
{ "file_get", _wrap_Camera_file_get, METH_VARARGS, "\n"
"file_get(self, folder, file, type, camera_file, context)\n"
"\n"
"Parameters\n"
"----------\n"
"folder: str\n"
"file: str\n"
"type: CameraFileType (gphoto2.GP_FILE_TYPE_PREVIEW etc.)\n"
"camera_file: gphoto2.CameraFile (default=None)\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Retrieves a file from the Camera. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `file` : \n"
" the name of a file \n"
"* `type` : \n"
" the CameraFileType \n"
"* `camera_file` : \n"
" a CameraFile \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_file_get\n"
"" },
{ "file_read", _wrap_Camera_file_read, METH_VARARGS, "\n"
"file_read(self, folder, file, type, offset, buf, context)\n"
"\n"
"Parameters\n"
"----------\n"
"folder: str\n"
"file: str\n"
"type: CameraFileType (gphoto2.GP_FILE_TYPE_PREVIEW etc.)\n"
"offset: int\n"
"buf: writable buffer (e.g. memoryview)\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Reads a file partially from the Camera. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `file` : \n"
" the name of a file \n"
"* `type` : \n"
" the CameraFileType \n"
"* `offset` : \n"
" the offset into the camera file \n"
"* `data` : \n"
" the buffer receiving the data \n"
"* `size` : \n"
" the size to be read and that was read. (Note: size should not exceed\n"
" 32 bits) \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_file_read\n"
"" },
{ "file_delete", _wrap_Camera_file_delete, METH_VARARGS, "\n"
"file_delete(self, folder, file, context)\n"
"\n"
"Parameters\n"
"----------\n"
"folder: str\n"
"file: str\n"
"context: gphoto2.Context (default=None)\n"
"\n"
"Deletes the file from `folder`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `camera` : \n"
" a Camera \n"
"* `folder` : \n"
" a folder \n"
"* `file` : \n"
" the name of a file \n"
"* `context` : \n"
" a GPContext \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_camera_file_delete\n"
"" },
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___Camera_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.camera.Camera", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_Camera_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___Camera_type.as_number, /* tp_as_number */
&SwigPyBuiltin___Camera_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___Camera_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___Camera_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"::_Camera", /* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___Camera_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___Camera_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___Camera_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
_wrap_new_Camera, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___Camera_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___Camera_type};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_CameraAbilities = {"_p_CameraAbilities", "CameraAbilities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraCaptureType = {"_p_CameraCaptureType", "CameraCaptureType *|enum CameraCaptureType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraDriverStatus = {"_p_CameraDriverStatus", "CameraDriverStatus *|enum CameraDriverStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraEventType = {"_p_CameraEventType", "CameraEventType *|enum CameraEventType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFileAccessType = {"_p_CameraFileAccessType", "CameraFileAccessType *|enum CameraFileAccessType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFileInfoFields = {"_p_CameraFileInfoFields", "CameraFileInfoFields *|enum CameraFileInfoFields *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFileOperation = {"_p_CameraFileOperation", "CameraFileOperation *|enum CameraFileOperation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFilePath = {"_p_CameraFilePath", "CameraFilePath *", 0, 0, (void*)&SwigPyBuiltin__CameraFilePath_clientdata, 0};
static swig_type_info _swigt__p_CameraFilePermissions = {"_p_CameraFilePermissions", "CameraFilePermissions *|enum CameraFilePermissions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFileStatus = {"_p_CameraFileStatus", "CameraFileStatus *|enum CameraFileStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFileType = {"_p_CameraFileType", "CameraFileType *|enum CameraFileType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFolderOperation = {"_p_CameraFolderOperation", "CameraFolderOperation *|enum CameraFolderOperation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraOperation = {"_p_CameraOperation", "CameraOperation *|enum CameraOperation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraStorageAccessType = {"_p_CameraStorageAccessType", "CameraStorageAccessType *|enum CameraStorageAccessType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraStorageFilesystemType = {"_p_CameraStorageFilesystemType", "CameraStorageFilesystemType *|enum CameraStorageFilesystemType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraStorageInfoFields = {"_p_CameraStorageInfoFields", "CameraStorageInfoFields *|enum CameraStorageInfoFields *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraStorageType = {"_p_CameraStorageType", "CameraStorageType *|enum CameraStorageType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraText = {"_p_CameraText", "CameraText *", 0, 0, (void*)&SwigPyBuiltin__CameraText_clientdata, 0};
static swig_type_info _swigt__p_CameraWidgetType = {"_p_CameraWidgetType", "CameraWidgetType *|enum CameraWidgetType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GPPortType = {"_p_GPPortType", "GPPortType *|enum GPPortType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GphotoDeviceType = {"_p_GphotoDeviceType", "GphotoDeviceType *|enum GphotoDeviceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwigPyObject = {"_p_SwigPyObject", "SwigPyObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__Camera = {"_p__Camera", "Camera *|struct _Camera *|_Camera *", 0, 0, (void*)&SwigPyBuiltin___Camera_clientdata, 0};
static swig_type_info _swigt__p__CameraAbilitiesList = {"_p__CameraAbilitiesList", "CameraAbilitiesList *|struct _CameraAbilitiesList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraFile = {"_p__CameraFile", "CameraFile *|struct _CameraFile *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraFileHandler = {"_p__CameraFileHandler", "CameraFileHandler *|struct _CameraFileHandler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraFileInfo = {"_p__CameraFileInfo", "CameraFileInfo *|struct _CameraFileInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraFileInfoAudio = {"_p__CameraFileInfoAudio", "CameraFileInfoAudio *|struct _CameraFileInfoAudio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraFileInfoFile = {"_p__CameraFileInfoFile", "CameraFileInfoFile *|struct _CameraFileInfoFile *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraFileInfoPreview = {"_p__CameraFileInfoPreview", "CameraFileInfoPreview *|struct _CameraFileInfoPreview *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraFunctions = {"_p__CameraFunctions", "CameraFunctions *|struct _CameraFunctions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraList = {"_p__CameraList", "CameraList *|struct _CameraList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraPrivateCore = {"_p__CameraPrivateCore", "CameraPrivateCore *|struct _CameraPrivateCore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraPrivateLibrary = {"_p__CameraPrivateLibrary", "CameraPrivateLibrary *|struct _CameraPrivateLibrary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraStorageInformation = {"_p__CameraStorageInformation", "CameraStorageInformation *|struct _CameraStorageInformation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraWidget = {"_p__CameraWidget", "CameraWidget *|struct _CameraWidget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPContext = {"_p__GPContext", "GPContext *|struct _GPContext *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPContextFeedback = {"_p__GPContextFeedback", "GPContextFeedback *|enum _GPContextFeedback *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortInfo = {"_p__GPPortInfo", "GPPortInfo|struct _GPPortInfo *|_GPPortInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortInfoList = {"_p__GPPortInfoList", "GPPortInfoList *|struct _GPPortInfoList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int32_t *|int_fast16_t *|int_fast32_t *|int_least32_t *|intptr_t *|int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long = {"_p_long", "time_t *|long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "int64_t *|int_fast64_t *|int_least64_t *|intmax_t *|long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__Camera = {"_p_p__Camera", "Camera **|struct _Camera **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__CameraStorageInformation = {"_p_p__CameraStorageInformation", "CameraStorageInformation **|struct _CameraStorageInformation **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__CameraWidget = {"_p_p__CameraWidget", "CameraWidget **|struct _CameraWidget **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__GPPortInfo = {"_p_p__GPPortInfo", "GPPortInfo *|struct _GPPortInfo **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "int16_t *|int_least16_t *|short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "int8_t *|int_fast8_t *|int_least8_t *|signed char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "uint8_t *|uint_fast8_t *|uint_least8_t *|unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uint32_t *|uint_fast16_t *|uint_fast32_t *|uint_least32_t *|uintptr_t *|unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint64_t *|uint_fast64_t *|uint_least64_t *|uintmax_t *|unsigned long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "uint16_t *|uint_least16_t *|unsigned short *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_CameraAbilities,
&_swigt__p_CameraCaptureType,
&_swigt__p_CameraDriverStatus,
&_swigt__p_CameraEventType,
&_swigt__p_CameraFileAccessType,
&_swigt__p_CameraFileInfoFields,
&_swigt__p_CameraFileOperation,
&_swigt__p_CameraFilePath,
&_swigt__p_CameraFilePermissions,
&_swigt__p_CameraFileStatus,
&_swigt__p_CameraFileType,
&_swigt__p_CameraFolderOperation,
&_swigt__p_CameraOperation,
&_swigt__p_CameraStorageAccessType,
&_swigt__p_CameraStorageFilesystemType,
&_swigt__p_CameraStorageInfoFields,
&_swigt__p_CameraStorageType,
&_swigt__p_CameraText,
&_swigt__p_CameraWidgetType,
&_swigt__p_GPPortType,
&_swigt__p_GphotoDeviceType,
&_swigt__p_SwigPyObject,
&_swigt__p__Camera,
&_swigt__p__CameraAbilitiesList,
&_swigt__p__CameraFile,
&_swigt__p__CameraFileHandler,
&_swigt__p__CameraFileInfo,
&_swigt__p__CameraFileInfoAudio,
&_swigt__p__CameraFileInfoFile,
&_swigt__p__CameraFileInfoPreview,
&_swigt__p__CameraFunctions,
&_swigt__p__CameraList,
&_swigt__p__CameraPrivateCore,
&_swigt__p__CameraPrivateLibrary,
&_swigt__p__CameraStorageInformation,
&_swigt__p__CameraWidget,
&_swigt__p__GPContext,
&_swigt__p__GPContextFeedback,
&_swigt__p__GPPortInfo,
&_swigt__p__GPPortInfoList,
&_swigt__p_char,
&_swigt__p_int,
&_swigt__p_long,
&_swigt__p_long_long,
&_swigt__p_p__Camera,
&_swigt__p_p__CameraStorageInformation,
&_swigt__p_p__CameraWidget,
&_swigt__p_p__GPPortInfo,
&_swigt__p_p_void,
&_swigt__p_short,
&_swigt__p_signed_char,
&_swigt__p_unsigned_char,
&_swigt__p_unsigned_int,
&_swigt__p_unsigned_long_long,
&_swigt__p_unsigned_short,
};
static swig_cast_info _swigc__p_CameraAbilities[] = { {&_swigt__p_CameraAbilities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraCaptureType[] = { {&_swigt__p_CameraCaptureType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraDriverStatus[] = { {&_swigt__p_CameraDriverStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraEventType[] = { {&_swigt__p_CameraEventType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFileAccessType[] = { {&_swigt__p_CameraFileAccessType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFileInfoFields[] = { {&_swigt__p_CameraFileInfoFields, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFileOperation[] = { {&_swigt__p_CameraFileOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFilePath[] = { {&_swigt__p_CameraFilePath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFilePermissions[] = { {&_swigt__p_CameraFilePermissions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFileStatus[] = { {&_swigt__p_CameraFileStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFileType[] = { {&_swigt__p_CameraFileType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFolderOperation[] = { {&_swigt__p_CameraFolderOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraOperation[] = { {&_swigt__p_CameraOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraStorageAccessType[] = { {&_swigt__p_CameraStorageAccessType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraStorageFilesystemType[] = { {&_swigt__p_CameraStorageFilesystemType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraStorageInfoFields[] = { {&_swigt__p_CameraStorageInfoFields, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraStorageType[] = { {&_swigt__p_CameraStorageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraText[] = { {&_swigt__p_CameraText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraWidgetType[] = { {&_swigt__p_CameraWidgetType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GPPortType[] = { {&_swigt__p_GPPortType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GphotoDeviceType[] = { {&_swigt__p_GphotoDeviceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwigPyObject[] = { {&_swigt__p_SwigPyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__Camera[] = { {&_swigt__p__Camera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraAbilitiesList[] = { {&_swigt__p__CameraAbilitiesList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFile[] = { {&_swigt__p__CameraFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFileHandler[] = { {&_swigt__p__CameraFileHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFileInfo[] = { {&_swigt__p__CameraFileInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFileInfoAudio[] = { {&_swigt__p__CameraFileInfoAudio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFileInfoFile[] = { {&_swigt__p__CameraFileInfoFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFileInfoPreview[] = { {&_swigt__p__CameraFileInfoPreview, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFunctions[] = { {&_swigt__p__CameraFunctions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraList[] = { {&_swigt__p__CameraList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraPrivateCore[] = { {&_swigt__p__CameraPrivateCore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraPrivateLibrary[] = { {&_swigt__p__CameraPrivateLibrary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraStorageInformation[] = { {&_swigt__p__CameraStorageInformation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraWidget[] = { {&_swigt__p__CameraWidget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPContext[] = { {&_swigt__p__GPContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPContextFeedback[] = { {&_swigt__p__GPContextFeedback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortInfo[] = { {&_swigt__p__GPPortInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortInfoList[] = { {&_swigt__p__GPPortInfoList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__Camera[] = { {&_swigt__p_p__Camera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__CameraStorageInformation[] = { {&_swigt__p_p__CameraStorageInformation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__CameraWidget[] = { {&_swigt__p_p__CameraWidget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__GPPortInfo[] = { {&_swigt__p_p__GPPortInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_CameraAbilities,
_swigc__p_CameraCaptureType,
_swigc__p_CameraDriverStatus,
_swigc__p_CameraEventType,
_swigc__p_CameraFileAccessType,
_swigc__p_CameraFileInfoFields,
_swigc__p_CameraFileOperation,
_swigc__p_CameraFilePath,
_swigc__p_CameraFilePermissions,
_swigc__p_CameraFileStatus,
_swigc__p_CameraFileType,
_swigc__p_CameraFolderOperation,
_swigc__p_CameraOperation,
_swigc__p_CameraStorageAccessType,
_swigc__p_CameraStorageFilesystemType,
_swigc__p_CameraStorageInfoFields,
_swigc__p_CameraStorageType,
_swigc__p_CameraText,
_swigc__p_CameraWidgetType,
_swigc__p_GPPortType,
_swigc__p_GphotoDeviceType,
_swigc__p_SwigPyObject,
_swigc__p__Camera,
_swigc__p__CameraAbilitiesList,
_swigc__p__CameraFile,
_swigc__p__CameraFileHandler,
_swigc__p__CameraFileInfo,
_swigc__p__CameraFileInfoAudio,
_swigc__p__CameraFileInfoFile,
_swigc__p__CameraFileInfoPreview,
_swigc__p__CameraFunctions,
_swigc__p__CameraList,
_swigc__p__CameraPrivateCore,
_swigc__p__CameraPrivateLibrary,
_swigc__p__CameraStorageInformation,
_swigc__p__CameraWidget,
_swigc__p__GPContext,
_swigc__p__GPContextFeedback,
_swigc__p__GPPortInfo,
_swigc__p__GPPortInfoList,
_swigc__p_char,
_swigc__p_int,
_swigc__p_long,
_swigc__p_long_long,
_swigc__p_p__Camera,
_swigc__p_p__CameraStorageInformation,
_swigc__p_p__CameraWidget,
_swigc__p_p__GPPortInfo,
_swigc__p_p_void,
_swigc__p_short,
_swigc__p_signed_char,
_swigc__p_unsigned_char,
_swigc__p_unsigned_int,
_swigc__p_unsigned_long_long,
_swigc__p_unsigned_short,
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};
#ifdef __cplusplus
}
#endif
static PyTypeObject *builtin_bases[2];
/* -----------------------------------------------------------------------------
* Type initialization:
* This problem is tough by the requirement that no dynamic
* memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
* to swig_type_info structures, we need some lookup code at initialization.
* The idea is that swig generates all the structures that are needed.
* The runtime then collects these partially filled structures.
* The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
* The generated swig_type_info structures are assigned statically to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
* cast linked list. The cast data is initially stored in something like a
* two-dimensional array. Each row corresponds to a type (there are the same
* number of rows as there are in the swig_type_initial array). Each entry in
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
* we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
* First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
* 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
* swig_cast_info to the linked list (because the cast->type) pointer will
* be correct.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif
#if 0
#define SWIGRUNTIME_DEBUG
#endif
#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif
SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
size_t i;
swig_module_info *module_head, *iter;
int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* Initialize the swig_module */
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
init = 1;
} else {
init = 0;
}
/* Try and load any already created modules */
module_head = SWIG_GetModule(clientdata);
if (!module_head) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
iter=module_head;
do {
if (iter==&swig_module) {
/* Our module is already in the list, so there's nothing more to do. */
return;
}
iter=iter->next;
} while (iter!= module_head);
/* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpreters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
if (init == 0) return;
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
if (swig_module.next != &swig_module) {
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
}
if (type) {
/* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
if (swig_module.type_initial[i]->clientdata) {
type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
}
} else {
type = swig_module.type_initial[i];
}
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
if (swig_module.next != &swig_module) {
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
}
if (ret) {
if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
cast->type = ret;
ret = 0;
} else {
/* Check for casting already in the list */
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
if (!ocast) ret = 0;
}
}
if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
if (type->cast) {
type->cast->prev = cast;
cast->next = type->cast;
}
type->cast = cast;
}
cast++;
}
/* Set entry in modules->types array equal to the type */
swig_module.types[i] = type;
}
swig_module.types[i] = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("**** SWIG_InitializeModule: Cast List ******\n");
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
++j;
}
printf("---- Total casts: %d\n",j);
}
printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}
/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types. It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
size_t i;
swig_cast_info *equiv;
static int init_run = 0;
if (init_run) return;
init_run = 1;
for (i = 0; i < swig_module.size; i++) {
if (swig_module.types[i]->clientdata) {
equiv = swig_module.types[i]->cast;
while (equiv) {
if (!equiv->converter) {
if (equiv->type && !equiv->type->clientdata)
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
}
equiv = equiv->next;
}
}
}
}
#ifdef __cplusplus
#if 0
{
/* c-mode */
#endif
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* constants/methods manipulation
* ----------------------------------------------------------------------------- */
/* Install Constants */
SWIGINTERN void
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
PyObject *obj = 0;
size_t i;
for (i = 0; constants[i].type; ++i) {
switch(constants[i].type) {
case SWIG_PY_POINTER:
obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_PY_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
break;
default:
obj = 0;
break;
}
if (obj) {
PyDict_SetItemString(d, constants[i].name, obj);
Py_DECREF(obj);
}
}
}
/* -----------------------------------------------------------------------------
* Patch %callback methods' docstrings to hold the callback ptrs
* -----------------------------------------------------------------------------*/
SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
size_t i;
for (i = 0; methods[i].ml_name; ++i) {
const char *c = methods[i].ml_doc;
if (!c) continue;
c = strstr(c, "swig_ptr: ");
if (c) {
int j;
const swig_const_info *ci = 0;
const char *name = c + 10;
for (j = 0; const_table[j].type; ++j) {
if (strncmp(const_table[j].name, name,
strlen(const_table[j].name)) == 0) {
ci = &(const_table[j]);
break;
}
}
if (ci) {
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
if (ptr) {
size_t shift = (ci->ptype) - types;
swig_type_info *ty = types_initial[shift];
size_t ldoc = (c - methods[i].ml_doc);
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
char *ndoc = (char*)malloc(ldoc + lptr + 10);
if (ndoc) {
char *buff = ndoc;
memcpy(buff, methods[i].ml_doc, ldoc);
buff += ldoc;
memcpy(buff, "swig_ptr: ", 10);
buff += 10;
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
methods[i].ml_doc = ndoc;
}
}
}
}
}
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------*
* Partial Init method
* -----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
PyObject *m, *d, *md, *globals;
#if PY_VERSION_HEX >= 0x03000000
static struct PyModuleDef SWIG_module = {
PyModuleDef_HEAD_INIT,
SWIG_name,
NULL,
-1,
SwigMethods,
NULL,
NULL,
NULL,
NULL
};
#endif
#if defined(SWIGPYTHON_BUILTIN)
static SwigPyClientData SwigPyObject_clientdata = {
0, 0, 0, 0, 0, 0, 0
};
static PyGetSetDef this_getset_def = {
(char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
};
static SwigPyGetSet thisown_getset_closure = {
SwigPyObject_own,
SwigPyObject_own
};
static PyGetSetDef thisown_getset_def = {
(char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
};
PyTypeObject *builtin_pytype;
int builtin_base_count;
swig_type_info *builtin_basetype;
PyObject *tuple;
PyGetSetDescrObject *static_getset;
PyTypeObject *metatype;
PyTypeObject *swigpyobject;
SwigPyClientData *cd;
PyObject *public_interface, *public_symbol;
PyObject *this_descr;
PyObject *thisown_descr;
PyObject *self = 0;
int i;
(void)builtin_pytype;
(void)builtin_base_count;
(void)builtin_basetype;
(void)tuple;
(void)static_getset;
(void)self;
/* Metaclass is used to implement static member variables */
metatype = SwigPyObjectType();
assert(metatype);
#endif
(void)globals;
/* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
SWIG_This();
SWIG_Python_TypeCache();
SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
SwigPyObject_type();
#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
#if PY_VERSION_HEX >= 0x03000000
m = PyModule_Create(&SWIG_module);
#else
m = Py_InitModule(SWIG_name, SwigMethods);
#endif
md = d = PyModule_GetDict(m);
(void)md;
SWIG_InitializeModule(0);
#ifdef SWIGPYTHON_BUILTIN
swigpyobject = SwigPyObject_TypeOnce();
SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
if (!cd) {
SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
SwigPyObject_clientdata.pytype = swigpyobject;
} else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
return NULL;
# else
return;
# endif
}
/* All objects have a 'this' attribute */
this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
(void)this_descr;
/* All objects have a 'thisown' attribute */
thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
(void)thisown_descr;
public_interface = PyList_New(0);
public_symbol = 0;
(void)public_symbol;
PyDict_SetItemString(md, "__all__", public_interface);
Py_DECREF(public_interface);
for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
for (i = 0; swig_const_table[i].name != 0; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
SWIG_InstallConstants(d,swig_const_table);
{
PyObject *module = PyImport_ImportModule("gphoto2");
if (module != NULL) {
PyExc_GPhoto2Error = PyObject_GetAttrString(module, "GPhoto2Error");
Py_DECREF(module);
}
if (PyExc_GPhoto2Error == NULL)
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
/* type '::CameraText' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CameraText_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraText'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CameraText", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraText");
d = md;
/* type '::CameraFilePath' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CameraFilePath_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraFilePath'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CameraFilePath", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraFilePath");
d = md;
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_CAPTURE_IMAGE",SWIG_From_int((int)(GP_CAPTURE_IMAGE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_CAPTURE_MOVIE",SWIG_From_int((int)(GP_CAPTURE_MOVIE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_CAPTURE_SOUND",SWIG_From_int((int)(GP_CAPTURE_SOUND)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_EVENT_UNKNOWN",SWIG_From_int((int)(GP_EVENT_UNKNOWN)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_EVENT_TIMEOUT",SWIG_From_int((int)(GP_EVENT_TIMEOUT)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_EVENT_FILE_ADDED",SWIG_From_int((int)(GP_EVENT_FILE_ADDED)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_EVENT_FOLDER_ADDED",SWIG_From_int((int)(GP_EVENT_FOLDER_ADDED)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_EVENT_CAPTURE_COMPLETE",SWIG_From_int((int)(GP_EVENT_CAPTURE_COMPLETE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_EVENT_FILE_CHANGED",SWIG_From_int((int)(GP_EVENT_FILE_CHANGED)));
/* type '::_Camera' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___Camera_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'Camera'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "Camera", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "Camera");
d = md;
/* Initialize threading */
SWIG_PYTHON_INITIALIZE_THREADS;
#if PY_VERSION_HEX >= 0x03000000
return m;
#else
return;
#endif
}
python-gphoto2-2.5.1/src/swig-gp2_5_31/context.py 0000664 0000000 0000000 00000000674 14703210004 0021431 0 ustar 00root root 0000000 0000000 # This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
# Pull in all the attributes from the low-level C/C++ module
if __package__ or "." in __name__:
from ._context import *
else:
from _context import *
Context = GPContext
python-gphoto2-2.5.1/src/swig-gp2_5_31/context_wrap.c 0000664 0000000 0000000 00000635444 14703210004 0022265 0 ustar 00root root 0000000 0000000 /* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (https://www.swig.org).
* Version 4.1.1
*
* Do not make changes to this file unless you know what you are doing - modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
#define SWIG_VERSION 0x040101
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_BUILTIN
#define SWIGPYTHON_FASTPROXY
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if defined(__GNUC__)
# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
/* Intel's compiler complains if a variable which was never initialised is
* cast to void, which is a common idiom which we use to indicate that we
* are aware a variable isn't used. So we just silence that warning.
* See: https://github.com/swig/swig/issues/192 for more discussion.
*/
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include
#endif
#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
* See https://github.com/swig/swig/issues/2090 */
# include
#endif
# undef _DEBUG
# include
# define _DEBUG 1
#else
# include
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
creating a static or dynamic library from the SWIG runtime code.
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
But only do this if strictly necessary, ie, if you have problems
with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif
#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif
/* Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
#define SWIG_POINTER_NO_NULL 0x4
#define SWIG_POINTER_CLEAR 0x8
#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
if (SWIG_IsOK(res)) {
// success code
if (SWIG_IsNewObj(res) {
...
delete *ptr;
} else {
...
}
} else {
// fail code
}
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if () {
if () {
*ptr = ;
return SWIG_NEWOBJ;
} else {
*ptr = ;
return SWIG_OLDOBJ;
}
} else {
return SWIG_BADOBJ;
}
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows returning the 'cast rank', for example, if you have this
int food(double)
int fooi(int);
and you call
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
*/
#define SWIG_OK (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ (SWIG_ERROR)
#define SWIG_OLDOBJ (SWIG_OK)
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
# define SWIG_TypeRank unsigned long
# endif
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
# define SWIG_MAXCASTRANK (2)
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
# define SWIG_AddCast(r) (r)
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
#include
#ifdef __cplusplus
extern "C" {
#endif
typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
void *clientdata; /* language specific type data */
int owndata; /* flag if the structure owns the clientdata */
} swig_type_info;
/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
swig_type_info *type; /* pointer to type that is equivalent to this type */
swig_converter_func converter; /* function to cast the void pointers */
struct swig_cast_info *next; /* pointer to next cast in linked list */
struct swig_cast_info *prev; /* pointer to the previous cast */
} swig_cast_info;
/* Structure used to store module information
* Each module generates one structure like this, and the runtime collects
* all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
size_t size; /* Number of types in this module */
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
swig_type_info **type_initial; /* Array of initially generated type structures */
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
void *clientdata; /* Language specific module data */
} swig_module_info;
/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class" == "Class", etc.
Return 0 when the two name types are equivalent, as in
strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
const char *f2, const char *l2) {
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
while ((*f1 == ' ') && (f1 != l1)) ++f1;
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
return (int)((l1 - f1) - (l2 - f2));
}
/*
Check type equivalence in a name list like ||...
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
}
/*
Check type equivalence in a name list like ||...
Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (strcmp(iter->type->name, c) == 0) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (iter->type == from) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
swig_type_info *lastty = ty;
if (!ty || !ty->dcast) return ty;
while (ty && (ty->dcast)) {
ty = (*ty->dcast)(ptr);
if (ty) lastty = ty;
}
return lastty;
}
/*
Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
return ty->name;
}
/*
Return the pretty name associated with this type,
that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
/* The "str" field contains the equivalent pretty names of the
type, separated by vertical-bar characters. Choose the last
name. It should be the most specific; a fully resolved name
but not necessarily with default template parameters expanded. */
if (!type) return NULL;
if (type->str != NULL) {
const char *last_name = type->str;
const char *s;
for (s = type->str; *s; s++)
if (*s == '|') last_name = s+1;
return last_name;
}
else
return type->name;
}
/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
}
cast = cast->next;
}
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
size_t l = 0;
size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
r = i - 1;
} else {
break;
}
} else if (compare > 0) {
l = i + 1;
}
} else {
break; /* should never happen */
}
} while (l <= r);
}
iter = iter->next;
} while (iter != end);
return 0;
}
/*
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
if (ret) {
return ret;
} else {
/* STEP 2: If the type hasn't been found, do a complete search
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
}
iter = iter->next;
} while (iter != end);
}
/* neither found a match */
return 0;
}
/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
const unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
char d = *(c++);
unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
uu = (unsigned char)((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
uu |= (unsigned char)(d - ('a'-10));
else
return (char *) 0;
*u = uu;
}
return c;
}
/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
char *r = buff;
if ((2*sizeof(void *) + 2) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,&ptr,sizeof(void *));
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
strcpy(r,name);
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
*ptr = (void *) 0;
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sizeof(void *));
}
SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
char *r = buff;
size_t lname = (name ? strlen(name) : 0);
if ((2*sz + 2 + lname) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
if (lname) {
strncpy(r,name,lname+1);
} else {
*r = 0;
}
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
memset(ptr,0,sz);
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sz);
}
#ifdef __cplusplus
}
#endif
/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
#endif
#ifndef Py_TYPE
# define Py_TYPE(op) ((op)->ob_type)
#endif
/* SWIG APIs for compatibility of both Python 2 & 3 */
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
# define SWIG_Python_str_FromFormat PyString_FromFormat
#endif
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03030000
return (char *)PyUnicode_AsUTF8(str);
#else
return PyString_AsString(str);
#endif
}
/* Was useful for Python 3.0.x-3.2.x - now provided only for compatibility
* with any uses in user interface files. */
#define SWIG_Python_str_DelForPy3(x)
SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromString(c);
#else
return PyString_FromString(c);
#endif
}
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif
/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif
/* -----------------------------------------------------------------------------
* error manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
PyObject* type = 0;
switch(code) {
case SWIG_MemoryError:
type = PyExc_MemoryError;
break;
case SWIG_IOError:
type = PyExc_IOError;
break;
case SWIG_RuntimeError:
type = PyExc_RuntimeError;
break;
case SWIG_IndexError:
type = PyExc_IndexError;
break;
case SWIG_TypeError:
type = PyExc_TypeError;
break;
case SWIG_DivisionByZero:
type = PyExc_ZeroDivisionError;
break;
case SWIG_OverflowError:
type = PyExc_OverflowError;
break;
case SWIG_SyntaxError:
type = PyExc_SyntaxError;
break;
case SWIG_ValueError:
type = PyExc_ValueError;
break;
case SWIG_SystemError:
type = PyExc_SystemError;
break;
case SWIG_AttributeError:
type = PyExc_AttributeError;
break;
default:
type = PyExc_RuntimeError;
}
return type;
}
SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
if (PyErr_Occurred())
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
PyErr_Clear();
Py_XINCREF(type);
if (tmp)
PyErr_Format(type, "%s %s", tmp, mesg);
else
PyErr_Format(type, "%s", mesg);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
PyErr_SetString(PyExc_RuntimeError, mesg);
}
}
SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
PyObject *error;
if (obj)
return 0;
error = PyErr_Occurred();
return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}
SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
if (SWIG_Python_TypeErrorOccurred(NULL)) {
/* Use existing TypeError to preserve stacktrace and enhance with given message */
PyObject *newvalue;
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
if (newvalue) {
Py_XDECREF(value);
PyErr_Restore(type, newvalue, traceback);
} else {
PyErr_Restore(type, value, traceback);
}
} else {
/* Raise TypeError using given message */
PyErr_SetString(PyExc_TypeError, message);
}
}
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
# undef SWIG_PYTHON_THREADS
# endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
# define SWIG_PYTHON_USE_GIL
# endif
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# if PY_VERSION_HEX < 0x03070000
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
# else
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# endif
# ifdef __cplusplus /* C++ code */
class SWIG_Python_Thread_Block {
bool status;
PyGILState_STATE state;
public:
void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block() { end(); }
};
class SWIG_Python_Thread_Allow {
bool status;
PyThreadState *save;
public:
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow() { end(); }
};
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
# else /* C code */
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
# endif
# else /* Old thread way, not implemented, user must provide it */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
# define SWIG_PYTHON_THREAD_END_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# endif
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
# define SWIG_PYTHON_THREAD_END_ALLOW
# endif
# endif
#else /* No thread support */
# define SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# define SWIG_PYTHON_THREAD_END_BLOCK
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# define SWIG_PYTHON_THREAD_END_ALLOW
#endif
/* -----------------------------------------------------------------------------
* Python API portion that goes into the runtime
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* Constant declarations
* ----------------------------------------------------------------------------- */
/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY 5
/* Constant information structure */
typedef struct swig_const_info {
int type;
const char *name;
long lvalue;
double dvalue;
void *pvalue;
swig_type_info **ptype;
} swig_const_info;
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* pyrun.swg
*
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* type checking.
*
* ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif
#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#endif
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif
#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
#define SWIG_fail goto fail
/* Runtime API implementation */
/* Error manipulation */
SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetObject(errtype, obj);
Py_DECREF(obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetString(errtype, msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
/* Set a constant value */
#if defined(SWIGPYTHON_BUILTIN)
SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
PyObject *s = PyString_InternFromString(key);
PyList_Append(seq, s);
Py_DECREF(s);
}
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
if (public_interface)
SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}
#else
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
}
#endif
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyList_Check(result)) {
PyObject *o2 = result;
result = PyList_New(1);
if (result) {
PyList_SET_ITEM(result, 0, o2);
} else {
Py_DECREF(obj);
return o2;
}
}
PyList_Append(result,obj);
Py_DECREF(obj);
}
return result;
}
/* Unpack the argument tuple */
SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
if (!PyTuple_Check(args)) {
if (min <= 1 && max >= 1) {
Py_ssize_t i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
}
return 2;
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
Py_ssize_t i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
for (; l < max; ++l) {
objs[l] = 0;
}
return i + 1;
}
}
}
SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
int no_kwargs = 1;
if (kwargs) {
assert(PyDict_Check(kwargs));
if (PyDict_Size(kwargs) > 0) {
PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
no_kwargs = 0;
}
}
return no_kwargs;
}
/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
/*
Helper for static pointer initialization for both C and C++ code, for example
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var) var
#else
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Python-specific SWIG API */
#define SWIG_newvarlink() SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
/* -----------------------------------------------------------------------------
* global variable support code.
* ----------------------------------------------------------------------------- */
typedef struct swig_globalvar {
char *name; /* Name of global variable */
PyObject *(*get_attr)(void); /* Return the current value */
int (*set_attr)(PyObject *); /* Set the value */
struct swig_globalvar *next;
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar *vars;
} swig_varlinkobject;
SWIGINTERN PyObject *
swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_InternFromString("");
#else
return PyString_FromString("");
#endif
}
SWIGINTERN PyObject *
swig_varlink_str(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
PyObject *str = PyUnicode_InternFromString("(");
PyObject *tail;
PyObject *joined;
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
tail = PyUnicode_FromString(var->name);
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
if (var->next) {
tail = PyUnicode_InternFromString(", ");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
}
}
tail = PyUnicode_InternFromString(")");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
#else
PyObject *str = PyString_FromString("(");
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
return str;
}
SWIGINTERN void
swig_varlink_dealloc(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
swig_globalvar *var = v->vars;
while (var) {
swig_globalvar *n = var->next;
free(var->name);
free(var);
var = n;
}
}
SWIGINTERN PyObject *
swig_varlink_getattr(PyObject *o, char *n) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
PyObject *res = NULL;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->get_attr)();
break;
}
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN int
swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
int res = 1;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->set_attr)(p);
break;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
static char varlink__doc__[] = "Swig var link object";
static PyTypeObject varlink_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"swigvarlink", /* tp_name */
sizeof(swig_varlinkobject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) swig_varlink_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc) swig_varlink_getattr, /* tp_getattr */
(setattrfunc) swig_varlink_setattr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc) swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
varlink__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
varlink_type = tmp;
type_init = 1;
if (PyType_Ready(&varlink_type) < 0)
return NULL;
}
return &varlink_type;
}
/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
if (result) {
result->vars = 0;
}
return ((PyObject*) result);
}
SWIGINTERN void
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
memcpy(gv->name, name, size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
}
}
v->vars = gv;
}
static PyObject *Swig_Globals_global = NULL;
SWIGINTERN PyObject *
SWIG_globals(void) {
if (Swig_Globals_global == NULL) {
Swig_Globals_global = SWIG_newvarlink();
}
return Swig_Globals_global;
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* Pointer declarations
* ----------------------------------------------------------------------------- */
/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
#ifdef __cplusplus
extern "C" {
#endif
/* The python void return value */
SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)
{
PyObject *none = Py_None;
Py_INCREF(none);
return none;
}
/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
PyTypeObject *pytype;
} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
int fail = data ? data->implicitconv : 0;
if (fail)
PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
return fail;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
/* the newraw method and newargs arguments used to create a new raw instance */
if (PyClass_Check(obj)) {
data->newraw = 0;
Py_INCREF(obj);
data->newargs = obj;
} else {
data->newraw = PyObject_GetAttrString(data->klass, "__new__");
if (data->newraw) {
data->newargs = PyTuple_New(1);
if (data->newargs) {
Py_INCREF(obj);
PyTuple_SET_ITEM(data->newargs, 0, obj);
} else {
Py_DECREF(data->newraw);
Py_DECREF(data->klass);
free(data);
return 0;
}
} else {
Py_INCREF(obj);
data->newargs = obj;
}
}
/* the destroy method, aka as the C++ delete method */
data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
}
if (data->destroy) {
data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
} else {
data->delargs = 0;
}
data->implicitconv = 0;
data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData *data)
{
Py_XDECREF(data->klass);
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
free(data);
}
/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
PyObject *dict;
#endif
} SwigPyObject;
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
if (!sobj->dict)
sobj->dict = PyDict_New();
Py_XINCREF(sobj->dict);
return sobj->dict;
}
#endif
SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
PyObject *val = SwigPyObject_long(v);
if (val) {
PyObject *ofmt;
PyTuple_SET_ITEM(args, 0, val);
ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
res = PyUnicode_Format(ofmt,args);
#else
res = PyString_Format(ofmt,args);
#endif
Py_DECREF(ofmt);
}
}
Py_DECREF(args);
}
return res;
}
SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v);
if (repr && v->next) {
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
PyObject *joined = PyUnicode_Concat(repr, nrep);
Py_DecRef(repr);
Py_DecRef(nrep);
repr = joined;
# else
PyString_ConcatAndDel(&repr,nrep);
# endif
} else {
Py_DecRef(repr);
repr = NULL;
}
}
return repr;
}
/* We need a version taking two PyObject* parameters so it's a valid
* PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
return SwigPyObject_repr((SwigPyObject*)v);
}
SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
PyObject* res;
if( op != Py_EQ && op != Py_NE ) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
return res;
}
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
SwigPyClientData *cd;
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
assert(cd);
assert(cd->pytype);
return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
#endif
SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
PyTypeObject *target_tp = SwigPyObject_type();
if (PyType_IsSubtype(op->ob_type, target_tp))
return 1;
return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
return (Py_TYPE(op) == SwigPyObject_type())
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
static PyObject* Swig_Capsule_global = NULL;
SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
/* PyObject_CallFunction() has the potential to silently drop
the active exception. In cases of unnamed temporary
variable or where we just finished iterating over a generator
StopIteration will be active right now, and this needs to
remain true upon return from SwigPyObject_dealloc. So save
and restore. */
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
if (data->delargs) {
/* we need to create a temporary object to carry the destroy operation */
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
if (tmp) {
res = SWIG_Python_CallFunctor(destroy, tmp);
} else {
res = 0;
}
Py_XDECREF(tmp);
} else {
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
PyObject *mself = PyCFunction_GET_SELF(destroy);
res = ((*meth)(mself, v));
}
if (!res)
PyErr_WriteUnraisable(destroy);
PyErr_Restore(type, value, traceback);
Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
else {
const char *name = SWIG_TypePrettyName(ty);
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
#endif
Py_XDECREF(Swig_Capsule_global);
}
Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
Py_XDECREF(sobj->dict);
#endif
PyObject_DEL(v);
}
SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject* v, PyObject* next)
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (!SwigPyObject_Check(next)) {
PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
((SwigPyObject *)next)->next = sobj->next;
sobj->next = next;
Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
return NULL;
} else {
SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
if (PyObject_IsTrue(val)) {
Py_DECREF(SwigPyObject_acquire(v,args));
} else {
Py_DECREF(SwigPyObject_disown(v,args));
}
}
return obj;
}
}
static PyMethodDef
swigobject_methods[] = {
{"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
{"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
{"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
{"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
{"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
{"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
{0, 0, 0, 0}
};
SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
/* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
#endif
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
(unaryfunc)0, /*nb_negative*/
(unaryfunc)0, /*nb_positive*/
(unaryfunc)0, /*nb_absolute*/
(inquiry)0, /*nb_nonzero*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
0, /*nb_coerce*/
#endif
(unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_long, /*nb_long*/
#else
0, /*nb_reserved*/
#endif
(unaryfunc)0, /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
};
static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyObject", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
(cmpfunc)SwigPyObject_compare, /* tp_compare */
#endif
(reprfunc)SwigPyObject_repr, /* tp_repr */
&SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigobject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
(richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
swigobject_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobject_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpyobject_type) != 0)
return NULL;
}
return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
sobj->own = own;
sobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
sobj->dict = 0;
#endif
if (own == SWIG_POINTER_OWN) {
/* Obtain a reference to the Python capsule wrapping the module information, so that the
* module information is correctly destroyed after all SWIG python objects have been freed
* by the GC (and corresponding destructors invoked) */
Py_XINCREF(Swig_Capsule_global);
}
}
return (PyObject *)sobj;
}
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
void *pack;
swig_type_info *ty;
size_t size;
} SwigPyPacked;
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return SWIG_Python_str_FromFormat("", result, v->ty->name);
} else {
return SWIG_Python_str_FromFormat("", v->ty->name);
}
}
SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}
SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
return ((op)->ob_type == SwigPyPacked_TypeOnce())
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
if (SwigPyPacked_Check(v)) {
SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyPacked", /* tp_name */
sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
0, /* tp_reserved in 3.0.1 */
#else
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
#endif
(reprfunc)SwigPyPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigpacked_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpypacked_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpypacked_type) != 0)
return NULL;
}
return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
memcpy(pack, ptr, size);
sobj->pack = pack;
sobj->ty = ty;
sobj->size = size;
} else {
PyObject_DEL((PyObject *) sobj);
sobj = 0;
}
}
return (PyObject *) sobj;
}
SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (SwigPyPacked_Check(obj)) {
SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
} else {
return 0;
}
}
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
static PyObject *Swig_This_global = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
if (Swig_This_global == NULL)
Swig_This_global = SWIG_Python_str_FromChar("this");
return Swig_This_global;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS
#endif
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
PyObject *obj;
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
#ifdef SWIGPYTHON_BUILTIN
(void)obj;
# ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
pyobj = PyWeakref_GET_OBJECT(pyobj);
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
# endif
return NULL;
#else
obj = 0;
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
}
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
#endif
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
return oldown;
}
}
return 0;
}
/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
int res;
SwigPyObject *sobj;
int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
if (!obj)
return SWIG_ERROR;
if (obj == Py_None && !implicit_conv) {
if (ptr)
*ptr = 0;
return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
}
res = SWIG_ERROR;
sobj = SWIG_Python_GetSwigThis(obj);
if (own)
*own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
swig_type_info *to = sobj->ty;
if (to == ty) {
/* no type cast needed */
if (ptr) *ptr = vptr;
break;
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
sobj = (SwigPyObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
if (own)
*own = *own | SWIG_CAST_NEW_MEMORY;
}
}
break;
}
}
} else {
if (ptr) *ptr = vptr;
break;
}
}
if (sobj) {
if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
res = SWIG_ERROR_RELEASE_NOT_OWNED;
} else {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
if (flags & SWIG_POINTER_CLEAR) {
sobj->ptr = 0;
}
res = SWIG_OK;
}
} else {
if (implicit_conv) {
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
PyObject *impconv;
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
impconv = SWIG_Python_CallFunctor(klass, obj);
data->implicitconv = 0;
if (PyErr_Occurred()) {
PyErr_Clear();
impconv = 0;
}
if (impconv) {
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
if (SWIG_IsOK(res)) {
if (ptr) {
*ptr = vptr;
/* transfer the ownership to 'ptr' */
iobj->own = 0;
res = SWIG_AddCast(res);
res = SWIG_AddNewMask(res);
} else {
res = SWIG_AddCast(res);
}
}
}
Py_DECREF(impconv);
}
}
}
if (!SWIG_IsOK(res) && obj == Py_None) {
if (ptr)
*ptr = 0;
if (PyErr_Occurred())
PyErr_Clear();
res = SWIG_OK;
}
}
}
return res;
}
/* Convert a function ptr value */
SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
if (!PyCFunction_Check(obj)) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
swig_cast_info *tc;
/* here we get the method pointer for callbacks */
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
if (!desc)
return SWIG_ERROR;
tc = SWIG_TypeCheck(desc,ty);
if (tc) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
} else {
return SWIG_ERROR;
}
return SWIG_OK;
}
}
/* Convert a packed pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
/* check type cast? */
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* -----------------------------------------------------------------------------
* Create a new pointer object
* ----------------------------------------------------------------------------- */
/*
Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
inst = PyObject_Call(newraw, data->newargs, NULL);
if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
Py_DECREF(inst);
inst = 0;
}
}
#else
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
}
#endif
}
} else {
#if PY_VERSION_HEX >= 0x03000000
PyObject *empty_args = PyTuple_New(0);
if (empty_args) {
PyObject *empty_kwargs = PyDict_New();
if (empty_kwargs) {
inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
Py_DECREF(empty_kwargs);
if (inst) {
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
} else {
PyType_Modified(Py_TYPE(inst));
}
}
}
Py_DECREF(empty_args);
}
#else
PyObject *dict = PyDict_New();
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
}
#endif
}
return inst;
}
SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
return PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
return -1;
}
}
#endif
return PyObject_SetAttr(inst, SWIG_This(), swig_this);
}
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
return NULL;
} else {
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
} else {
if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
return NULL;
}
return SWIG_Py_Void();
}
}
/* Create a new pointer object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
SwigPyClientData *clientdata;
PyObject * robj;
int own;
if (!ptr)
return SWIG_Py_Void();
clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
if (clientdata && clientdata->pytype) {
SwigPyObject *newobj;
if (flags & SWIG_BUILTIN_TP_INIT) {
newobj = (SwigPyObject*) self;
if (newobj->ptr) {
PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
while (newobj->next)
newobj = (SwigPyObject *) newobj->next;
newobj->next = next_self;
newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
newobj->dict = 0;
#endif
}
} else {
newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
if (newobj) {
newobj->dict = 0;
}
#endif
}
if (newobj) {
newobj->ptr = ptr;
newobj->ty = type;
newobj->own = own;
newobj->next = 0;
return (PyObject*) newobj;
}
return SWIG_Py_Void();
}
assert(!(flags & SWIG_BUILTIN_TP_INIT));
robj = SwigPyObject_New(ptr, type, own);
if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
Py_DECREF(robj);
robj = inst;
}
return robj;
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
* Get type list
* -----------------------------------------------------------------------------*/
#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif
static PyObject *Swig_TypeCache_global = NULL;
/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
if (Swig_TypeCache_global == NULL) {
Swig_TypeCache_global = PyDict_New();
}
return Swig_TypeCache_global;
}
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
}
#else
void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
}
#endif
return (swig_module_info *) type_pointer;
}
static int interpreter_counter = 0; // how many (sub-)interpreters are using swig_module's types
SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
swig_type_info **types = swig_module->types;
size_t i;
if (--interpreter_counter != 0) // another sub-interpreter may still be using the swig_module's types
return;
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
ty->clientdata = 0;
if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
Swig_This_global = NULL;
Py_DECREF(SWIG_globals());
Swig_Globals_global = NULL;
Py_DECREF(SWIG_Python_TypeCache());
Swig_TypeCache_global = NULL;
Swig_Capsule_global = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
/* Add a dummy module object into sys.modules */
PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && module) {
if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
++interpreter_counter;
Swig_Capsule_global = pointer;
} else {
Py_DECREF(pointer);
}
} else {
Py_XDECREF(pointer);
}
}
SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
PyObject *key = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
} else {
swig_module_info *swig_module = SWIG_GetModule(0);
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
obj = PyCapsule_New((void*) descriptor, NULL, NULL);
if (obj) {
PyDict_SetItem(cache, key, obj);
Py_DECREF(obj);
}
}
}
Py_DECREF(key);
return descriptor;
}
/*
For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION 0
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
const char *errmesg = tmp ? tmp : "Invalid error message";
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, errmesg);
} else {
PyErr_Format(type, "%s %s", errmesg, mesg);
}
Py_DECREF(old_str);
}
return 1;
} else {
return 0;
}
}
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
if (PyErr_Occurred()) {
/* add information about failing argument */
char mesg[256];
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
} else {
return 0;
}
}
SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : "";
}
SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
if (obj && SwigPyObject_Check(obj)) {
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
type, otype);
return;
}
} else
#endif
{
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
}
Py_XDECREF(str);
return;
}
}
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
} else {
PyErr_Format(PyExc_TypeError, "unexpected type is received");
}
}
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
}
return result;
}
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
PyTypeObject *tp = obj->ob_type;
PyObject *descr;
PyObject *encoded_name;
descrsetfunc f;
int res = -1;
# ifdef Py_USING_UNICODE
if (PyString_Check(name)) {
name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
if (!name)
return -1;
} else if (!PyUnicode_Check(name))
# else
if (!PyString_Check(name))
# endif
{
PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
return -1;
} else {
Py_INCREF(name);
}
if (!tp->tp_dict) {
if (PyType_Ready(tp) != 0)
goto done;
}
descr = _PyType_Lookup(tp, name);
f = NULL;
if (descr != NULL)
f = descr->ob_type->tp_descr_set;
if (!f) {
if (PyString_Check(name)) {
encoded_name = name;
Py_INCREF(name);
} else {
encoded_name = PyUnicode_AsUTF8String(name);
if (!encoded_name)
goto done;
}
PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
Py_DECREF(encoded_name);
} else {
res = f(descr, obj, value);
}
done:
Py_DECREF(name);
return res;
}
#endif
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN Py_hash_t
SwigPyObject_hash(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
void *ptr = sobj->ptr;
#if PY_VERSION_HEX < 0x03020000
return (Py_hash_t)(Py_ssize_t)ptr;
#else
return (Py_hash_t)ptr;
#endif
}
SWIGINTERN Py_hash_t
SWIG_PyNumber_AsPyHash(PyObject *obj) {
Py_hash_t result = -1;
#if PY_VERSION_HEX < 0x03020000
if (PyInt_Check(obj))
result = PyInt_AsLong(obj);
else if (PyLong_Check(obj))
result = PyLong_AsLong(obj);
#else
if (PyNumber_Check(obj))
result = PyNumber_AsSsize_t(obj, NULL);
#endif
else
PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
return PyErr_Occurred() ? -1 : result;
}
SWIGINTERN int
SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
return -1;
}
SWIGINTERN void
SwigPyBuiltin_BadDealloc(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
if (sobj->own) {
PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", obj->ob_type->tp_name);
}
}
typedef struct {
PyCFunction get;
PyCFunction set;
} SwigPyGetSet;
SWIGINTERN PyObject *
SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
tuple = PyTuple_New(0);
assert(tuple);
result = (*getset->get)(obj, tuple);
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyObject *
SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
result = (*getset->get)(obj, NULL);
return result;
}
SWIGINTERN int
SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(val);
PyTuple_SET_ITEM(tuple, 0, val);
result = (*getset->set)(obj, tuple);
Py_DECREF(tuple);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN int
SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
result = (*getset->set)(obj, val);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN void
SwigPyStaticVar_dealloc(PyDescrObject *descr) {
PyObject_GC_UnTrack(descr);
Py_XDECREF(PyDescr_TYPE(descr));
Py_XDECREF(PyDescr_NAME(descr));
PyObject_GC_Del(descr);
}
SWIGINTERN PyObject *
SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromFormat("", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
return PyString_FromFormat("", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
}
SWIGINTERN int
SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
PyDescrObject *descr;
descr = (PyDescrObject *)self;
Py_VISIT((PyObject*) PyDescr_TYPE(descr));
return 0;
}
SWIGINTERN PyObject *
SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
if (descr->d_getset->get != NULL)
return descr->d_getset->get(obj, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return NULL;
}
SWIGINTERN int
SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
if (descr->d_getset->set != NULL)
return descr->d_getset->set(obj, value, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return -1;
}
SWIGINTERN int
SwigPyObjectType_setattro(PyObject *typeobject, PyObject *name, PyObject *value) {
PyObject *attribute;
PyTypeObject *type;
descrsetfunc local_set;
assert(PyType_Check(typeobject));
type = (PyTypeObject *)typeobject;
attribute = _PyType_Lookup(type, name);
if (attribute != NULL) {
/* Implement descriptor functionality, if any */
local_set = attribute->ob_type->tp_descr_set;
if (local_set != NULL)
return local_set(attribute, (PyObject *)type, value);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
} else {
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
}
return -1;
}
SWIGINTERN PyTypeObject*
SwigPyStaticVar_Type(void) {
static PyTypeObject staticvar_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"swig_static_var_getset_descriptor", /* tp_name */
sizeof(PyGetSetDescrObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyStaticVar_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
(reprfunc)SwigPyStaticVar_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
0, /* tp_doc */
SwigPyStaticVar_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc)SwigPyStaticVar_get, /* tp_descr_get */
(descrsetfunc)SwigPyStaticVar_set, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
staticvar_type = tmp;
type_init = 1;
if (PyType_Ready(&staticvar_type) < 0)
return NULL;
}
return &staticvar_type;
}
SWIGINTERN PyTypeObject*
SwigPyObjectType(void) {
static char swigpyobjecttype_doc[] = "Metaclass for SWIG wrapped types";
static PyTypeObject swigpyobjecttype_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"SwigPyObjectType", /* tp_name */
PyType_Type.tp_basicsize, /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
SwigPyObjectType_setattro, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
swigpyobjecttype_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobjecttype_type = tmp;
type_init = 1;
swigpyobjecttype_type.tp_base = &PyType_Type;
if (PyType_Ready(&swigpyobjecttype_type) < 0)
return NULL;
}
return &swigpyobjecttype_type;
}
SWIGINTERN PyGetSetDescrObject *
SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
PyGetSetDescrObject *descr;
descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
assert(descr);
Py_XINCREF(type);
PyDescr_TYPE(descr) = type;
PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
descr->d_getset = getset;
if (PyDescr_NAME(descr) == NULL) {
Py_DECREF(descr);
descr = NULL;
}
return descr;
}
SWIGINTERN void
SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
Py_ssize_t base_count = 0;
PyTypeObject **b;
PyObject *tuple;
Py_ssize_t i;
if (!bases[0]) {
bases[0] = SwigPyObject_type();
bases[1] = NULL;
}
type->tp_base = bases[0];
Py_INCREF((PyObject *)bases[0]);
for (b = bases; *b != NULL; ++b)
++base_count;
tuple = PyTuple_New(base_count);
for (i = 0; i < base_count; ++i) {
Py_INCREF((PyObject *)bases[i]);
PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
}
type->tp_bases = tuple;
}
SWIGINTERN PyObject *
SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
PyObject *result;
result = (PyObject *)SWIG_Python_GetSwigThis(self);
Py_XINCREF(result);
return result;
}
SWIGINTERN void
SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
{
#if PY_VERSION_HEX >= 0x030900a4
Py_SET_TYPE(type, metatype);
#else
Py_TYPE(type) = metatype;
#endif
}
/* Start of callback function macros for use in PyTypeObject */
typedef PyObject *(*SwigPyWrapperFunction)(PyObject *, PyObject *);
#define SWIGPY_UNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_unaryfunc_closure(PyObject *a) { \
return SwigPyBuiltin_unaryfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_unaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper) \
SWIGINTERN void \
wrapper##_destructor_closure(PyObject *a) { \
SwigPyBuiltin_destructor_closure(wrapper, #wrapper, a); \
}
SWIGINTERN void
SwigPyBuiltin_destructor_closure(SwigPyWrapperFunction wrapper, const char *wrappername, PyObject *a) {
SwigPyObject *sobj;
sobj = (SwigPyObject *)a;
Py_XDECREF(sobj->dict);
if (sobj->own) {
PyObject *o;
PyObject *type = 0, *value = 0, *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
o = wrapper(a, NULL);
if (!o) {
PyObject *deallocname = PyString_FromString(wrappername);
PyErr_WriteUnraisable(deallocname);
Py_DECREF(deallocname);
}
PyErr_Restore(type, value, traceback);
Py_XDECREF(o);
}
if (PyType_IS_GC(a->ob_type)) {
PyObject_GC_Del(a);
} else {
PyObject_Del(a);
}
}
#define SWIGPY_INQUIRY_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_inquiry_closure(PyObject *a) { \
return SwigPyBuiltin_inquiry_closure(wrapper, a); \
}
SWIGINTERN int
SwigPyBuiltin_inquiry_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
int result;
pyresult = wrapper(a, NULL);
result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_GETITERFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_getiterfunc_closure(PyObject *a) { \
return SwigPyBuiltin_getiterfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_getiterfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_BINARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_binaryfunc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_binaryfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_binaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
typedef ternaryfunc ternarycallfunc;
#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternaryfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternaryfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternarycallfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternarycallfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternarycallfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
(void) c;
return wrapper(a, b);
}
#define SWIGPY_LENFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_ssize_t \
wrapper##_lenfunc_closure(PyObject *a) { \
return SwigPyBuiltin_lenfunc_closure(wrapper, a); \
}
SWIGINTERN Py_ssize_t
SwigPyBuiltin_lenfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *resultobj;
Py_ssize_t result;
resultobj = wrapper(a, NULL);
result = PyNumber_AsSsize_t(resultobj, NULL);
Py_DECREF(resultobj);
return result;
}
#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizessizeargfunc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) { \
return SwigPyBuiltin_ssizessizeargfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizessizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizessizeobjargproc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
return SwigPyBuiltin_ssizessizeobjargproc_closure(wrapper, a, b, c, d); \
}
SWIGINTERN int
SwigPyBuiltin_ssizessizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(d ? 3 : 2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
if (d) {
Py_INCREF(d);
PyTuple_SET_ITEM(tuple, 2, d);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_DECREF(tuple);
Py_XDECREF(resultobj);
return result;
}
#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_funpack_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_funpack_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *arg, *result;
arg = _PyLong_FromSsize_t(b);
result = wrapper(a, arg);
Py_DECREF(arg);
return result;
}
#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizeobjargproc_closure(PyObject *a, Py_ssize_t b, PyObject *c) { \
return SwigPyBuiltin_ssizeobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_ssizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
PyObject *tuple;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
pyresult = wrapper(a, tuple);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_funpack_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_funpack_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
pyresult = wrapper(a, b);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjargproc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_objobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_objobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(c ? 2 : 1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
if (c) {
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_REPRFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_reprfunc_closure(PyObject *a) { \
return SwigPyBuiltin_reprfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_reprfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_HASHFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_hash_t \
wrapper##_hashfunc_closure(PyObject *a) { \
return SwigPyBuiltin_hashfunc_closure(wrapper, a); \
}
SWIGINTERN Py_hash_t
SwigPyBuiltin_hashfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
Py_hash_t result;
pyresult = wrapper(a, NULL);
if (!pyresult)
return -1;
result = SWIG_PyNumber_AsPyHash(pyresult);
Py_DECREF(pyresult);
return result;
}
#define SWIGPY_ITERNEXTFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_iternextfunc_closure(PyObject *a) { \
return SwigPyBuiltin_iternextfunc_closure(wrapper, a);\
}
SWIGINTERN PyObject *
SwigPyBuiltin_iternextfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
/* End of callback function macros for use in PyTypeObject */
#ifdef __cplusplus
}
#endif
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_CallbackDetails swig_types[0]
#define SWIGTYPE_p_SwigPyObject swig_types[1]
#define SWIGTYPE_p__GPContext swig_types[2]
#define SWIGTYPE_p__GPContextFeedback swig_types[3]
#define SWIGTYPE_p_char swig_types[4]
#define SWIGTYPE_p_f_p_struct__GPContext_float_p_q_const__char_p_void__unsigned_int swig_types[5]
#define SWIGTYPE_p_f_p_struct__GPContext_p_q_const__char_p_void___GPContextFeedback swig_types[6]
#define SWIGTYPE_p_f_p_struct__GPContext_p_q_const__char_p_void__void swig_types[7]
#define SWIGTYPE_p_f_p_struct__GPContext_p_void___GPContextFeedback swig_types[8]
#define SWIGTYPE_p_f_p_struct__GPContext_p_void__void swig_types[9]
#define SWIGTYPE_p_f_p_struct__GPContext_unsigned_int_float_p_void__void swig_types[10]
#define SWIGTYPE_p_f_p_struct__GPContext_unsigned_int_p_void__void swig_types[11]
static swig_type_info *swig_types[13];
static swig_module_info swig_module = {swig_types, 12, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery
/*-----------------------------------------------
@(target):= _context.so
------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_init PyInit__context
#else
# define SWIG_init init_context
#endif
#define SWIG_name "_context"
#define SWIG_as_voidptr(a) (void *)((const void *)(a))
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
#include
#include "gphoto2/gphoto2.h"
PyObject *PyExc_GPhoto2Error = NULL;
typedef void (*RemoveFunc) (GPContext *context, void *func, void *data);
typedef struct CallbackDetails {
GPContext *context;
PyObject *func_1;
PyObject *func_2;
PyObject *func_3;
PyObject *data;
RemoveFunc remove;
} CallbackDetails;
// Function to remove progress callbacks, compatible with RemoveFunc
static void unset_progress_funcs(GPContext *context,
GPContextProgressStartFunc start_func,
void *data) {
gp_context_set_progress_funcs(context, NULL, NULL, NULL, NULL);
};
// Destructor
static int del_CallbackDetails(struct CallbackDetails *this) {
if (this->context && this->remove) {
this->remove(this->context, NULL, NULL);
gp_context_unref(this->context);
}
Py_XDECREF(this->func_1);
Py_XDECREF(this->func_2);
Py_XDECREF(this->func_3);
Py_XDECREF(this->data);
free(this);
return GP_OK;
};
SWIGINTERN void delete_CallbackDetails(struct CallbackDetails *self){
int error = del_CallbackDetails(self);
if (error < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
}
static void wrap_idle_func (GPContext *context, void *data) {
PyGILState_STATE gstate = PyGILState_Ensure();
CallbackDetails *this = data;
PyObject *result = NULL;
PyObject *arglist = NULL;
PyObject *self = NULL;
PyObject *py_context = SWIG_NewPointerObj(
SWIG_as_voidptr(context), SWIGTYPE_p__GPContext, 0);
arglist = Py_BuildValue ("(OO)", py_context, this->data);
if (arglist == NULL) {
PyErr_Print();
goto fail;
}
result = PyObject_CallObject(this->func_1, arglist);
Py_DECREF(arglist);
if (result == NULL) {
PyErr_Print();
goto fail;
}
Py_DECREF(result);
fail:
PyGILState_Release(gstate);
};
static void wrap_error_func (GPContext *context, const char *text, void *data) {
PyGILState_STATE gstate = PyGILState_Ensure();
CallbackDetails *this = data;
PyObject *result = NULL;
PyObject *arglist = NULL;
PyObject *self = NULL;
PyObject *py_context = SWIG_NewPointerObj(
SWIG_as_voidptr(context), SWIGTYPE_p__GPContext, 0);
arglist = Py_BuildValue ("(OyO)", py_context, text, this->data);
if (arglist == NULL) {
PyErr_Print();
goto fail;
}
result = PyObject_CallObject(this->func_1, arglist);
Py_DECREF(arglist);
if (result == NULL) {
PyErr_Print();
goto fail;
}
Py_DECREF(result);
fail:
PyGILState_Release(gstate);
};
static void wrap_status_func (GPContext *context, const char *text, void *data) {
PyGILState_STATE gstate = PyGILState_Ensure();
CallbackDetails *this = data;
PyObject *result = NULL;
PyObject *arglist = NULL;
PyObject *self = NULL;
PyObject *py_context = SWIG_NewPointerObj(
SWIG_as_voidptr(context), SWIGTYPE_p__GPContext, 0);
arglist = Py_BuildValue ("(OyO)", py_context, text, this->data);
if (arglist == NULL) {
PyErr_Print();
goto fail;
}
result = PyObject_CallObject(this->func_1, arglist);
Py_DECREF(arglist);
if (result == NULL) {
PyErr_Print();
goto fail;
}
Py_DECREF(result);
fail:
PyGILState_Release(gstate);
};
static void wrap_message_func (GPContext *context, const char *text, void *data) {
PyGILState_STATE gstate = PyGILState_Ensure();
CallbackDetails *this = data;
PyObject *result = NULL;
PyObject *arglist = NULL;
PyObject *self = NULL;
PyObject *py_context = SWIG_NewPointerObj(
SWIG_as_voidptr(context), SWIGTYPE_p__GPContext, 0);
arglist = Py_BuildValue ("(OyO)", py_context, text, this->data);
if (arglist == NULL) {
PyErr_Print();
goto fail;
}
result = PyObject_CallObject(this->func_1, arglist);
Py_DECREF(arglist);
if (result == NULL) {
PyErr_Print();
goto fail;
}
Py_DECREF(result);
fail:
PyGILState_Release(gstate);
};
static GPContextFeedback wrap_question_func (GPContext *context, const char *text, void *data) {
PyGILState_STATE gstate = PyGILState_Ensure();
CallbackDetails *this = data;
PyObject *result = NULL;
PyObject *arglist = NULL;
PyObject *self = NULL;
GPContextFeedback c_result = GP_CONTEXT_FEEDBACK_OK;
PyObject *py_context = SWIG_NewPointerObj(
SWIG_as_voidptr(context), SWIGTYPE_p__GPContext, 0);
arglist = Py_BuildValue ("(OyO)", py_context, text, this->data);
if (arglist == NULL) {
PyErr_Print();
goto fail;
}
result = PyObject_CallObject(this->func_1, arglist);
Py_DECREF(arglist);
if (result == NULL) {
PyErr_Print();
goto fail;
}
c_result = PyInt_AsLong(result);
Py_DECREF(result);
fail:
PyGILState_Release(gstate);
return c_result;
};
static GPContextFeedback wrap_cancel_func (GPContext *context, void *data) {
PyGILState_STATE gstate = PyGILState_Ensure();
CallbackDetails *this = data;
PyObject *result = NULL;
PyObject *arglist = NULL;
PyObject *self = NULL;
GPContextFeedback c_result = GP_CONTEXT_FEEDBACK_OK;
PyObject *py_context = SWIG_NewPointerObj(
SWIG_as_voidptr(context), SWIGTYPE_p__GPContext, 0);
arglist = Py_BuildValue ("(OO)", py_context, this->data);
if (arglist == NULL) {
PyErr_Print();
goto fail;
}
result = PyObject_CallObject(this->func_1, arglist);
Py_DECREF(arglist);
if (result == NULL) {
PyErr_Print();
goto fail;
}
c_result = PyInt_AsLong(result);
Py_DECREF(result);
fail:
PyGILState_Release(gstate);
return c_result;
};
static int py_progress_start (GPContext *context, float target, const char *text, void *data) {
PyGILState_STATE gstate = PyGILState_Ensure();
CallbackDetails *this = data;
PyObject *result = NULL;
PyObject *arglist = NULL;
PyObject *self = NULL;
int c_result = 0;
PyObject *py_context = SWIG_NewPointerObj(
SWIG_as_voidptr(context), SWIGTYPE_p__GPContext, 0);
arglist = Py_BuildValue ("(OfyO)", py_context, target, text, this->data);
if (arglist == NULL) {
PyErr_Print();
goto fail;
}
result = PyObject_CallObject(this->func_1, arglist);
Py_DECREF(arglist);
if (result == NULL) {
PyErr_Print();
goto fail;
}
c_result = PyInt_AsLong(result);
Py_DECREF(result);
fail:
PyGILState_Release(gstate);
return c_result;
};
static void py_progress_update (GPContext *context, unsigned int id, float current, void *data) {
PyGILState_STATE gstate = PyGILState_Ensure();
CallbackDetails *this = data;
PyObject *result = NULL;
PyObject *arglist = NULL;
PyObject *self = NULL;
PyObject *py_context = SWIG_NewPointerObj(
SWIG_as_voidptr(context), SWIGTYPE_p__GPContext, 0);
arglist = Py_BuildValue ("(OifO)", py_context, id, current, this->data);
if (arglist == NULL) {
PyErr_Print();
goto fail;
}
result = PyObject_CallObject(this->func_2, arglist);
Py_DECREF(arglist);
if (result == NULL) {
PyErr_Print();
goto fail;
}
Py_DECREF(result);
fail:
PyGILState_Release(gstate);
};
static void py_progress_stop (GPContext *context, unsigned int id, void *data) {
PyGILState_STATE gstate = PyGILState_Ensure();
CallbackDetails *this = data;
PyObject *result = NULL;
PyObject *arglist = NULL;
PyObject *self = NULL;
PyObject *py_context = SWIG_NewPointerObj(
SWIG_as_voidptr(context), SWIGTYPE_p__GPContext, 0);
arglist = Py_BuildValue ("(OiO)", py_context, id, this->data);
if (arglist == NULL) {
PyErr_Print();
goto fail;
}
result = PyObject_CallObject(this->func_3, arglist);
Py_DECREF(arglist);
if (result == NULL) {
PyErr_Print();
goto fail;
}
Py_DECREF(result);
fail:
PyGILState_Release(gstate);
};
SWIGINTERN struct _GPContext *new__GPContext(void){
return gp_context_new();
}
SWIGINTERN void delete__GPContext(struct _GPContext *self){
gp_context_unref(self);
}
SWIGINTERN void _GPContext_set_idle_func(struct _GPContext *self,GPContextIdleFunc func,void *data){
gp_context_set_idle_func (self, func, data);
}
SWIGINTERN void _GPContext_set_error_func(struct _GPContext *self,GPContextErrorFunc func,void *data){
gp_context_set_error_func (self, func, data);
}
SWIGINTERN void _GPContext_set_message_func(struct _GPContext *self,GPContextMessageFunc func,void *data){
gp_context_set_message_func (self, func, data);
}
SWIGINTERN void _GPContext_set_question_func(struct _GPContext *self,GPContextQuestionFunc func,void *data){
gp_context_set_question_func (self, func, data);
}
SWIGINTERN void _GPContext_set_cancel_func(struct _GPContext *self,GPContextCancelFunc func,void *data){
gp_context_set_cancel_func (self, func, data);
}
SWIGINTERN void _GPContext_set_progress_funcs(struct _GPContext *self,GPContextProgressStartFunc start_func,GPContextProgressUpdateFunc update_func,GPContextProgressStopFunc stop_func,void *data){
gp_context_set_progress_funcs (self, start_func, update_func, stop_func, data);
}
SWIGINTERN void _GPContext_set_status_func(struct _GPContext *self,GPContextStatusFunc func,void *data){
gp_context_set_status_func (self, func, data);
}
SWIGINTERNINLINE PyObject*
SWIG_From_int (int value)
{
return PyInt_FromLong((long) value);
}
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_delete_CallbackDetails(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct CallbackDetails *arg1 = (struct CallbackDetails *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CallbackDetails takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CallbackDetails, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CallbackDetails" "', argument " "1"" of type '" "struct CallbackDetails *""'");
}
arg1 = (struct CallbackDetails *)(argp1);
delete_CallbackDetails(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CallbackDetails) /* defines _wrap_delete_CallbackDetails_destructor_closure */
SWIGINTERN PyObject *_wrap_unset_progress_funcs(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPContext *arg1 = (GPContext *) 0 ;
GPContextProgressStartFunc arg2 = (GPContextProgressStartFunc) 0 ;
void *arg3 = (void *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "unset_progress_funcs", 3, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unset_progress_funcs" "', argument " "1"" of type '" "GPContext *""'");
}
arg1 = (GPContext *)(argp1);
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_struct__GPContext_float_p_q_const__char_p_void__unsigned_int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "unset_progress_funcs" "', argument " "2"" of type '" "GPContextProgressStartFunc""'");
}
}
res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "unset_progress_funcs" "', argument " "3"" of type '" "void *""'");
}
unset_progress_funcs(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN int _wrap_new_GPContext(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
struct _GPContext *result = 0 ;
(void)self;
if (!SWIG_Python_CheckNoKeywords(kwargs, "new_GPContext")) SWIG_fail;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "new_GPContext takes no arguments");
result = (struct _GPContext *)new__GPContext();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__GPContext, SWIG_BUILTIN_INIT | 0 );
return resultobj == Py_None ? -1 : 0;
fail:
return -1;
}
SWIGINTERN PyObject *_wrap_delete_GPContext(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPContext *arg1 = (struct _GPContext *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_GPContext takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPContext, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GPContext" "', argument " "1"" of type '" "struct _GPContext *""'");
}
arg1 = (struct _GPContext *)(argp1);
delete__GPContext(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPContext_set_idle_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPContext *arg1 = (struct _GPContext *) 0 ;
GPContextIdleFunc arg2 = (GPContextIdleFunc) 0 ;
void *arg3 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "GPContext_set_idle_func", 2, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPContext_set_idle_func" "', argument " "1"" of type '" "struct _GPContext *""'");
}
arg1 = (struct _GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GPContext_set_idle_func" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) gp_context_set_idle_func;
arg2 = (GPContextIdleFunc) wrap_idle_func;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj2);
_global_callbacks->data = obj2;
arg3 = _global_callbacks;
}
_GPContext_set_idle_func(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_GPContext_set_error_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPContext *arg1 = (struct _GPContext *) 0 ;
GPContextErrorFunc arg2 = (GPContextErrorFunc) 0 ;
void *arg3 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "GPContext_set_error_func", 2, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPContext_set_error_func" "', argument " "1"" of type '" "struct _GPContext *""'");
}
arg1 = (struct _GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GPContext_set_error_func" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) gp_context_set_error_func;
arg2 = (GPContextErrorFunc) wrap_error_func;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj2);
_global_callbacks->data = obj2;
arg3 = _global_callbacks;
}
_GPContext_set_error_func(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_GPContext_set_message_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPContext *arg1 = (struct _GPContext *) 0 ;
GPContextMessageFunc arg2 = (GPContextMessageFunc) 0 ;
void *arg3 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "GPContext_set_message_func", 2, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPContext_set_message_func" "', argument " "1"" of type '" "struct _GPContext *""'");
}
arg1 = (struct _GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GPContext_set_message_func" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) gp_context_set_message_func;
arg2 = (GPContextMessageFunc) wrap_message_func;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj2);
_global_callbacks->data = obj2;
arg3 = _global_callbacks;
}
_GPContext_set_message_func(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_GPContext_set_question_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPContext *arg1 = (struct _GPContext *) 0 ;
GPContextQuestionFunc arg2 = (GPContextQuestionFunc) 0 ;
void *arg3 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "GPContext_set_question_func", 2, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPContext_set_question_func" "', argument " "1"" of type '" "struct _GPContext *""'");
}
arg1 = (struct _GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GPContext_set_question_func" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) gp_context_set_question_func;
arg2 = (GPContextQuestionFunc) wrap_question_func;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj2);
_global_callbacks->data = obj2;
arg3 = _global_callbacks;
}
_GPContext_set_question_func(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_GPContext_set_cancel_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPContext *arg1 = (struct _GPContext *) 0 ;
GPContextCancelFunc arg2 = (GPContextCancelFunc) 0 ;
void *arg3 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "GPContext_set_cancel_func", 2, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPContext_set_cancel_func" "', argument " "1"" of type '" "struct _GPContext *""'");
}
arg1 = (struct _GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GPContext_set_cancel_func" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) gp_context_set_cancel_func;
arg2 = (GPContextCancelFunc) wrap_cancel_func;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj2);
_global_callbacks->data = obj2;
arg3 = _global_callbacks;
}
_GPContext_set_cancel_func(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_GPContext_set_progress_funcs(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPContext *arg1 = (struct _GPContext *) 0 ;
GPContextProgressStartFunc arg2 = (GPContextProgressStartFunc) 0 ;
GPContextProgressUpdateFunc arg3 = (GPContextProgressUpdateFunc) 0 ;
GPContextProgressStopFunc arg4 = (GPContextProgressStopFunc) 0 ;
void *arg5 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "GPContext_set_progress_funcs", 4, 4, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPContext_set_progress_funcs" "', argument " "1"" of type '" "struct _GPContext *""'");
}
arg1 = (struct _GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GPContext_set_progress_funcs" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) unset_progress_funcs;
arg2 = (GPContextProgressStartFunc) py_progress_start;
}
{
if (!PyCallable_Check(obj2)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GPContext_set_progress_funcs" "', argument " "3"" of type '" "callable""'");
}
_global_callbacks->func_2 = obj2;
Py_INCREF(_global_callbacks->func_2);
arg3 = (GPContextProgressUpdateFunc) py_progress_update;
}
{
if (!PyCallable_Check(obj3)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GPContext_set_progress_funcs" "', argument " "4"" of type '" "callable""'");
}
_global_callbacks->func_3 = obj3;
Py_INCREF(_global_callbacks->func_3);
arg4 = (GPContextProgressStopFunc) py_progress_stop;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj4);
_global_callbacks->data = obj4;
arg5 = _global_callbacks;
}
_GPContext_set_progress_funcs(arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_GPContext_set_status_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPContext *arg1 = (struct _GPContext *) 0 ;
GPContextStatusFunc arg2 = (GPContextStatusFunc) 0 ;
void *arg3 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "GPContext_set_status_func", 2, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPContext_set_status_func" "', argument " "1"" of type '" "struct _GPContext *""'");
}
arg1 = (struct _GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GPContext_set_status_func" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) gp_context_set_status_func;
arg2 = (GPContextStatusFunc) wrap_status_func;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj2);
_global_callbacks->data = obj2;
arg3 = _global_callbacks;
}
_GPContext_set_status_func(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GPContext) /* defines _wrap_delete_GPContext_destructor_closure */
SWIGINTERN PyObject *_wrap_gp_context_new(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPContext *result = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_context_new", 0, 0)) SWIG_fail;
result = (GPContext *)gp_context_new();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__GPContext, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_context_set_idle_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPContext *arg1 = (GPContext *) 0 ;
GPContextIdleFunc arg2 = (GPContextIdleFunc) 0 ;
void *arg3 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_context_set_idle_func", 3, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_context_set_idle_func" "', argument " "1"" of type '" "GPContext *""'");
}
arg1 = (GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "gp_context_set_idle_func" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) gp_context_set_idle_func;
arg2 = (GPContextIdleFunc) wrap_idle_func;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj2);
_global_callbacks->data = obj2;
arg3 = _global_callbacks;
}
gp_context_set_idle_func(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_context_set_progress_funcs(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPContext *arg1 = (GPContext *) 0 ;
GPContextProgressStartFunc arg2 = (GPContextProgressStartFunc) 0 ;
GPContextProgressUpdateFunc arg3 = (GPContextProgressUpdateFunc) 0 ;
GPContextProgressStopFunc arg4 = (GPContextProgressStopFunc) 0 ;
void *arg5 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_context_set_progress_funcs", 5, 5, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_context_set_progress_funcs" "', argument " "1"" of type '" "GPContext *""'");
}
arg1 = (GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "gp_context_set_progress_funcs" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) unset_progress_funcs;
arg2 = (GPContextProgressStartFunc) py_progress_start;
}
{
if (!PyCallable_Check(obj2)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "gp_context_set_progress_funcs" "', argument " "3"" of type '" "callable""'");
}
_global_callbacks->func_2 = obj2;
Py_INCREF(_global_callbacks->func_2);
arg3 = (GPContextProgressUpdateFunc) py_progress_update;
}
{
if (!PyCallable_Check(obj3)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "gp_context_set_progress_funcs" "', argument " "4"" of type '" "callable""'");
}
_global_callbacks->func_3 = obj3;
Py_INCREF(_global_callbacks->func_3);
arg4 = (GPContextProgressStopFunc) py_progress_stop;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj4);
_global_callbacks->data = obj4;
arg5 = _global_callbacks;
}
gp_context_set_progress_funcs(arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_context_set_error_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPContext *arg1 = (GPContext *) 0 ;
GPContextErrorFunc arg2 = (GPContextErrorFunc) 0 ;
void *arg3 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_context_set_error_func", 3, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_context_set_error_func" "', argument " "1"" of type '" "GPContext *""'");
}
arg1 = (GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "gp_context_set_error_func" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) gp_context_set_error_func;
arg2 = (GPContextErrorFunc) wrap_error_func;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj2);
_global_callbacks->data = obj2;
arg3 = _global_callbacks;
}
gp_context_set_error_func(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_context_set_status_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPContext *arg1 = (GPContext *) 0 ;
GPContextStatusFunc arg2 = (GPContextStatusFunc) 0 ;
void *arg3 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_context_set_status_func", 3, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_context_set_status_func" "', argument " "1"" of type '" "GPContext *""'");
}
arg1 = (GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "gp_context_set_status_func" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) gp_context_set_status_func;
arg2 = (GPContextStatusFunc) wrap_status_func;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj2);
_global_callbacks->data = obj2;
arg3 = _global_callbacks;
}
gp_context_set_status_func(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_context_set_question_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPContext *arg1 = (GPContext *) 0 ;
GPContextQuestionFunc arg2 = (GPContextQuestionFunc) 0 ;
void *arg3 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_context_set_question_func", 3, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_context_set_question_func" "', argument " "1"" of type '" "GPContext *""'");
}
arg1 = (GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "gp_context_set_question_func" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) gp_context_set_question_func;
arg2 = (GPContextQuestionFunc) wrap_question_func;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj2);
_global_callbacks->data = obj2;
arg3 = _global_callbacks;
}
gp_context_set_question_func(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_context_set_cancel_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPContext *arg1 = (GPContext *) 0 ;
GPContextCancelFunc arg2 = (GPContextCancelFunc) 0 ;
void *arg3 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_context_set_cancel_func", 3, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_context_set_cancel_func" "', argument " "1"" of type '" "GPContext *""'");
}
arg1 = (GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "gp_context_set_cancel_func" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) gp_context_set_cancel_func;
arg2 = (GPContextCancelFunc) wrap_cancel_func;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj2);
_global_callbacks->data = obj2;
arg3 = _global_callbacks;
}
gp_context_set_cancel_func(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_context_set_message_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPContext *arg1 = (GPContext *) 0 ;
GPContextMessageFunc arg2 = (GPContextMessageFunc) 0 ;
void *arg3 = (void *) 0 ;
CallbackDetails *_global_callbacks ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
_global_callbacks = malloc(sizeof(CallbackDetails));
if (!_global_callbacks) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callbacks->context = NULL;
_global_callbacks->func_1 = NULL;
_global_callbacks->func_2 = NULL;
_global_callbacks->func_3 = NULL;
_global_callbacks->data = NULL;
_global_callbacks->remove = NULL;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_context_set_message_func", 3, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPContext, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_context_set_message_func" "', argument " "1"" of type '" "GPContext *""'");
}
arg1 = (GPContext *)(argp1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "gp_context_set_message_func" "', argument " "2"" of type '" "callable""'");
}
Py_INCREF(obj1);
_global_callbacks->func_1 = obj1;
_global_callbacks->remove = (RemoveFunc) gp_context_set_message_func;
arg2 = (GPContextMessageFunc) wrap_message_func;
}
{
gp_context_ref(arg1);
_global_callbacks->context = arg1;
Py_INCREF(obj2);
_global_callbacks->data = obj2;
arg3 = _global_callbacks;
}
gp_context_set_message_func(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callbacks, SWIGTYPE_p_CallbackDetails, SWIG_POINTER_OWN));
_global_callbacks = NULL;
}
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return resultobj;
fail:
{
if (_global_callbacks)
del_CallbackDetails(_global_callbacks);
}
return NULL;
}
static PyMethodDef SwigMethods[] = {
{ "unset_progress_funcs", _wrap_unset_progress_funcs, METH_VARARGS, "\n"
"unset_progress_funcs(context, start_func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.GPContext\n"
"start_func: GPContextProgressStartFunc\n"
"data: void *\n"
"\n"
""},
{ "gp_context_new", _wrap_gp_context_new, METH_VARARGS, "\n"
"gp_context_new() -> GPContext\n"
"Creates a new context. \n"
"\n"
"To be used by the frontend. \n"
"\n"
"Returns\n"
"-------\n"
"a GPContext.\n"
"\n"
"See also gphoto2.Context\n"
""},
{ "gp_context_set_idle_func", _wrap_gp_context_set_idle_func, METH_VARARGS, "\n"
"gp_context_set_idle_func(context, func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.GPContext\n"
"func: callable function\n"
"data: object\n"
"\n"
""},
{ "gp_context_set_progress_funcs", _wrap_gp_context_set_progress_funcs, METH_VARARGS, "\n"
"gp_context_set_progress_funcs(context, start_func, update_func, stop_func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.GPContext\n"
"start_func: callable function\n"
"update_func: callable function\n"
"stop_func: callable function\n"
"data: object\n"
"\n"
""},
{ "gp_context_set_error_func", _wrap_gp_context_set_error_func, METH_VARARGS, "\n"
"gp_context_set_error_func(context, func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.GPContext\n"
"func: callable function\n"
"data: object\n"
"\n"
""},
{ "gp_context_set_status_func", _wrap_gp_context_set_status_func, METH_VARARGS, "\n"
"gp_context_set_status_func(context, func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.GPContext\n"
"func: callable function\n"
"data: object\n"
"\n"
""},
{ "gp_context_set_question_func", _wrap_gp_context_set_question_func, METH_VARARGS, "\n"
"gp_context_set_question_func(context, func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.GPContext\n"
"func: callable function\n"
"data: object\n"
"\n"
""},
{ "gp_context_set_cancel_func", _wrap_gp_context_set_cancel_func, METH_VARARGS, "\n"
"gp_context_set_cancel_func(context, func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.GPContext\n"
"func: callable function\n"
"data: object\n"
"\n"
""},
{ "gp_context_set_message_func", _wrap_gp_context_set_message_func, METH_VARARGS, "\n"
"gp_context_set_message_func(context, func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"context: gphoto2.GPContext\n"
"func: callable function\n"
"data: object\n"
"\n"
""},
{ NULL, NULL, 0, NULL }
};
static SwigPyGetSet CallbackDetails___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CallbackDetails_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"~CallbackDetails", &CallbackDetails___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin__CallbackDetails_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin__CallbackDetails_methods[] = {
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin__CallbackDetails_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.context.CallbackDetails", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CallbackDetails_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin__CallbackDetails_type.as_number, /* tp_as_number */
&SwigPyBuiltin__CallbackDetails_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin__CallbackDetails_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin__CallbackDetails_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"::CallbackDetails", /* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin__CallbackDetails_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin__CallbackDetails_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin__CallbackDetails_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
SwigPyBuiltin_BadInit, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin__CallbackDetails_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CallbackDetails_type};
static SwigPyGetSet GPContext___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin___GPContext_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"unset_progress_funcs", &GPContext___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___GPContext_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___GPContext_methods[] = {
{ "set_idle_func", _wrap_GPContext_set_idle_func, METH_VARARGS, "\n"
"set_idle_func(self, func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"func: callable function\n"
"data: object\n"
"\n"
"" },
{ "set_error_func", _wrap_GPContext_set_error_func, METH_VARARGS, "\n"
"set_error_func(self, func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"func: callable function\n"
"data: object\n"
"\n"
"" },
{ "set_message_func", _wrap_GPContext_set_message_func, METH_VARARGS, "\n"
"set_message_func(self, func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"func: callable function\n"
"data: object\n"
"\n"
"" },
{ "set_question_func", _wrap_GPContext_set_question_func, METH_VARARGS, "\n"
"set_question_func(self, func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"func: callable function\n"
"data: object\n"
"\n"
"" },
{ "set_cancel_func", _wrap_GPContext_set_cancel_func, METH_VARARGS, "\n"
"set_cancel_func(self, func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"func: callable function\n"
"data: object\n"
"\n"
"" },
{ "set_progress_funcs", _wrap_GPContext_set_progress_funcs, METH_VARARGS, "\n"
"set_progress_funcs(self, start_func, update_func, stop_func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"start_func: callable function\n"
"update_func: callable function\n"
"stop_func: callable function\n"
"data: object\n"
"\n"
"" },
{ "set_status_func", _wrap_GPContext_set_status_func, METH_VARARGS, "\n"
"set_status_func(self, func, data)\n"
"\n"
"Parameters\n"
"----------\n"
"func: callable function\n"
"data: object\n"
"\n"
"" },
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___GPContext_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.context.GPContext", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_GPContext_destructor_closure,/* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___GPContext_type.as_number,/* tp_as_number */
&SwigPyBuiltin___GPContext_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___GPContext_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___GPContext_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"::_GPContext", /* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___GPContext_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___GPContext_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___GPContext_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
_wrap_new_GPContext, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___GPContext_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___GPContext_type};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_CallbackDetails = {"_p_CallbackDetails", "CallbackDetails *|struct CallbackDetails *", 0, 0, (void*)&SwigPyBuiltin__CallbackDetails_clientdata, 0};
static swig_type_info _swigt__p_SwigPyObject = {"_p_SwigPyObject", "SwigPyObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPContext = {"_p__GPContext", "GPContext *|struct _GPContext *|_GPContext *", 0, 0, (void*)&SwigPyBuiltin___GPContext_clientdata, 0};
static swig_type_info _swigt__p__GPContextFeedback = {"_p__GPContextFeedback", "GPContextFeedback *|enum _GPContextFeedback *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_struct__GPContext_float_p_q_const__char_p_void__unsigned_int = {"_p_f_p_struct__GPContext_float_p_q_const__char_p_void__unsigned_int", "GPContextProgressStartFunc|unsigned int (*)(struct _GPContext *,float,char const *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_struct__GPContext_p_q_const__char_p_void___GPContextFeedback = {"_p_f_p_struct__GPContext_p_q_const__char_p_void___GPContextFeedback", "GPContextQuestionFunc|enum _GPContextFeedback (*)(struct _GPContext *,char const *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_struct__GPContext_p_q_const__char_p_void__void = {"_p_f_p_struct__GPContext_p_q_const__char_p_void__void", "GPContextErrorFunc|GPContextMessageFunc|GPContextStatusFunc|void (*)(struct _GPContext *,char const *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_struct__GPContext_p_void___GPContextFeedback = {"_p_f_p_struct__GPContext_p_void___GPContextFeedback", "GPContextCancelFunc|enum _GPContextFeedback (*)(struct _GPContext *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_struct__GPContext_p_void__void = {"_p_f_p_struct__GPContext_p_void__void", "GPContextIdleFunc|void (*)(struct _GPContext *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_struct__GPContext_unsigned_int_float_p_void__void = {"_p_f_p_struct__GPContext_unsigned_int_float_p_void__void", "GPContextProgressUpdateFunc|void (*)(struct _GPContext *,unsigned int,float,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_struct__GPContext_unsigned_int_p_void__void = {"_p_f_p_struct__GPContext_unsigned_int_p_void__void", "GPContextProgressStopFunc|void (*)(struct _GPContext *,unsigned int,void *)", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_CallbackDetails,
&_swigt__p_SwigPyObject,
&_swigt__p__GPContext,
&_swigt__p__GPContextFeedback,
&_swigt__p_char,
&_swigt__p_f_p_struct__GPContext_float_p_q_const__char_p_void__unsigned_int,
&_swigt__p_f_p_struct__GPContext_p_q_const__char_p_void___GPContextFeedback,
&_swigt__p_f_p_struct__GPContext_p_q_const__char_p_void__void,
&_swigt__p_f_p_struct__GPContext_p_void___GPContextFeedback,
&_swigt__p_f_p_struct__GPContext_p_void__void,
&_swigt__p_f_p_struct__GPContext_unsigned_int_float_p_void__void,
&_swigt__p_f_p_struct__GPContext_unsigned_int_p_void__void,
};
static swig_cast_info _swigc__p_CallbackDetails[] = { {&_swigt__p_CallbackDetails, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwigPyObject[] = { {&_swigt__p_SwigPyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPContext[] = { {&_swigt__p__GPContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPContextFeedback[] = { {&_swigt__p__GPContextFeedback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_struct__GPContext_float_p_q_const__char_p_void__unsigned_int[] = { {&_swigt__p_f_p_struct__GPContext_float_p_q_const__char_p_void__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_struct__GPContext_p_q_const__char_p_void___GPContextFeedback[] = { {&_swigt__p_f_p_struct__GPContext_p_q_const__char_p_void___GPContextFeedback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_struct__GPContext_p_q_const__char_p_void__void[] = { {&_swigt__p_f_p_struct__GPContext_p_q_const__char_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_struct__GPContext_p_void___GPContextFeedback[] = { {&_swigt__p_f_p_struct__GPContext_p_void___GPContextFeedback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_struct__GPContext_p_void__void[] = { {&_swigt__p_f_p_struct__GPContext_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_struct__GPContext_unsigned_int_float_p_void__void[] = { {&_swigt__p_f_p_struct__GPContext_unsigned_int_float_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_struct__GPContext_unsigned_int_p_void__void[] = { {&_swigt__p_f_p_struct__GPContext_unsigned_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_CallbackDetails,
_swigc__p_SwigPyObject,
_swigc__p__GPContext,
_swigc__p__GPContextFeedback,
_swigc__p_char,
_swigc__p_f_p_struct__GPContext_float_p_q_const__char_p_void__unsigned_int,
_swigc__p_f_p_struct__GPContext_p_q_const__char_p_void___GPContextFeedback,
_swigc__p_f_p_struct__GPContext_p_q_const__char_p_void__void,
_swigc__p_f_p_struct__GPContext_p_void___GPContextFeedback,
_swigc__p_f_p_struct__GPContext_p_void__void,
_swigc__p_f_p_struct__GPContext_unsigned_int_float_p_void__void,
_swigc__p_f_p_struct__GPContext_unsigned_int_p_void__void,
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};
#ifdef __cplusplus
}
#endif
static PyTypeObject *builtin_bases[2];
/* -----------------------------------------------------------------------------
* Type initialization:
* This problem is tough by the requirement that no dynamic
* memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
* to swig_type_info structures, we need some lookup code at initialization.
* The idea is that swig generates all the structures that are needed.
* The runtime then collects these partially filled structures.
* The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
* The generated swig_type_info structures are assigned statically to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
* cast linked list. The cast data is initially stored in something like a
* two-dimensional array. Each row corresponds to a type (there are the same
* number of rows as there are in the swig_type_initial array). Each entry in
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
* we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
* First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
* 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
* swig_cast_info to the linked list (because the cast->type) pointer will
* be correct.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif
#if 0
#define SWIGRUNTIME_DEBUG
#endif
#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif
SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
size_t i;
swig_module_info *module_head, *iter;
int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* Initialize the swig_module */
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
init = 1;
} else {
init = 0;
}
/* Try and load any already created modules */
module_head = SWIG_GetModule(clientdata);
if (!module_head) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
iter=module_head;
do {
if (iter==&swig_module) {
/* Our module is already in the list, so there's nothing more to do. */
return;
}
iter=iter->next;
} while (iter!= module_head);
/* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpreters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
if (init == 0) return;
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
if (swig_module.next != &swig_module) {
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
}
if (type) {
/* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
if (swig_module.type_initial[i]->clientdata) {
type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
}
} else {
type = swig_module.type_initial[i];
}
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
if (swig_module.next != &swig_module) {
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
}
if (ret) {
if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
cast->type = ret;
ret = 0;
} else {
/* Check for casting already in the list */
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
if (!ocast) ret = 0;
}
}
if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
if (type->cast) {
type->cast->prev = cast;
cast->next = type->cast;
}
type->cast = cast;
}
cast++;
}
/* Set entry in modules->types array equal to the type */
swig_module.types[i] = type;
}
swig_module.types[i] = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("**** SWIG_InitializeModule: Cast List ******\n");
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
++j;
}
printf("---- Total casts: %d\n",j);
}
printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}
/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types. It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
size_t i;
swig_cast_info *equiv;
static int init_run = 0;
if (init_run) return;
init_run = 1;
for (i = 0; i < swig_module.size; i++) {
if (swig_module.types[i]->clientdata) {
equiv = swig_module.types[i]->cast;
while (equiv) {
if (!equiv->converter) {
if (equiv->type && !equiv->type->clientdata)
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
}
equiv = equiv->next;
}
}
}
}
#ifdef __cplusplus
#if 0
{
/* c-mode */
#endif
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* constants/methods manipulation
* ----------------------------------------------------------------------------- */
/* Install Constants */
SWIGINTERN void
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
PyObject *obj = 0;
size_t i;
for (i = 0; constants[i].type; ++i) {
switch(constants[i].type) {
case SWIG_PY_POINTER:
obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_PY_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
break;
default:
obj = 0;
break;
}
if (obj) {
PyDict_SetItemString(d, constants[i].name, obj);
Py_DECREF(obj);
}
}
}
/* -----------------------------------------------------------------------------
* Patch %callback methods' docstrings to hold the callback ptrs
* -----------------------------------------------------------------------------*/
SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
size_t i;
for (i = 0; methods[i].ml_name; ++i) {
const char *c = methods[i].ml_doc;
if (!c) continue;
c = strstr(c, "swig_ptr: ");
if (c) {
int j;
const swig_const_info *ci = 0;
const char *name = c + 10;
for (j = 0; const_table[j].type; ++j) {
if (strncmp(const_table[j].name, name,
strlen(const_table[j].name)) == 0) {
ci = &(const_table[j]);
break;
}
}
if (ci) {
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
if (ptr) {
size_t shift = (ci->ptype) - types;
swig_type_info *ty = types_initial[shift];
size_t ldoc = (c - methods[i].ml_doc);
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
char *ndoc = (char*)malloc(ldoc + lptr + 10);
if (ndoc) {
char *buff = ndoc;
memcpy(buff, methods[i].ml_doc, ldoc);
buff += ldoc;
memcpy(buff, "swig_ptr: ", 10);
buff += 10;
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
methods[i].ml_doc = ndoc;
}
}
}
}
}
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------*
* Partial Init method
* -----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
PyObject *m, *d, *md, *globals;
#if PY_VERSION_HEX >= 0x03000000
static struct PyModuleDef SWIG_module = {
PyModuleDef_HEAD_INIT,
SWIG_name,
NULL,
-1,
SwigMethods,
NULL,
NULL,
NULL,
NULL
};
#endif
#if defined(SWIGPYTHON_BUILTIN)
static SwigPyClientData SwigPyObject_clientdata = {
0, 0, 0, 0, 0, 0, 0
};
static PyGetSetDef this_getset_def = {
(char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
};
static SwigPyGetSet thisown_getset_closure = {
SwigPyObject_own,
SwigPyObject_own
};
static PyGetSetDef thisown_getset_def = {
(char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
};
PyTypeObject *builtin_pytype;
int builtin_base_count;
swig_type_info *builtin_basetype;
PyObject *tuple;
PyGetSetDescrObject *static_getset;
PyTypeObject *metatype;
PyTypeObject *swigpyobject;
SwigPyClientData *cd;
PyObject *public_interface, *public_symbol;
PyObject *this_descr;
PyObject *thisown_descr;
PyObject *self = 0;
int i;
(void)builtin_pytype;
(void)builtin_base_count;
(void)builtin_basetype;
(void)tuple;
(void)static_getset;
(void)self;
/* Metaclass is used to implement static member variables */
metatype = SwigPyObjectType();
assert(metatype);
#endif
(void)globals;
/* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
SWIG_This();
SWIG_Python_TypeCache();
SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
SwigPyObject_type();
#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
#if PY_VERSION_HEX >= 0x03000000
m = PyModule_Create(&SWIG_module);
#else
m = Py_InitModule(SWIG_name, SwigMethods);
#endif
md = d = PyModule_GetDict(m);
(void)md;
SWIG_InitializeModule(0);
#ifdef SWIGPYTHON_BUILTIN
swigpyobject = SwigPyObject_TypeOnce();
SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
if (!cd) {
SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
SwigPyObject_clientdata.pytype = swigpyobject;
} else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
return NULL;
# else
return;
# endif
}
/* All objects have a 'this' attribute */
this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
(void)this_descr;
/* All objects have a 'thisown' attribute */
thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
(void)thisown_descr;
public_interface = PyList_New(0);
public_symbol = 0;
(void)public_symbol;
PyDict_SetItemString(md, "__all__", public_interface);
Py_DECREF(public_interface);
for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
for (i = 0; swig_const_table[i].name != 0; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
SWIG_InstallConstants(d,swig_const_table);
{
PyObject *module = PyImport_ImportModule("gphoto2");
if (module != NULL) {
PyExc_GPhoto2Error = PyObject_GetAttrString(module, "GPhoto2Error");
Py_DECREF(module);
}
if (PyExc_GPhoto2Error == NULL)
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
/* type '::CallbackDetails' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CallbackDetails_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CallbackDetails'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CallbackDetails", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CallbackDetails");
d = md;
/* type '::_GPContext' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___GPContext_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'GPContext'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "GPContext", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "GPContext");
d = md;
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_CONTEXT_FEEDBACK_OK",SWIG_From_int((int)(GP_CONTEXT_FEEDBACK_OK)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_CONTEXT_FEEDBACK_CANCEL",SWIG_From_int((int)(GP_CONTEXT_FEEDBACK_CANCEL)));
#if PY_VERSION_HEX >= 0x03000000
return m;
#else
return;
#endif
}
python-gphoto2-2.5.1/src/swig-gp2_5_31/file.py 0000664 0000000 0000000 00000000636 14703210004 0020662 0 ustar 00root root 0000000 0000000 # This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
# Pull in all the attributes from the low-level C/C++ module
if __package__ or "." in __name__:
from ._file import *
else:
from _file import *
python-gphoto2-2.5.1/src/swig-gp2_5_31/file_wrap.c 0000664 0000000 0000000 00000654421 14703210004 0021514 0 ustar 00root root 0000000 0000000 /* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (https://www.swig.org).
* Version 4.1.1
*
* Do not make changes to this file unless you know what you are doing - modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
#define SWIG_VERSION 0x040101
#define SWIGPYTHON
#define SWIG_PYTHON_THREADS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_BUILTIN
#define SWIGPYTHON_FASTPROXY
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if defined(__GNUC__)
# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
/* Intel's compiler complains if a variable which was never initialised is
* cast to void, which is a common idiom which we use to indicate that we
* are aware a variable isn't used. So we just silence that warning.
* See: https://github.com/swig/swig/issues/192 for more discussion.
*/
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include
#endif
#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
* See https://github.com/swig/swig/issues/2090 */
# include
#endif
# undef _DEBUG
# include
# define _DEBUG 1
#else
# include
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
creating a static or dynamic library from the SWIG runtime code.
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
But only do this if strictly necessary, ie, if you have problems
with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif
#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif
/* Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
#define SWIG_POINTER_NO_NULL 0x4
#define SWIG_POINTER_CLEAR 0x8
#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
if (SWIG_IsOK(res)) {
// success code
if (SWIG_IsNewObj(res) {
...
delete *ptr;
} else {
...
}
} else {
// fail code
}
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if () {
if () {
*ptr = ;
return SWIG_NEWOBJ;
} else {
*ptr = ;
return SWIG_OLDOBJ;
}
} else {
return SWIG_BADOBJ;
}
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows returning the 'cast rank', for example, if you have this
int food(double)
int fooi(int);
and you call
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
*/
#define SWIG_OK (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ (SWIG_ERROR)
#define SWIG_OLDOBJ (SWIG_OK)
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
# define SWIG_TypeRank unsigned long
# endif
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
# define SWIG_MAXCASTRANK (2)
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
# define SWIG_AddCast(r) (r)
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
#include
#ifdef __cplusplus
extern "C" {
#endif
typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
void *clientdata; /* language specific type data */
int owndata; /* flag if the structure owns the clientdata */
} swig_type_info;
/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
swig_type_info *type; /* pointer to type that is equivalent to this type */
swig_converter_func converter; /* function to cast the void pointers */
struct swig_cast_info *next; /* pointer to next cast in linked list */
struct swig_cast_info *prev; /* pointer to the previous cast */
} swig_cast_info;
/* Structure used to store module information
* Each module generates one structure like this, and the runtime collects
* all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
size_t size; /* Number of types in this module */
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
swig_type_info **type_initial; /* Array of initially generated type structures */
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
void *clientdata; /* Language specific module data */
} swig_module_info;
/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class" == "Class", etc.
Return 0 when the two name types are equivalent, as in
strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
const char *f2, const char *l2) {
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
while ((*f1 == ' ') && (f1 != l1)) ++f1;
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
return (int)((l1 - f1) - (l2 - f2));
}
/*
Check type equivalence in a name list like ||...
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
}
/*
Check type equivalence in a name list like ||...
Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (strcmp(iter->type->name, c) == 0) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (iter->type == from) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
swig_type_info *lastty = ty;
if (!ty || !ty->dcast) return ty;
while (ty && (ty->dcast)) {
ty = (*ty->dcast)(ptr);
if (ty) lastty = ty;
}
return lastty;
}
/*
Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
return ty->name;
}
/*
Return the pretty name associated with this type,
that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
/* The "str" field contains the equivalent pretty names of the
type, separated by vertical-bar characters. Choose the last
name. It should be the most specific; a fully resolved name
but not necessarily with default template parameters expanded. */
if (!type) return NULL;
if (type->str != NULL) {
const char *last_name = type->str;
const char *s;
for (s = type->str; *s; s++)
if (*s == '|') last_name = s+1;
return last_name;
}
else
return type->name;
}
/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
}
cast = cast->next;
}
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
size_t l = 0;
size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
r = i - 1;
} else {
break;
}
} else if (compare > 0) {
l = i + 1;
}
} else {
break; /* should never happen */
}
} while (l <= r);
}
iter = iter->next;
} while (iter != end);
return 0;
}
/*
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
if (ret) {
return ret;
} else {
/* STEP 2: If the type hasn't been found, do a complete search
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
}
iter = iter->next;
} while (iter != end);
}
/* neither found a match */
return 0;
}
/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
const unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
char d = *(c++);
unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
uu = (unsigned char)((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
uu |= (unsigned char)(d - ('a'-10));
else
return (char *) 0;
*u = uu;
}
return c;
}
/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
char *r = buff;
if ((2*sizeof(void *) + 2) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,&ptr,sizeof(void *));
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
strcpy(r,name);
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
*ptr = (void *) 0;
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sizeof(void *));
}
SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
char *r = buff;
size_t lname = (name ? strlen(name) : 0);
if ((2*sz + 2 + lname) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
if (lname) {
strncpy(r,name,lname+1);
} else {
*r = 0;
}
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
memset(ptr,0,sz);
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sz);
}
#ifdef __cplusplus
}
#endif
/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
#endif
#ifndef Py_TYPE
# define Py_TYPE(op) ((op)->ob_type)
#endif
/* SWIG APIs for compatibility of both Python 2 & 3 */
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
# define SWIG_Python_str_FromFormat PyString_FromFormat
#endif
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03030000
return (char *)PyUnicode_AsUTF8(str);
#else
return PyString_AsString(str);
#endif
}
/* Was useful for Python 3.0.x-3.2.x - now provided only for compatibility
* with any uses in user interface files. */
#define SWIG_Python_str_DelForPy3(x)
SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromString(c);
#else
return PyString_FromString(c);
#endif
}
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif
/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif
/* -----------------------------------------------------------------------------
* error manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
PyObject* type = 0;
switch(code) {
case SWIG_MemoryError:
type = PyExc_MemoryError;
break;
case SWIG_IOError:
type = PyExc_IOError;
break;
case SWIG_RuntimeError:
type = PyExc_RuntimeError;
break;
case SWIG_IndexError:
type = PyExc_IndexError;
break;
case SWIG_TypeError:
type = PyExc_TypeError;
break;
case SWIG_DivisionByZero:
type = PyExc_ZeroDivisionError;
break;
case SWIG_OverflowError:
type = PyExc_OverflowError;
break;
case SWIG_SyntaxError:
type = PyExc_SyntaxError;
break;
case SWIG_ValueError:
type = PyExc_ValueError;
break;
case SWIG_SystemError:
type = PyExc_SystemError;
break;
case SWIG_AttributeError:
type = PyExc_AttributeError;
break;
default:
type = PyExc_RuntimeError;
}
return type;
}
SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
if (PyErr_Occurred())
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
PyErr_Clear();
Py_XINCREF(type);
if (tmp)
PyErr_Format(type, "%s %s", tmp, mesg);
else
PyErr_Format(type, "%s", mesg);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
PyErr_SetString(PyExc_RuntimeError, mesg);
}
}
SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
PyObject *error;
if (obj)
return 0;
error = PyErr_Occurred();
return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}
SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
if (SWIG_Python_TypeErrorOccurred(NULL)) {
/* Use existing TypeError to preserve stacktrace and enhance with given message */
PyObject *newvalue;
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
if (newvalue) {
Py_XDECREF(value);
PyErr_Restore(type, newvalue, traceback);
} else {
PyErr_Restore(type, value, traceback);
}
} else {
/* Raise TypeError using given message */
PyErr_SetString(PyExc_TypeError, message);
}
}
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
# undef SWIG_PYTHON_THREADS
# endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
# define SWIG_PYTHON_USE_GIL
# endif
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# if PY_VERSION_HEX < 0x03070000
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
# else
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# endif
# ifdef __cplusplus /* C++ code */
class SWIG_Python_Thread_Block {
bool status;
PyGILState_STATE state;
public:
void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block() { end(); }
};
class SWIG_Python_Thread_Allow {
bool status;
PyThreadState *save;
public:
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow() { end(); }
};
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
# else /* C code */
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
# endif
# else /* Old thread way, not implemented, user must provide it */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
# define SWIG_PYTHON_THREAD_END_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# endif
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
# define SWIG_PYTHON_THREAD_END_ALLOW
# endif
# endif
#else /* No thread support */
# define SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# define SWIG_PYTHON_THREAD_END_BLOCK
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# define SWIG_PYTHON_THREAD_END_ALLOW
#endif
/* -----------------------------------------------------------------------------
* Python API portion that goes into the runtime
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* Constant declarations
* ----------------------------------------------------------------------------- */
/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY 5
/* Constant information structure */
typedef struct swig_const_info {
int type;
const char *name;
long lvalue;
double dvalue;
void *pvalue;
swig_type_info **ptype;
} swig_const_info;
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* pyrun.swg
*
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* type checking.
*
* ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif
#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#endif
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif
#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
#define SWIG_fail goto fail
/* Runtime API implementation */
/* Error manipulation */
SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetObject(errtype, obj);
Py_DECREF(obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetString(errtype, msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
/* Set a constant value */
#if defined(SWIGPYTHON_BUILTIN)
SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
PyObject *s = PyString_InternFromString(key);
PyList_Append(seq, s);
Py_DECREF(s);
}
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
if (public_interface)
SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}
#else
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
}
#endif
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyList_Check(result)) {
PyObject *o2 = result;
result = PyList_New(1);
if (result) {
PyList_SET_ITEM(result, 0, o2);
} else {
Py_DECREF(obj);
return o2;
}
}
PyList_Append(result,obj);
Py_DECREF(obj);
}
return result;
}
/* Unpack the argument tuple */
SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
if (!PyTuple_Check(args)) {
if (min <= 1 && max >= 1) {
Py_ssize_t i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
}
return 2;
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
Py_ssize_t i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
for (; l < max; ++l) {
objs[l] = 0;
}
return i + 1;
}
}
}
SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
int no_kwargs = 1;
if (kwargs) {
assert(PyDict_Check(kwargs));
if (PyDict_Size(kwargs) > 0) {
PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
no_kwargs = 0;
}
}
return no_kwargs;
}
/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
/*
Helper for static pointer initialization for both C and C++ code, for example
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var) var
#else
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Python-specific SWIG API */
#define SWIG_newvarlink() SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
/* -----------------------------------------------------------------------------
* global variable support code.
* ----------------------------------------------------------------------------- */
typedef struct swig_globalvar {
char *name; /* Name of global variable */
PyObject *(*get_attr)(void); /* Return the current value */
int (*set_attr)(PyObject *); /* Set the value */
struct swig_globalvar *next;
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar *vars;
} swig_varlinkobject;
SWIGINTERN PyObject *
swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_InternFromString("");
#else
return PyString_FromString("");
#endif
}
SWIGINTERN PyObject *
swig_varlink_str(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
PyObject *str = PyUnicode_InternFromString("(");
PyObject *tail;
PyObject *joined;
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
tail = PyUnicode_FromString(var->name);
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
if (var->next) {
tail = PyUnicode_InternFromString(", ");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
}
}
tail = PyUnicode_InternFromString(")");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
#else
PyObject *str = PyString_FromString("(");
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
return str;
}
SWIGINTERN void
swig_varlink_dealloc(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
swig_globalvar *var = v->vars;
while (var) {
swig_globalvar *n = var->next;
free(var->name);
free(var);
var = n;
}
}
SWIGINTERN PyObject *
swig_varlink_getattr(PyObject *o, char *n) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
PyObject *res = NULL;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->get_attr)();
break;
}
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN int
swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
int res = 1;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->set_attr)(p);
break;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
static char varlink__doc__[] = "Swig var link object";
static PyTypeObject varlink_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"swigvarlink", /* tp_name */
sizeof(swig_varlinkobject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) swig_varlink_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc) swig_varlink_getattr, /* tp_getattr */
(setattrfunc) swig_varlink_setattr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc) swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
varlink__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
varlink_type = tmp;
type_init = 1;
if (PyType_Ready(&varlink_type) < 0)
return NULL;
}
return &varlink_type;
}
/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
if (result) {
result->vars = 0;
}
return ((PyObject*) result);
}
SWIGINTERN void
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
memcpy(gv->name, name, size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
}
}
v->vars = gv;
}
static PyObject *Swig_Globals_global = NULL;
SWIGINTERN PyObject *
SWIG_globals(void) {
if (Swig_Globals_global == NULL) {
Swig_Globals_global = SWIG_newvarlink();
}
return Swig_Globals_global;
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* Pointer declarations
* ----------------------------------------------------------------------------- */
/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
#ifdef __cplusplus
extern "C" {
#endif
/* The python void return value */
SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)
{
PyObject *none = Py_None;
Py_INCREF(none);
return none;
}
/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
PyTypeObject *pytype;
} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
int fail = data ? data->implicitconv : 0;
if (fail)
PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
return fail;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
/* the newraw method and newargs arguments used to create a new raw instance */
if (PyClass_Check(obj)) {
data->newraw = 0;
Py_INCREF(obj);
data->newargs = obj;
} else {
data->newraw = PyObject_GetAttrString(data->klass, "__new__");
if (data->newraw) {
data->newargs = PyTuple_New(1);
if (data->newargs) {
Py_INCREF(obj);
PyTuple_SET_ITEM(data->newargs, 0, obj);
} else {
Py_DECREF(data->newraw);
Py_DECREF(data->klass);
free(data);
return 0;
}
} else {
Py_INCREF(obj);
data->newargs = obj;
}
}
/* the destroy method, aka as the C++ delete method */
data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
}
if (data->destroy) {
data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
} else {
data->delargs = 0;
}
data->implicitconv = 0;
data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData *data)
{
Py_XDECREF(data->klass);
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
free(data);
}
/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
PyObject *dict;
#endif
} SwigPyObject;
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
if (!sobj->dict)
sobj->dict = PyDict_New();
Py_XINCREF(sobj->dict);
return sobj->dict;
}
#endif
SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
PyObject *val = SwigPyObject_long(v);
if (val) {
PyObject *ofmt;
PyTuple_SET_ITEM(args, 0, val);
ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
res = PyUnicode_Format(ofmt,args);
#else
res = PyString_Format(ofmt,args);
#endif
Py_DECREF(ofmt);
}
}
Py_DECREF(args);
}
return res;
}
SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v);
if (repr && v->next) {
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
PyObject *joined = PyUnicode_Concat(repr, nrep);
Py_DecRef(repr);
Py_DecRef(nrep);
repr = joined;
# else
PyString_ConcatAndDel(&repr,nrep);
# endif
} else {
Py_DecRef(repr);
repr = NULL;
}
}
return repr;
}
/* We need a version taking two PyObject* parameters so it's a valid
* PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
return SwigPyObject_repr((SwigPyObject*)v);
}
SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
PyObject* res;
if( op != Py_EQ && op != Py_NE ) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
return res;
}
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
SwigPyClientData *cd;
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
assert(cd);
assert(cd->pytype);
return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
#endif
SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
PyTypeObject *target_tp = SwigPyObject_type();
if (PyType_IsSubtype(op->ob_type, target_tp))
return 1;
return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
return (Py_TYPE(op) == SwigPyObject_type())
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
static PyObject* Swig_Capsule_global = NULL;
SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
/* PyObject_CallFunction() has the potential to silently drop
the active exception. In cases of unnamed temporary
variable or where we just finished iterating over a generator
StopIteration will be active right now, and this needs to
remain true upon return from SwigPyObject_dealloc. So save
and restore. */
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
if (data->delargs) {
/* we need to create a temporary object to carry the destroy operation */
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
if (tmp) {
res = SWIG_Python_CallFunctor(destroy, tmp);
} else {
res = 0;
}
Py_XDECREF(tmp);
} else {
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
PyObject *mself = PyCFunction_GET_SELF(destroy);
res = ((*meth)(mself, v));
}
if (!res)
PyErr_WriteUnraisable(destroy);
PyErr_Restore(type, value, traceback);
Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
else {
const char *name = SWIG_TypePrettyName(ty);
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
#endif
Py_XDECREF(Swig_Capsule_global);
}
Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
Py_XDECREF(sobj->dict);
#endif
PyObject_DEL(v);
}
SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject* v, PyObject* next)
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (!SwigPyObject_Check(next)) {
PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
((SwigPyObject *)next)->next = sobj->next;
sobj->next = next;
Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
return NULL;
} else {
SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
if (PyObject_IsTrue(val)) {
Py_DECREF(SwigPyObject_acquire(v,args));
} else {
Py_DECREF(SwigPyObject_disown(v,args));
}
}
return obj;
}
}
static PyMethodDef
swigobject_methods[] = {
{"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
{"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
{"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
{"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
{"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
{"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
{0, 0, 0, 0}
};
SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
/* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
#endif
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
(unaryfunc)0, /*nb_negative*/
(unaryfunc)0, /*nb_positive*/
(unaryfunc)0, /*nb_absolute*/
(inquiry)0, /*nb_nonzero*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
0, /*nb_coerce*/
#endif
(unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_long, /*nb_long*/
#else
0, /*nb_reserved*/
#endif
(unaryfunc)0, /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
};
static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyObject", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
(cmpfunc)SwigPyObject_compare, /* tp_compare */
#endif
(reprfunc)SwigPyObject_repr, /* tp_repr */
&SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigobject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
(richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
swigobject_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobject_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpyobject_type) != 0)
return NULL;
}
return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
sobj->own = own;
sobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
sobj->dict = 0;
#endif
if (own == SWIG_POINTER_OWN) {
/* Obtain a reference to the Python capsule wrapping the module information, so that the
* module information is correctly destroyed after all SWIG python objects have been freed
* by the GC (and corresponding destructors invoked) */
Py_XINCREF(Swig_Capsule_global);
}
}
return (PyObject *)sobj;
}
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
void *pack;
swig_type_info *ty;
size_t size;
} SwigPyPacked;
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return SWIG_Python_str_FromFormat("", result, v->ty->name);
} else {
return SWIG_Python_str_FromFormat("", v->ty->name);
}
}
SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}
SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
return ((op)->ob_type == SwigPyPacked_TypeOnce())
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
if (SwigPyPacked_Check(v)) {
SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyPacked", /* tp_name */
sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
0, /* tp_reserved in 3.0.1 */
#else
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
#endif
(reprfunc)SwigPyPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigpacked_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpypacked_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpypacked_type) != 0)
return NULL;
}
return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
memcpy(pack, ptr, size);
sobj->pack = pack;
sobj->ty = ty;
sobj->size = size;
} else {
PyObject_DEL((PyObject *) sobj);
sobj = 0;
}
}
return (PyObject *) sobj;
}
SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (SwigPyPacked_Check(obj)) {
SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
} else {
return 0;
}
}
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
static PyObject *Swig_This_global = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
if (Swig_This_global == NULL)
Swig_This_global = SWIG_Python_str_FromChar("this");
return Swig_This_global;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS
#endif
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
PyObject *obj;
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
#ifdef SWIGPYTHON_BUILTIN
(void)obj;
# ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
pyobj = PyWeakref_GET_OBJECT(pyobj);
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
# endif
return NULL;
#else
obj = 0;
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
}
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
#endif
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
return oldown;
}
}
return 0;
}
/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
int res;
SwigPyObject *sobj;
int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
if (!obj)
return SWIG_ERROR;
if (obj == Py_None && !implicit_conv) {
if (ptr)
*ptr = 0;
return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
}
res = SWIG_ERROR;
sobj = SWIG_Python_GetSwigThis(obj);
if (own)
*own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
swig_type_info *to = sobj->ty;
if (to == ty) {
/* no type cast needed */
if (ptr) *ptr = vptr;
break;
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
sobj = (SwigPyObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
if (own)
*own = *own | SWIG_CAST_NEW_MEMORY;
}
}
break;
}
}
} else {
if (ptr) *ptr = vptr;
break;
}
}
if (sobj) {
if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
res = SWIG_ERROR_RELEASE_NOT_OWNED;
} else {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
if (flags & SWIG_POINTER_CLEAR) {
sobj->ptr = 0;
}
res = SWIG_OK;
}
} else {
if (implicit_conv) {
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
PyObject *impconv;
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
impconv = SWIG_Python_CallFunctor(klass, obj);
data->implicitconv = 0;
if (PyErr_Occurred()) {
PyErr_Clear();
impconv = 0;
}
if (impconv) {
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
if (SWIG_IsOK(res)) {
if (ptr) {
*ptr = vptr;
/* transfer the ownership to 'ptr' */
iobj->own = 0;
res = SWIG_AddCast(res);
res = SWIG_AddNewMask(res);
} else {
res = SWIG_AddCast(res);
}
}
}
Py_DECREF(impconv);
}
}
}
if (!SWIG_IsOK(res) && obj == Py_None) {
if (ptr)
*ptr = 0;
if (PyErr_Occurred())
PyErr_Clear();
res = SWIG_OK;
}
}
}
return res;
}
/* Convert a function ptr value */
SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
if (!PyCFunction_Check(obj)) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
swig_cast_info *tc;
/* here we get the method pointer for callbacks */
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
if (!desc)
return SWIG_ERROR;
tc = SWIG_TypeCheck(desc,ty);
if (tc) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
} else {
return SWIG_ERROR;
}
return SWIG_OK;
}
}
/* Convert a packed pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
/* check type cast? */
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* -----------------------------------------------------------------------------
* Create a new pointer object
* ----------------------------------------------------------------------------- */
/*
Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
inst = PyObject_Call(newraw, data->newargs, NULL);
if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
Py_DECREF(inst);
inst = 0;
}
}
#else
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
}
#endif
}
} else {
#if PY_VERSION_HEX >= 0x03000000
PyObject *empty_args = PyTuple_New(0);
if (empty_args) {
PyObject *empty_kwargs = PyDict_New();
if (empty_kwargs) {
inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
Py_DECREF(empty_kwargs);
if (inst) {
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
} else {
PyType_Modified(Py_TYPE(inst));
}
}
}
Py_DECREF(empty_args);
}
#else
PyObject *dict = PyDict_New();
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
}
#endif
}
return inst;
}
SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
return PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
return -1;
}
}
#endif
return PyObject_SetAttr(inst, SWIG_This(), swig_this);
}
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
return NULL;
} else {
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
} else {
if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
return NULL;
}
return SWIG_Py_Void();
}
}
/* Create a new pointer object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
SwigPyClientData *clientdata;
PyObject * robj;
int own;
if (!ptr)
return SWIG_Py_Void();
clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
if (clientdata && clientdata->pytype) {
SwigPyObject *newobj;
if (flags & SWIG_BUILTIN_TP_INIT) {
newobj = (SwigPyObject*) self;
if (newobj->ptr) {
PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
while (newobj->next)
newobj = (SwigPyObject *) newobj->next;
newobj->next = next_self;
newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
newobj->dict = 0;
#endif
}
} else {
newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
if (newobj) {
newobj->dict = 0;
}
#endif
}
if (newobj) {
newobj->ptr = ptr;
newobj->ty = type;
newobj->own = own;
newobj->next = 0;
return (PyObject*) newobj;
}
return SWIG_Py_Void();
}
assert(!(flags & SWIG_BUILTIN_TP_INIT));
robj = SwigPyObject_New(ptr, type, own);
if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
Py_DECREF(robj);
robj = inst;
}
return robj;
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
* Get type list
* -----------------------------------------------------------------------------*/
#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif
static PyObject *Swig_TypeCache_global = NULL;
/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
if (Swig_TypeCache_global == NULL) {
Swig_TypeCache_global = PyDict_New();
}
return Swig_TypeCache_global;
}
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
}
#else
void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
}
#endif
return (swig_module_info *) type_pointer;
}
static int interpreter_counter = 0; // how many (sub-)interpreters are using swig_module's types
SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
swig_type_info **types = swig_module->types;
size_t i;
if (--interpreter_counter != 0) // another sub-interpreter may still be using the swig_module's types
return;
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
ty->clientdata = 0;
if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
Swig_This_global = NULL;
Py_DECREF(SWIG_globals());
Swig_Globals_global = NULL;
Py_DECREF(SWIG_Python_TypeCache());
Swig_TypeCache_global = NULL;
Swig_Capsule_global = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
/* Add a dummy module object into sys.modules */
PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && module) {
if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
++interpreter_counter;
Swig_Capsule_global = pointer;
} else {
Py_DECREF(pointer);
}
} else {
Py_XDECREF(pointer);
}
}
SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
PyObject *key = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
} else {
swig_module_info *swig_module = SWIG_GetModule(0);
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
obj = PyCapsule_New((void*) descriptor, NULL, NULL);
if (obj) {
PyDict_SetItem(cache, key, obj);
Py_DECREF(obj);
}
}
}
Py_DECREF(key);
return descriptor;
}
/*
For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION 0
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
const char *errmesg = tmp ? tmp : "Invalid error message";
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, errmesg);
} else {
PyErr_Format(type, "%s %s", errmesg, mesg);
}
Py_DECREF(old_str);
}
return 1;
} else {
return 0;
}
}
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
if (PyErr_Occurred()) {
/* add information about failing argument */
char mesg[256];
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
} else {
return 0;
}
}
SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : "";
}
SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
if (obj && SwigPyObject_Check(obj)) {
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
type, otype);
return;
}
} else
#endif
{
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
}
Py_XDECREF(str);
return;
}
}
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
} else {
PyErr_Format(PyExc_TypeError, "unexpected type is received");
}
}
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
}
return result;
}
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
PyTypeObject *tp = obj->ob_type;
PyObject *descr;
PyObject *encoded_name;
descrsetfunc f;
int res = -1;
# ifdef Py_USING_UNICODE
if (PyString_Check(name)) {
name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
if (!name)
return -1;
} else if (!PyUnicode_Check(name))
# else
if (!PyString_Check(name))
# endif
{
PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
return -1;
} else {
Py_INCREF(name);
}
if (!tp->tp_dict) {
if (PyType_Ready(tp) != 0)
goto done;
}
descr = _PyType_Lookup(tp, name);
f = NULL;
if (descr != NULL)
f = descr->ob_type->tp_descr_set;
if (!f) {
if (PyString_Check(name)) {
encoded_name = name;
Py_INCREF(name);
} else {
encoded_name = PyUnicode_AsUTF8String(name);
if (!encoded_name)
goto done;
}
PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
Py_DECREF(encoded_name);
} else {
res = f(descr, obj, value);
}
done:
Py_DECREF(name);
return res;
}
#endif
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN Py_hash_t
SwigPyObject_hash(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
void *ptr = sobj->ptr;
#if PY_VERSION_HEX < 0x03020000
return (Py_hash_t)(Py_ssize_t)ptr;
#else
return (Py_hash_t)ptr;
#endif
}
SWIGINTERN Py_hash_t
SWIG_PyNumber_AsPyHash(PyObject *obj) {
Py_hash_t result = -1;
#if PY_VERSION_HEX < 0x03020000
if (PyInt_Check(obj))
result = PyInt_AsLong(obj);
else if (PyLong_Check(obj))
result = PyLong_AsLong(obj);
#else
if (PyNumber_Check(obj))
result = PyNumber_AsSsize_t(obj, NULL);
#endif
else
PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
return PyErr_Occurred() ? -1 : result;
}
SWIGINTERN int
SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
return -1;
}
SWIGINTERN void
SwigPyBuiltin_BadDealloc(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
if (sobj->own) {
PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", obj->ob_type->tp_name);
}
}
typedef struct {
PyCFunction get;
PyCFunction set;
} SwigPyGetSet;
SWIGINTERN PyObject *
SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
tuple = PyTuple_New(0);
assert(tuple);
result = (*getset->get)(obj, tuple);
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyObject *
SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
result = (*getset->get)(obj, NULL);
return result;
}
SWIGINTERN int
SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(val);
PyTuple_SET_ITEM(tuple, 0, val);
result = (*getset->set)(obj, tuple);
Py_DECREF(tuple);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN int
SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
result = (*getset->set)(obj, val);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN void
SwigPyStaticVar_dealloc(PyDescrObject *descr) {
PyObject_GC_UnTrack(descr);
Py_XDECREF(PyDescr_TYPE(descr));
Py_XDECREF(PyDescr_NAME(descr));
PyObject_GC_Del(descr);
}
SWIGINTERN PyObject *
SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromFormat("", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
return PyString_FromFormat("", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
}
SWIGINTERN int
SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
PyDescrObject *descr;
descr = (PyDescrObject *)self;
Py_VISIT((PyObject*) PyDescr_TYPE(descr));
return 0;
}
SWIGINTERN PyObject *
SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
if (descr->d_getset->get != NULL)
return descr->d_getset->get(obj, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return NULL;
}
SWIGINTERN int
SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
if (descr->d_getset->set != NULL)
return descr->d_getset->set(obj, value, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return -1;
}
SWIGINTERN int
SwigPyObjectType_setattro(PyObject *typeobject, PyObject *name, PyObject *value) {
PyObject *attribute;
PyTypeObject *type;
descrsetfunc local_set;
assert(PyType_Check(typeobject));
type = (PyTypeObject *)typeobject;
attribute = _PyType_Lookup(type, name);
if (attribute != NULL) {
/* Implement descriptor functionality, if any */
local_set = attribute->ob_type->tp_descr_set;
if (local_set != NULL)
return local_set(attribute, (PyObject *)type, value);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
} else {
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
}
return -1;
}
SWIGINTERN PyTypeObject*
SwigPyStaticVar_Type(void) {
static PyTypeObject staticvar_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"swig_static_var_getset_descriptor", /* tp_name */
sizeof(PyGetSetDescrObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyStaticVar_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
(reprfunc)SwigPyStaticVar_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
0, /* tp_doc */
SwigPyStaticVar_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc)SwigPyStaticVar_get, /* tp_descr_get */
(descrsetfunc)SwigPyStaticVar_set, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
staticvar_type = tmp;
type_init = 1;
if (PyType_Ready(&staticvar_type) < 0)
return NULL;
}
return &staticvar_type;
}
SWIGINTERN PyTypeObject*
SwigPyObjectType(void) {
static char swigpyobjecttype_doc[] = "Metaclass for SWIG wrapped types";
static PyTypeObject swigpyobjecttype_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"SwigPyObjectType", /* tp_name */
PyType_Type.tp_basicsize, /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
SwigPyObjectType_setattro, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
swigpyobjecttype_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobjecttype_type = tmp;
type_init = 1;
swigpyobjecttype_type.tp_base = &PyType_Type;
if (PyType_Ready(&swigpyobjecttype_type) < 0)
return NULL;
}
return &swigpyobjecttype_type;
}
SWIGINTERN PyGetSetDescrObject *
SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
PyGetSetDescrObject *descr;
descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
assert(descr);
Py_XINCREF(type);
PyDescr_TYPE(descr) = type;
PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
descr->d_getset = getset;
if (PyDescr_NAME(descr) == NULL) {
Py_DECREF(descr);
descr = NULL;
}
return descr;
}
SWIGINTERN void
SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
Py_ssize_t base_count = 0;
PyTypeObject **b;
PyObject *tuple;
Py_ssize_t i;
if (!bases[0]) {
bases[0] = SwigPyObject_type();
bases[1] = NULL;
}
type->tp_base = bases[0];
Py_INCREF((PyObject *)bases[0]);
for (b = bases; *b != NULL; ++b)
++base_count;
tuple = PyTuple_New(base_count);
for (i = 0; i < base_count; ++i) {
Py_INCREF((PyObject *)bases[i]);
PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
}
type->tp_bases = tuple;
}
SWIGINTERN PyObject *
SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
PyObject *result;
result = (PyObject *)SWIG_Python_GetSwigThis(self);
Py_XINCREF(result);
return result;
}
SWIGINTERN void
SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
{
#if PY_VERSION_HEX >= 0x030900a4
Py_SET_TYPE(type, metatype);
#else
Py_TYPE(type) = metatype;
#endif
}
/* Start of callback function macros for use in PyTypeObject */
typedef PyObject *(*SwigPyWrapperFunction)(PyObject *, PyObject *);
#define SWIGPY_UNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_unaryfunc_closure(PyObject *a) { \
return SwigPyBuiltin_unaryfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_unaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper) \
SWIGINTERN void \
wrapper##_destructor_closure(PyObject *a) { \
SwigPyBuiltin_destructor_closure(wrapper, #wrapper, a); \
}
SWIGINTERN void
SwigPyBuiltin_destructor_closure(SwigPyWrapperFunction wrapper, const char *wrappername, PyObject *a) {
SwigPyObject *sobj;
sobj = (SwigPyObject *)a;
Py_XDECREF(sobj->dict);
if (sobj->own) {
PyObject *o;
PyObject *type = 0, *value = 0, *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
o = wrapper(a, NULL);
if (!o) {
PyObject *deallocname = PyString_FromString(wrappername);
PyErr_WriteUnraisable(deallocname);
Py_DECREF(deallocname);
}
PyErr_Restore(type, value, traceback);
Py_XDECREF(o);
}
if (PyType_IS_GC(a->ob_type)) {
PyObject_GC_Del(a);
} else {
PyObject_Del(a);
}
}
#define SWIGPY_INQUIRY_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_inquiry_closure(PyObject *a) { \
return SwigPyBuiltin_inquiry_closure(wrapper, a); \
}
SWIGINTERN int
SwigPyBuiltin_inquiry_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
int result;
pyresult = wrapper(a, NULL);
result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_GETITERFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_getiterfunc_closure(PyObject *a) { \
return SwigPyBuiltin_getiterfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_getiterfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_BINARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_binaryfunc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_binaryfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_binaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
typedef ternaryfunc ternarycallfunc;
#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternaryfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternaryfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternarycallfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternarycallfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternarycallfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
(void) c;
return wrapper(a, b);
}
#define SWIGPY_LENFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_ssize_t \
wrapper##_lenfunc_closure(PyObject *a) { \
return SwigPyBuiltin_lenfunc_closure(wrapper, a); \
}
SWIGINTERN Py_ssize_t
SwigPyBuiltin_lenfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *resultobj;
Py_ssize_t result;
resultobj = wrapper(a, NULL);
result = PyNumber_AsSsize_t(resultobj, NULL);
Py_DECREF(resultobj);
return result;
}
#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizessizeargfunc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) { \
return SwigPyBuiltin_ssizessizeargfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizessizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizessizeobjargproc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
return SwigPyBuiltin_ssizessizeobjargproc_closure(wrapper, a, b, c, d); \
}
SWIGINTERN int
SwigPyBuiltin_ssizessizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(d ? 3 : 2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
if (d) {
Py_INCREF(d);
PyTuple_SET_ITEM(tuple, 2, d);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_DECREF(tuple);
Py_XDECREF(resultobj);
return result;
}
#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_funpack_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_funpack_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *arg, *result;
arg = _PyLong_FromSsize_t(b);
result = wrapper(a, arg);
Py_DECREF(arg);
return result;
}
#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizeobjargproc_closure(PyObject *a, Py_ssize_t b, PyObject *c) { \
return SwigPyBuiltin_ssizeobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_ssizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
PyObject *tuple;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
pyresult = wrapper(a, tuple);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_funpack_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_funpack_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
pyresult = wrapper(a, b);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjargproc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_objobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_objobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(c ? 2 : 1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
if (c) {
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_REPRFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_reprfunc_closure(PyObject *a) { \
return SwigPyBuiltin_reprfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_reprfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_HASHFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_hash_t \
wrapper##_hashfunc_closure(PyObject *a) { \
return SwigPyBuiltin_hashfunc_closure(wrapper, a); \
}
SWIGINTERN Py_hash_t
SwigPyBuiltin_hashfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
Py_hash_t result;
pyresult = wrapper(a, NULL);
if (!pyresult)
return -1;
result = SWIG_PyNumber_AsPyHash(pyresult);
Py_DECREF(pyresult);
return result;
}
#define SWIGPY_ITERNEXTFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_iternextfunc_closure(PyObject *a) { \
return SwigPyBuiltin_iternextfunc_closure(wrapper, a);\
}
SWIGINTERN PyObject *
SwigPyBuiltin_iternextfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
/* End of callback function macros for use in PyTypeObject */
#ifdef __cplusplus
}
#endif
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_CameraFileAccessType swig_types[0]
#define SWIGTYPE_p_CameraFileType swig_types[1]
#define SWIGTYPE_p_SwigPyObject swig_types[2]
#define SWIGTYPE_p__CameraFile swig_types[3]
#define SWIGTYPE_p__CameraFileHandler swig_types[4]
#define SWIGTYPE_p_char swig_types[5]
#define SWIGTYPE_p_long swig_types[6]
#define SWIGTYPE_p_p__CameraFile swig_types[7]
#define SWIGTYPE_p_p_char swig_types[8]
#define SWIGTYPE_p_unsigned_long swig_types[9]
static swig_type_info *swig_types[11];
static swig_module_info swig_module = {swig_types, 10, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery
/*-----------------------------------------------
@(target):= _file.so
------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_init PyInit__file
#else
# define SWIG_init init_file
#endif
#define SWIG_name "_file"
#define SWIG_as_voidptr(a) (void *)((const void *)(a))
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
#include
#include "gphoto2/gphoto2.h"
PyObject *PyExc_GPhoto2Error = NULL;
SWIGINTERN struct _CameraFile *new__CameraFile__SWIG_0(void){
struct _CameraFile *result;
int error = gp_file_new(&result);
if (error < GP_OK)
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
return result;
}
SWIGINTERN void delete__CameraFile(struct _CameraFile *self){
int error = gp_file_unref(self);
if (error < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
}
#include
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
# define LLONG_MAX __LONG_LONG_MAX__
# define LLONG_MIN (-LLONG_MAX - 1LL)
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif
SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
int res = SWIG_TypeError;
if (PyFloat_Check(obj)) {
if (val) *val = PyFloat_AsDouble(obj);
return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
} else if (PyInt_Check(obj)) {
if (val) *val = (double) PyInt_AsLong(obj);
return SWIG_OK;
#endif
} else if (PyLong_Check(obj)) {
double v = PyLong_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
double d = PyFloat_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = d;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
} else {
PyErr_Clear();
}
}
}
#endif
return res;
}
#include
#include
SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
double x = *d;
if ((min <= x && x <= max)) {
double fx = floor(x);
double cx = ceil(x);
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
if ((errno == EDOM) || (errno == ERANGE)) {
errno = 0;
} else {
double summ, reps, diff;
if (rd < x) {
diff = x - rd;
} else if (rd > x) {
diff = rd - x;
} else {
return 1;
}
summ = rd + x;
reps = diff/summ;
if (reps < 8*DBL_EPSILON) {
*d = rd;
return 1;
}
}
}
return 0;
}
SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
} else
#endif
if (PyLong_Check(obj)) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
return SWIG_OverflowError;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
long v = PyInt_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
if (val) *val = (long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
long v;
int res = SWIG_AsVal_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v < INT_MIN || v > INT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = (int)(v);
}
}
return res;
}
SWIGINTERN struct _CameraFile *new__CameraFile__SWIG_1(int fd){
struct _CameraFile *result;
int error = gp_file_new_from_fd(&result, fd);
if (error < GP_OK)
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
return result;
}
SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
static int init = 0;
static swig_type_info* info = 0;
if (!init) {
info = SWIG_TypeQuery("_p_char");
init = 1;
}
return info;
}
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (PyBytes_Check(obj))
#else
if (PyUnicode_Check(obj))
#endif
#else
if (PyString_Check(obj))
#endif
{
char *cstr; Py_ssize_t len;
int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (!alloc && cptr) {
/* We can't allow converting without allocation, since the internal
representation of string in Python 3 is UCS-2/UCS-4 but we require
a UTF-8 representation.
TODO(bhy) More detailed explanation */
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (alloc)
*alloc = SWIG_NEWOBJ;
#endif
if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#else
if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#endif
if (cptr) {
if (alloc) {
if (*alloc == SWIG_NEWOBJ) {
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
*alloc = SWIG_NEWOBJ;
} else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
}
} else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
*cptr = PyBytes_AsString(obj);
#else
assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
*cptr = SWIG_Python_str_AsChar(obj);
if (!*cptr)
ret = SWIG_TypeError;
#endif
}
}
if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
Py_XDECREF(obj);
#endif
return ret;
} else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
if (PyUnicode_Check(obj)) {
char *cstr; Py_ssize_t len;
if (!alloc && cptr) {
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
if (cptr) {
if (alloc) *alloc = SWIG_NEWOBJ;
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
}
if (psize) *psize = len + 1;
Py_XDECREF(obj);
return SWIG_OK;
} else {
Py_XDECREF(obj);
}
}
#endif
#endif
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
if (pchar_descriptor) {
void* vptr = 0;
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
if (cptr) *cptr = (char *) vptr;
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
if (alloc) *alloc = SWIG_OLDOBJ;
return SWIG_OK;
}
}
}
return SWIG_TypeError;
}
SWIGINTERN void _CameraFile_set_name(struct _CameraFile *self,char const *name){
int result = gp_file_set_name (self, name);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraFile_get_name(struct _CameraFile *self,char const **name){
int result = gp_file_get_name (self, name);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraFile_set_mime_type(struct _CameraFile *self,char const *mime_type){
int result = gp_file_set_mime_type (self, mime_type);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraFile_get_mime_type(struct _CameraFile *self,char const **mime_type){
int result = gp_file_get_mime_type (self, mime_type);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraFile_set_mtime(struct _CameraFile *self,time_t mtime){
int result = gp_file_set_mtime (self, mtime);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
#define SWIG_From_long PyInt_FromLong
SWIGINTERN void _CameraFile_get_mtime(struct _CameraFile *self,time_t *mtime){
int result = gp_file_get_mtime (self, mtime);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraFile_detect_mime_type(struct _CameraFile *self){
int result = gp_file_detect_mime_type (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraFile_adjust_name_for_mime_type(struct _CameraFile *self){
int result = gp_file_adjust_name_for_mime_type (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraFile_get_name_by_type(struct _CameraFile *self,char const *basename,CameraFileType type,char **newname){
int result = gp_file_get_name_by_type (self, basename, type, newname);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
{
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
long v = PyInt_AsLong(obj);
if (v >= 0) {
if (val) *val = v;
return SWIG_OK;
} else {
return SWIG_OverflowError;
}
} else
#endif
if (PyLong_Check(obj)) {
unsigned long v = PyLong_AsUnsignedLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
return SWIG_OverflowError;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
unsigned long v = PyLong_AsUnsignedLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
if (val) *val = (unsigned long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
SWIGINTERN void _CameraFile_set_data_and_size(struct _CameraFile *self,char *data,unsigned long size){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_file_set_data_and_size (self, data, size);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraFile_get_data_and_size(struct _CameraFile *self,char const **data,unsigned long *size){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_file_get_data_and_size (self, data, size);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraFile_save(struct _CameraFile *self,char const *filename){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_file_save (self, filename);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraFile_clean(struct _CameraFile *self){
int result = gp_file_clean (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraFile_copy(struct _CameraFile *self,CameraFile *source){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_file_copy (self, source);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraFile_open(struct _CameraFile *self,char const *filename){
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
int result = gp_file_open (self, filename);
SWIG_PYTHON_THREAD_END_ALLOW;
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
if (carray) {
if (size > INT_MAX) {
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
return pchar_descriptor ?
SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
} else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
#else
return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
#endif
#else
return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
#endif
}
} else {
return SWIG_Py_Void();
}
}
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtr(const char *cptr)
{
return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}
SWIGINTERNINLINE PyObject*
SWIG_From_int (int value)
{
return PyInt_FromLong((long) value);
}
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN int _wrap_new_CameraFile__SWIG_0(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
struct _CameraFile *result = 0 ;
(void)self;
if (!SWIG_Python_CheckNoKeywords(kwargs, "new_CameraFile")) SWIG_fail;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "new_CameraFile takes no arguments");
{
result = (struct _CameraFile *)new__CameraFile__SWIG_0();
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraFile, SWIG_BUILTIN_INIT | 0 );
return resultobj == Py_None ? -1 : 0;
fail:
return -1;
}
SWIGINTERN PyObject *_wrap_delete_CameraFile(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CameraFile takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraFile" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
{
delete__CameraFile(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN int _wrap_new_CameraFile__SWIG_1(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj1 = 0 ;
struct _CameraFile *result = 0 ;
(void)self;
if (!SWIG_Python_CheckNoKeywords(kwargs, "new_CameraFile")) SWIG_fail;
if (!PyArg_UnpackTuple(args, "new_CameraFile", 1, 1, &obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj1, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CameraFile" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
{
result = (struct _CameraFile *)new__CameraFile__SWIG_1(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraFile, SWIG_BUILTIN_INIT | 0 );
return resultobj == Py_None ? -1 : 0;
fail:
return -1;
}
SWIGINTERN int _wrap_new_CameraFile(PyObject *self, PyObject *args, PyObject *kwargs) {
Py_ssize_t argc;
PyObject *argv[2] = {
0
};
Py_ssize_t ii;
(void)self;
if (!SWIG_Python_CheckNoKeywords(kwargs, "new_CameraFile")) SWIG_fail;
if (!PyTuple_Check(args)) SWIG_fail;
argc = PyObject_Length(args);
for (ii = 0; (ii < 1) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
{
int retval = _wrap_new_CameraFile__SWIG_0(self, args, NULL);
if (retval == 0 || !SWIG_Python_TypeErrorOccurred(NULL)) return retval;
SWIG_fail;
}
}
if (argc == 1) {
{
int retval = _wrap_new_CameraFile__SWIG_1(self, args, NULL);
if (retval == 0 || !SWIG_Python_TypeErrorOccurred(NULL)) return retval;
SWIG_fail;
}
}
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CameraFile'.\n"
" Possible C/C++ prototypes are:\n"
" _CameraFile::_CameraFile()\n"
" _CameraFile::_CameraFile(int)\n");
return -1;
}
SWIGINTERN PyObject *_wrap_CameraFile_set_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFile_set_name", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_set_name" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraFile_set_name" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
{
_CameraFile_set_name(arg1,(char const *)arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_get_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
char **arg2 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *temp2 ;
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFile_get_name takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_get_name" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
{
_CameraFile_get_name(arg1,(char const **)arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg2 ? PyString_FromString(*arg2) : SWIG_Py_Void());
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_set_mime_type(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFile_set_mime_type", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_set_mime_type" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraFile_set_mime_type" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
{
_CameraFile_set_mime_type(arg1,(char const *)arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_get_mime_type(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
char **arg2 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *temp2 ;
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFile_get_mime_type takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_get_mime_type" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
{
_CameraFile_get_mime_type(arg1,(char const **)arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg2 ? PyString_FromString(*arg2) : SWIG_Py_Void());
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_set_mtime(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
time_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
long val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFile_set_mtime", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_set_mtime" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
ecode2 = SWIG_AsVal_long(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFile_set_mtime" "', argument " "2"" of type '" "time_t""'");
}
arg2 = (time_t)(val2);
{
_CameraFile_set_mtime(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_get_mtime(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
time_t *arg2 = (time_t *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
time_t temp2 ;
int res2 = SWIG_TMPOBJ ;
arg2 = &temp2;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFile_get_mtime takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_get_mtime" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
{
_CameraFile_get_mtime(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (SWIG_IsTmpObj(res2)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
} else {
int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_detect_mime_type(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFile_detect_mime_type takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_detect_mime_type" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
{
_CameraFile_detect_mime_type(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_adjust_name_for_mime_type(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFile_adjust_name_for_mime_type takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_adjust_name_for_mime_type" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
{
_CameraFile_adjust_name_for_mime_type(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_get_name_by_type(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
char *arg2 = (char *) 0 ;
CameraFileType arg3 ;
char **arg4 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
char *temp4 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
{
temp4 = NULL;
arg4 = &temp4;
}
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFile_get_name_by_type", 2, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_get_name_by_type" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraFile_get_name_by_type" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CameraFile_get_name_by_type" "', argument " "3"" of type '" "CameraFileType""'");
}
arg3 = (CameraFileType)(val3);
{
_CameraFile_get_name_by_type(arg1,(char const *)arg2,arg3,arg4);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg4 ? PyString_FromString(*arg4) : SWIG_Py_Void());
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_set_data_and_size(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
char *arg2 = (char *) 0 ;
unsigned long arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFile_set_data_and_size", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_set_data_and_size" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
{
Py_buffer view;
if (PyObject_CheckBuffer(obj1) != 1) {
PyErr_SetString(
PyExc_TypeError,
"in method 'CameraFile_set_data_and_size', argument 2 does not support the buffer interface");
SWIG_fail;
}
if (PyObject_GetBuffer(obj1, &view, PyBUF_SIMPLE) != 0) {
PyErr_SetString(
PyExc_TypeError,
"in method 'CameraFile_set_data_and_size', argument 2 does not export a simple buffer");
SWIG_fail;
}
arg2 = malloc(view.len);
if (!arg2) {
PyErr_SetString(
PyExc_MemoryError, "in method 'CameraFile_set_data_and_size', insufficient memory");
SWIG_fail;
}
memcpy(arg2, view.buf, view.len);
arg3 = view.len;
PyBuffer_Release(&view);
}
{
_CameraFile_set_data_and_size(arg1,arg2,arg3);
if (PyErr_Occurred()) {
free(arg2);
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_get_data_and_size(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
char **arg2 = (char **) 0 ;
unsigned long *arg3 = (unsigned long *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *temp_data2 = NULL ;
unsigned long temp_size2 = 0 ;
arg2 = &temp_data2;
arg3 = &temp_size2;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFile_get_data_and_size takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_get_data_and_size" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
{
_CameraFile_get_data_and_size(arg1,(char const **)arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
resultobj = SWIG_Python_AppendOutput(
resultobj, PyMemoryView_FromMemory(*arg2, *arg3, PyBUF_READ));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_save(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFile_save", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_save" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraFile_save" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
{
_CameraFile_save(arg1,(char const *)arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_clean(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFile_clean takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_clean" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
{
_CameraFile_clean(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_copy(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
CameraFile *arg2 = (CameraFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFile_copy", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_copy" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraFile_copy" "', argument " "2"" of type '" "CameraFile *""'");
}
arg2 = (CameraFile *)(argp2);
{
_CameraFile_copy(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFile_open(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFile *arg1 = (struct _CameraFile *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFile_open", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFile_open" "', argument " "1"" of type '" "struct _CameraFile *""'");
}
arg1 = (struct _CameraFile *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraFile_open" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
{
_CameraFile_open(arg1,(char const *)arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraFile) /* defines _wrap_delete_CameraFile_destructor_closure */
SWIGINTERN PyObject *_wrap_gp_file_new(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile **arg1 = (CameraFile **) 0 ;
CameraFile *temp1 ;
int result;
{
temp1 = NULL;
arg1 = &temp1;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_new", 0, 0)) SWIG_fail;
result = (int)gp_file_new(arg1);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg1, SWIGTYPE_p__CameraFile, SWIG_POINTER_OWN));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_new_from_fd(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile **arg1 = (CameraFile **) 0 ;
int arg2 ;
CameraFile *temp1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
int result;
{
temp1 = NULL;
arg1 = &temp1;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_new_from_fd", 1, 1, &obj0)) SWIG_fail;
ecode2 = SWIG_AsVal_int(obj0, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gp_file_new_from_fd" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
result = (int)gp_file_new_from_fd(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg1, SWIGTYPE_p__CameraFile, SWIG_POINTER_OWN));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_set_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_set_name", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_set_name" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_file_set_name" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
result = (int)gp_file_set_name(arg1,(char const *)arg2);
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_get_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
char **arg2 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *temp2 ;
PyObject * obj0 = 0 ;
int result;
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_get_name", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_get_name" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
result = (int)gp_file_get_name(arg1,(char const **)arg2);
resultobj = SWIG_From_int((int)(result));
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg2 ? PyString_FromString(*arg2) : SWIG_Py_Void());
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_set_mime_type(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_set_mime_type", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_set_mime_type" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_file_set_mime_type" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
result = (int)gp_file_set_mime_type(arg1,(char const *)arg2);
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_get_mime_type(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
char **arg2 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *temp2 ;
PyObject * obj0 = 0 ;
int result;
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_get_mime_type", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_get_mime_type" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
result = (int)gp_file_get_mime_type(arg1,(char const **)arg2);
resultobj = SWIG_From_int((int)(result));
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg2 ? PyString_FromString(*arg2) : SWIG_Py_Void());
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_set_mtime(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
time_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
long val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_set_mtime", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_set_mtime" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
ecode2 = SWIG_AsVal_long(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gp_file_set_mtime" "', argument " "2"" of type '" "time_t""'");
}
arg2 = (time_t)(val2);
result = (int)gp_file_set_mtime(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_get_mtime(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
time_t *arg2 = (time_t *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
time_t temp2 ;
int res2 = SWIG_TMPOBJ ;
PyObject * obj0 = 0 ;
int result;
arg2 = &temp2;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_get_mtime", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_get_mtime" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
result = (int)gp_file_get_mtime(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
if (SWIG_IsTmpObj(res2)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
} else {
int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_detect_mime_type(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_detect_mime_type", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_detect_mime_type" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
result = (int)gp_file_detect_mime_type(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_adjust_name_for_mime_type(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_adjust_name_for_mime_type", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_adjust_name_for_mime_type" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
result = (int)gp_file_adjust_name_for_mime_type(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_get_name_by_type(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
char *arg2 = (char *) 0 ;
CameraFileType arg3 ;
char **arg4 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
char *temp4 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
{
temp4 = NULL;
arg4 = &temp4;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_get_name_by_type", 3, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_get_name_by_type" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_file_get_name_by_type" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gp_file_get_name_by_type" "', argument " "3"" of type '" "CameraFileType""'");
}
arg3 = (CameraFileType)(val3);
result = (int)gp_file_get_name_by_type(arg1,(char const *)arg2,arg3,arg4);
resultobj = SWIG_From_int((int)(result));
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg4 ? PyString_FromString(*arg4) : SWIG_Py_Void());
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_set_data_and_size(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
char *arg2 = (char *) 0 ;
unsigned long arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_set_data_and_size", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_set_data_and_size" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
{
Py_buffer view;
if (PyObject_CheckBuffer(obj1) != 1) {
PyErr_SetString(
PyExc_TypeError,
"in method 'gp_file_set_data_and_size', argument 2 does not support the buffer interface");
SWIG_fail;
}
if (PyObject_GetBuffer(obj1, &view, PyBUF_SIMPLE) != 0) {
PyErr_SetString(
PyExc_TypeError,
"in method 'gp_file_set_data_and_size', argument 2 does not export a simple buffer");
SWIG_fail;
}
arg2 = malloc(view.len);
if (!arg2) {
PyErr_SetString(
PyExc_MemoryError, "in method 'gp_file_set_data_and_size', insufficient memory");
SWIG_fail;
}
memcpy(arg2, view.buf, view.len);
arg3 = view.len;
PyBuffer_Release(&view);
}
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_file_set_data_and_size(arg1,arg2,arg3);
SWIG_PYTHON_THREAD_END_ALLOW;
}
if (result < GP_OK) free(arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_get_data_and_size(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
char **arg2 = (char **) 0 ;
unsigned long *arg3 = (unsigned long *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *temp_data2 = NULL ;
unsigned long temp_size2 = 0 ;
PyObject * obj0 = 0 ;
int result;
arg2 = &temp_data2;
arg3 = &temp_size2;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_get_data_and_size", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_get_data_and_size" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_file_get_data_and_size(arg1,(char const **)arg2,arg3);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
resultobj = SWIG_Python_AppendOutput(
resultobj, PyMemoryView_FromMemory(*arg2, *arg3, PyBUF_READ));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_open(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_open", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_open" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_file_open" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
result = (int)gp_file_open(arg1,(char const *)arg2);
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_save(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_save", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_save" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_file_save" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_file_save(arg1,(char const *)arg2);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_clean(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_clean", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_clean" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
result = (int)gp_file_clean(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_file_copy(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraFile *arg1 = (CameraFile *) 0 ;
CameraFile *arg2 = (CameraFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_file_copy", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_file_copy" "', argument " "1"" of type '" "CameraFile *""'");
}
arg1 = (CameraFile *)(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__CameraFile, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_file_copy" "', argument " "2"" of type '" "CameraFile *""'");
}
arg2 = (CameraFile *)(argp2);
{
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
result = (int)gp_file_copy(arg1,arg2);
SWIG_PYTHON_THREAD_END_ALLOW;
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
static PyMethodDef SwigMethods[] = {
{ "gp_file_new", _wrap_gp_file_new, METH_VARARGS, "\n"
"gp_file_new() -> int\n"
"Create new CameraFile object. \n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a pointer to a CameraFile \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile\n"
""},
{ "gp_file_new_from_fd", _wrap_gp_file_new_from_fd, METH_VARARGS, "\n"
"gp_file_new_from_fd(fd) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"fd: int\n"
"\n"
"Create new CameraFile object from a UNIX filedescriptor. \n"
"\n"
"This function takes ownership of the filedescriptor and will close it\n"
"when closing the CameraFile. \n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a pointer to a CameraFile \n"
"* `fd` : \n"
" a UNIX filedescriptor \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.new_from_fd\n"
""},
{ "gp_file_set_name", _wrap_gp_file_set_name, METH_VARARGS, "\n"
"gp_file_set_name(file, name) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"file: gphoto2.CameraFile\n"
"name: str\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `name` : \n"
" a pointer to a MIME type string \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.set_name\n"
""},
{ "gp_file_get_name", _wrap_gp_file_get_name, METH_VARARGS, "\n"
"gp_file_get_name(file) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"file: gphoto2.CameraFile\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `name` : \n"
" a pointer to a name string \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.get_name\n"
""},
{ "gp_file_set_mime_type", _wrap_gp_file_set_mime_type, METH_VARARGS, "\n"
"gp_file_set_mime_type(file, mime_type) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"file: gphoto2.CameraFile\n"
"mime_type: str\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `mime_type` : \n"
" a MIME type string \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.set_mime_type\n"
""},
{ "gp_file_get_mime_type", _wrap_gp_file_get_mime_type, METH_VARARGS, "\n"
"gp_file_get_mime_type(file) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"file: gphoto2.CameraFile\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `mime_type` : \n"
" a pointer to a MIME type string \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.get_mime_type\n"
""},
{ "gp_file_set_mtime", _wrap_gp_file_set_mtime, METH_VARARGS, "\n"
"gp_file_set_mtime(file, mtime) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"file: gphoto2.CameraFile\n"
"mtime: int\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `mtime` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.set_mtime\n"
""},
{ "gp_file_get_mtime", _wrap_gp_file_get_mtime, METH_VARARGS, "\n"
"gp_file_get_mtime(file) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"file: gphoto2.CameraFile\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `mtime` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.get_mtime\n"
""},
{ "gp_file_detect_mime_type", _wrap_gp_file_detect_mime_type, METH_VARARGS, "\n"
"gp_file_detect_mime_type(file) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"file: gphoto2.CameraFile\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.detect_mime_type\n"
""},
{ "gp_file_adjust_name_for_mime_type", _wrap_gp_file_adjust_name_for_mime_type, METH_VARARGS, "\n"
"gp_file_adjust_name_for_mime_type(file) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"file: gphoto2.CameraFile\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.adjust_name_for_mime_type\n"
""},
{ "gp_file_get_name_by_type", _wrap_gp_file_get_name_by_type, METH_VARARGS, "\n"
"gp_file_get_name_by_type(file, basename, type) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"file: gphoto2.CameraFile\n"
"basename: str\n"
"type: CameraFileType (gphoto2.GP_FILE_TYPE_PREVIEW etc.)\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `basename` : \n"
" the basename of the file \n"
"* `type` : \n"
" the gphoto type of the file \n"
"* `newname` : \n"
" the new name generated \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code. \n"
"\n"
"This function takes the basename and generates a filename out of it\n"
"depending on the gphoto filetype and the mime type in the file. The\n"
"gphoto filetype will be converted to a prefix, like thumb_ or raw_, the\n"
"mimetype will replace the current suffix by a different one (if\n"
"necessary). \n"
"\n"
"This can be used so that saving thumbnails or metadata will not\n"
"overwrite the normal files.\n"
"\n"
"See also gphoto2.CameraFile.get_name_by_type\n"
""},
{ "gp_file_set_data_and_size", _wrap_gp_file_set_data_and_size, METH_VARARGS, "\n"
"gp_file_set_data_and_size(arg1, data) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"arg1: gphoto2.CameraFile\n"
"data: readable buffer (e.g. bytes)\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `data` : \n"
"* `size` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.set_data_and_size\n"
""},
{ "gp_file_get_data_and_size", _wrap_gp_file_get_data_and_size, METH_VARARGS, "\n"
"gp_file_get_data_and_size(arg1) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"arg1: gphoto2.CameraFile\n"
"\n"
"Get a pointer to the data and the file's size. \n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `data` : \n"
"* `size` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code. \n"
"\n"
"Both data and size can be NULL and will then be ignored. \n"
"\n"
"For regular CameraFiles, the pointer to data that is returned is still\n"
"owned by libgphoto2 and its lifetime is the same as the #file. \n"
"\n"
"For filedescriptor or handler based CameraFile types, the returned data\n"
"pointer is owned by the caller and needs to be free()d to avoid memory\n"
"leaks.\n"
"\n"
"See also gphoto2.CameraFile.get_data_and_size\n"
""},
{ "gp_file_open", _wrap_gp_file_open, METH_VARARGS, "\n"
"gp_file_open(file, filename) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"file: gphoto2.CameraFile\n"
"filename: str\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `filename` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.open\n"
""},
{ "gp_file_save", _wrap_gp_file_save, METH_VARARGS, "\n"
"gp_file_save(file, filename) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"file: gphoto2.CameraFile\n"
"filename: str\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `filename` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.save\n"
""},
{ "gp_file_clean", _wrap_gp_file_clean, METH_VARARGS, "\n"
"gp_file_clean(file) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"file: gphoto2.CameraFile\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.clean\n"
""},
{ "gp_file_copy", _wrap_gp_file_copy, METH_VARARGS, "\n"
"gp_file_copy(destination, source) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"destination: gphoto2.CameraFile\n"
"source: gphoto2.CameraFile\n"
"\n"
"Parameters\n"
"----------\n"
"* `destination` : \n"
" a CameraFile \n"
"* `source` : \n"
" a CameraFile \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraFile.copy\n"
""},
{ NULL, NULL, 0, NULL }
};
static SwigPyGetSet CameraFile___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin___CameraFile_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"\n"
"_CameraFile\n"
"CameraFile\n"
"The internals of the CameraFile struct are private.\n"
"", &CameraFile___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___CameraFile_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___CameraFile_methods[] = {
{ "set_name", _wrap_CameraFile_set_name, METH_VARARGS, "\n"
"set_name(self, name)\n"
"\n"
"Parameters\n"
"----------\n"
"name: str\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `name` : \n"
" a pointer to a MIME type string \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_set_name\n"
"" },
{ "get_name", _wrap_CameraFile_get_name, METH_VARARGS, "\n"
"get_name(self)\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `name` : \n"
" a pointer to a name string \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_get_name\n"
"" },
{ "set_mime_type", _wrap_CameraFile_set_mime_type, METH_VARARGS, "\n"
"set_mime_type(self, mime_type)\n"
"\n"
"Parameters\n"
"----------\n"
"mime_type: str\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `mime_type` : \n"
" a MIME type string \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_set_mime_type\n"
"" },
{ "get_mime_type", _wrap_CameraFile_get_mime_type, METH_VARARGS, "\n"
"get_mime_type(self)\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `mime_type` : \n"
" a pointer to a MIME type string \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_get_mime_type\n"
"" },
{ "set_mtime", _wrap_CameraFile_set_mtime, METH_VARARGS, "\n"
"set_mtime(self, mtime)\n"
"\n"
"Parameters\n"
"----------\n"
"mtime: int\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `mtime` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_set_mtime\n"
"" },
{ "get_mtime", _wrap_CameraFile_get_mtime, METH_VARARGS, "\n"
"get_mtime(self)\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `mtime` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_get_mtime\n"
"" },
{ "detect_mime_type", _wrap_CameraFile_detect_mime_type, METH_VARARGS, "\n"
"detect_mime_type(self)\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_detect_mime_type\n"
"" },
{ "adjust_name_for_mime_type", _wrap_CameraFile_adjust_name_for_mime_type, METH_VARARGS, "\n"
"adjust_name_for_mime_type(self)\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_adjust_name_for_mime_type\n"
"" },
{ "get_name_by_type", _wrap_CameraFile_get_name_by_type, METH_VARARGS, "\n"
"get_name_by_type(self, basename, type)\n"
"\n"
"Parameters\n"
"----------\n"
"basename: str\n"
"type: CameraFileType (gphoto2.GP_FILE_TYPE_PREVIEW etc.)\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `basename` : \n"
" the basename of the file \n"
"* `type` : \n"
" the gphoto type of the file \n"
"* `newname` : \n"
" the new name generated \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code. \n"
"\n"
"This function takes the basename and generates a filename out of it\n"
"depending on the gphoto filetype and the mime type in the file. The\n"
"gphoto filetype will be converted to a prefix, like thumb_ or raw_, the\n"
"mimetype will replace the current suffix by a different one (if\n"
"necessary). \n"
"\n"
"This can be used so that saving thumbnails or metadata will not\n"
"overwrite the normal files.\n"
"\n"
"See also gphoto2.gp_file_get_name_by_type\n"
"" },
{ "set_data_and_size", _wrap_CameraFile_set_data_and_size, METH_VARARGS, "\n"
"set_data_and_size(self, data)\n"
"\n"
"Parameters\n"
"----------\n"
"data: readable buffer (e.g. bytes)\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `data` : \n"
"* `size` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_set_data_and_size\n"
"" },
{ "get_data_and_size", _wrap_CameraFile_get_data_and_size, METH_VARARGS, "\n"
"get_data_and_size(self)\n"
"Get a pointer to the data and the file's size. \n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `data` : \n"
"* `size` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code. \n"
"\n"
"Both data and size can be NULL and will then be ignored. \n"
"\n"
"For regular CameraFiles, the pointer to data that is returned is still\n"
"owned by libgphoto2 and its lifetime is the same as the #file. \n"
"\n"
"For filedescriptor or handler based CameraFile types, the returned data\n"
"pointer is owned by the caller and needs to be free()d to avoid memory\n"
"leaks.\n"
"\n"
"See also gphoto2.gp_file_get_data_and_size\n"
"" },
{ "save", _wrap_CameraFile_save, METH_VARARGS, "\n"
"save(self, filename)\n"
"\n"
"Parameters\n"
"----------\n"
"filename: str\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `filename` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_save\n"
"" },
{ "clean", _wrap_CameraFile_clean, METH_VARARGS, "\n"
"clean(self)\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_clean\n"
"" },
{ "copy", _wrap_CameraFile_copy, METH_VARARGS, "\n"
"copy(self, source)\n"
"\n"
"Parameters\n"
"----------\n"
"source: gphoto2.CameraFile\n"
"\n"
"Parameters\n"
"----------\n"
"* `destination` : \n"
" a CameraFile \n"
"* `source` : \n"
" a CameraFile \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_copy\n"
"" },
{ "open", _wrap_CameraFile_open, METH_VARARGS, "\n"
"open(self, filename)\n"
"\n"
"Parameters\n"
"----------\n"
"filename: str\n"
"\n"
"Parameters\n"
"----------\n"
"* `file` : \n"
" a CameraFile \n"
"* `filename` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_file_open\n"
"" },
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___CameraFile_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.file.CameraFile", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CameraFile_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___CameraFile_type.as_number, /* tp_as_number */
&SwigPyBuiltin___CameraFile_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___CameraFile_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___CameraFile_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"The internals of the CameraFile struct are private.", /* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___CameraFile_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___CameraFile_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___CameraFile_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
_wrap_new_CameraFile, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___CameraFile_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___CameraFile_type};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_CameraFileAccessType = {"_p_CameraFileAccessType", "CameraFileAccessType *|enum CameraFileAccessType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFileType = {"_p_CameraFileType", "CameraFileType *|enum CameraFileType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwigPyObject = {"_p_SwigPyObject", "SwigPyObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraFile = {"_p__CameraFile", "CameraFile *|struct _CameraFile *|_CameraFile *", 0, 0, (void*)&SwigPyBuiltin___CameraFile_clientdata, 0};
static swig_type_info _swigt__p__CameraFileHandler = {"_p__CameraFileHandler", "CameraFileHandler *|struct _CameraFileHandler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long = {"_p_long", "time_t *|long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__CameraFile = {"_p_p__CameraFile", "CameraFile **|struct _CameraFile **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_CameraFileAccessType,
&_swigt__p_CameraFileType,
&_swigt__p_SwigPyObject,
&_swigt__p__CameraFile,
&_swigt__p__CameraFileHandler,
&_swigt__p_char,
&_swigt__p_long,
&_swigt__p_p__CameraFile,
&_swigt__p_p_char,
&_swigt__p_unsigned_long,
};
static swig_cast_info _swigc__p_CameraFileAccessType[] = { {&_swigt__p_CameraFileAccessType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFileType[] = { {&_swigt__p_CameraFileType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwigPyObject[] = { {&_swigt__p_SwigPyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFile[] = { {&_swigt__p__CameraFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFileHandler[] = { {&_swigt__p__CameraFileHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__CameraFile[] = { {&_swigt__p_p__CameraFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_CameraFileAccessType,
_swigc__p_CameraFileType,
_swigc__p_SwigPyObject,
_swigc__p__CameraFile,
_swigc__p__CameraFileHandler,
_swigc__p_char,
_swigc__p_long,
_swigc__p_p__CameraFile,
_swigc__p_p_char,
_swigc__p_unsigned_long,
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};
#ifdef __cplusplus
}
#endif
static PyTypeObject *builtin_bases[2];
/* -----------------------------------------------------------------------------
* Type initialization:
* This problem is tough by the requirement that no dynamic
* memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
* to swig_type_info structures, we need some lookup code at initialization.
* The idea is that swig generates all the structures that are needed.
* The runtime then collects these partially filled structures.
* The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
* The generated swig_type_info structures are assigned statically to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
* cast linked list. The cast data is initially stored in something like a
* two-dimensional array. Each row corresponds to a type (there are the same
* number of rows as there are in the swig_type_initial array). Each entry in
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
* we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
* First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
* 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
* swig_cast_info to the linked list (because the cast->type) pointer will
* be correct.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif
#if 0
#define SWIGRUNTIME_DEBUG
#endif
#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif
SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
size_t i;
swig_module_info *module_head, *iter;
int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* Initialize the swig_module */
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
init = 1;
} else {
init = 0;
}
/* Try and load any already created modules */
module_head = SWIG_GetModule(clientdata);
if (!module_head) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
iter=module_head;
do {
if (iter==&swig_module) {
/* Our module is already in the list, so there's nothing more to do. */
return;
}
iter=iter->next;
} while (iter!= module_head);
/* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpreters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
if (init == 0) return;
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
if (swig_module.next != &swig_module) {
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
}
if (type) {
/* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
if (swig_module.type_initial[i]->clientdata) {
type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
}
} else {
type = swig_module.type_initial[i];
}
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
if (swig_module.next != &swig_module) {
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
}
if (ret) {
if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
cast->type = ret;
ret = 0;
} else {
/* Check for casting already in the list */
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
if (!ocast) ret = 0;
}
}
if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
if (type->cast) {
type->cast->prev = cast;
cast->next = type->cast;
}
type->cast = cast;
}
cast++;
}
/* Set entry in modules->types array equal to the type */
swig_module.types[i] = type;
}
swig_module.types[i] = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("**** SWIG_InitializeModule: Cast List ******\n");
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
++j;
}
printf("---- Total casts: %d\n",j);
}
printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}
/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types. It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
size_t i;
swig_cast_info *equiv;
static int init_run = 0;
if (init_run) return;
init_run = 1;
for (i = 0; i < swig_module.size; i++) {
if (swig_module.types[i]->clientdata) {
equiv = swig_module.types[i]->cast;
while (equiv) {
if (!equiv->converter) {
if (equiv->type && !equiv->type->clientdata)
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
}
equiv = equiv->next;
}
}
}
}
#ifdef __cplusplus
#if 0
{
/* c-mode */
#endif
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* constants/methods manipulation
* ----------------------------------------------------------------------------- */
/* Install Constants */
SWIGINTERN void
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
PyObject *obj = 0;
size_t i;
for (i = 0; constants[i].type; ++i) {
switch(constants[i].type) {
case SWIG_PY_POINTER:
obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_PY_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
break;
default:
obj = 0;
break;
}
if (obj) {
PyDict_SetItemString(d, constants[i].name, obj);
Py_DECREF(obj);
}
}
}
/* -----------------------------------------------------------------------------
* Patch %callback methods' docstrings to hold the callback ptrs
* -----------------------------------------------------------------------------*/
SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
size_t i;
for (i = 0; methods[i].ml_name; ++i) {
const char *c = methods[i].ml_doc;
if (!c) continue;
c = strstr(c, "swig_ptr: ");
if (c) {
int j;
const swig_const_info *ci = 0;
const char *name = c + 10;
for (j = 0; const_table[j].type; ++j) {
if (strncmp(const_table[j].name, name,
strlen(const_table[j].name)) == 0) {
ci = &(const_table[j]);
break;
}
}
if (ci) {
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
if (ptr) {
size_t shift = (ci->ptype) - types;
swig_type_info *ty = types_initial[shift];
size_t ldoc = (c - methods[i].ml_doc);
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
char *ndoc = (char*)malloc(ldoc + lptr + 10);
if (ndoc) {
char *buff = ndoc;
memcpy(buff, methods[i].ml_doc, ldoc);
buff += ldoc;
memcpy(buff, "swig_ptr: ", 10);
buff += 10;
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
methods[i].ml_doc = ndoc;
}
}
}
}
}
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------*
* Partial Init method
* -----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
PyObject *m, *d, *md, *globals;
#if PY_VERSION_HEX >= 0x03000000
static struct PyModuleDef SWIG_module = {
PyModuleDef_HEAD_INIT,
SWIG_name,
NULL,
-1,
SwigMethods,
NULL,
NULL,
NULL,
NULL
};
#endif
#if defined(SWIGPYTHON_BUILTIN)
static SwigPyClientData SwigPyObject_clientdata = {
0, 0, 0, 0, 0, 0, 0
};
static PyGetSetDef this_getset_def = {
(char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
};
static SwigPyGetSet thisown_getset_closure = {
SwigPyObject_own,
SwigPyObject_own
};
static PyGetSetDef thisown_getset_def = {
(char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
};
PyTypeObject *builtin_pytype;
int builtin_base_count;
swig_type_info *builtin_basetype;
PyObject *tuple;
PyGetSetDescrObject *static_getset;
PyTypeObject *metatype;
PyTypeObject *swigpyobject;
SwigPyClientData *cd;
PyObject *public_interface, *public_symbol;
PyObject *this_descr;
PyObject *thisown_descr;
PyObject *self = 0;
int i;
(void)builtin_pytype;
(void)builtin_base_count;
(void)builtin_basetype;
(void)tuple;
(void)static_getset;
(void)self;
/* Metaclass is used to implement static member variables */
metatype = SwigPyObjectType();
assert(metatype);
#endif
(void)globals;
/* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
SWIG_This();
SWIG_Python_TypeCache();
SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
SwigPyObject_type();
#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
#if PY_VERSION_HEX >= 0x03000000
m = PyModule_Create(&SWIG_module);
#else
m = Py_InitModule(SWIG_name, SwigMethods);
#endif
md = d = PyModule_GetDict(m);
(void)md;
SWIG_InitializeModule(0);
#ifdef SWIGPYTHON_BUILTIN
swigpyobject = SwigPyObject_TypeOnce();
SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
if (!cd) {
SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
SwigPyObject_clientdata.pytype = swigpyobject;
} else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
return NULL;
# else
return;
# endif
}
/* All objects have a 'this' attribute */
this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
(void)this_descr;
/* All objects have a 'thisown' attribute */
thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
(void)thisown_descr;
public_interface = PyList_New(0);
public_symbol = 0;
(void)public_symbol;
PyDict_SetItemString(md, "__all__", public_interface);
Py_DECREF(public_interface);
for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
for (i = 0; swig_const_table[i].name != 0; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
SWIG_InstallConstants(d,swig_const_table);
{
PyObject *module = PyImport_ImportModule("gphoto2");
if (module != NULL) {
PyExc_GPhoto2Error = PyObject_GetAttrString(module, "GPhoto2Error");
Py_DECREF(module);
}
if (PyExc_GPhoto2Error == NULL)
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
/* type '::_CameraFile' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___CameraFile_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraFile'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CameraFile", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraFile");
d = md;
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_TXT",SWIG_FromCharPtr("text/plain"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_WAV",SWIG_FromCharPtr("audio/wav"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_RAW",SWIG_FromCharPtr("image/x-raw"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_PNG",SWIG_FromCharPtr("image/png"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_PGM",SWIG_FromCharPtr("image/x-portable-graymap"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_PPM",SWIG_FromCharPtr("image/x-portable-pixmap"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_PNM",SWIG_FromCharPtr("image/x-portable-anymap"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_JPEG",SWIG_FromCharPtr("image/jpeg"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_TIFF",SWIG_FromCharPtr("image/tiff"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_BMP",SWIG_FromCharPtr("image/bmp"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_QUICKTIME",SWIG_FromCharPtr("video/quicktime"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_AVI",SWIG_FromCharPtr("video/x-msvideo"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_CRW",SWIG_FromCharPtr("image/x-canon-raw"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_CR2",SWIG_FromCharPtr("image/x-canon-cr2"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_CR3",SWIG_FromCharPtr("image/x-canon-cr3"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_NEF",SWIG_FromCharPtr("image/x-nikon-nef"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_UNKNOWN",SWIG_FromCharPtr("application/octet-stream"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_EXIF",SWIG_FromCharPtr("application/x-exif"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_MP3",SWIG_FromCharPtr("audio/mpeg"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_OGG",SWIG_FromCharPtr("application/ogg"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_WMA",SWIG_FromCharPtr("audio/x-wma"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_ASF",SWIG_FromCharPtr("audio/x-asf"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_MPEG",SWIG_FromCharPtr("video/mpeg"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_AVCHD",SWIG_FromCharPtr("video/mp2t"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_RW2",SWIG_FromCharPtr("image/x-panasonic-raw2"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_MIME_ARW",SWIG_FromCharPtr("image/x-sony-arw"));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_TYPE_PREVIEW",SWIG_From_int((int)(GP_FILE_TYPE_PREVIEW)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_TYPE_NORMAL",SWIG_From_int((int)(GP_FILE_TYPE_NORMAL)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_TYPE_RAW",SWIG_From_int((int)(GP_FILE_TYPE_RAW)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_TYPE_AUDIO",SWIG_From_int((int)(GP_FILE_TYPE_AUDIO)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_TYPE_EXIF",SWIG_From_int((int)(GP_FILE_TYPE_EXIF)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_TYPE_METADATA",SWIG_From_int((int)(GP_FILE_TYPE_METADATA)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_ACCESSTYPE_MEMORY",SWIG_From_int((int)(GP_FILE_ACCESSTYPE_MEMORY)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_ACCESSTYPE_FD",SWIG_From_int((int)(GP_FILE_ACCESSTYPE_FD)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_ACCESSTYPE_HANDLER",SWIG_From_int((int)(GP_FILE_ACCESSTYPE_HANDLER)));
/* Initialize threading */
SWIG_PYTHON_INITIALIZE_THREADS;
#if PY_VERSION_HEX >= 0x03000000
return m;
#else
return;
#endif
}
python-gphoto2-2.5.1/src/swig-gp2_5_31/filesys.py 0000664 0000000 0000000 00000000671 14703210004 0021420 0 ustar 00root root 0000000 0000000 # This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
import gphoto2.file
# Pull in all the attributes from the low-level C/C++ module
if __package__ or "." in __name__:
from ._filesys import *
else:
from _filesys import *
python-gphoto2-2.5.1/src/swig-gp2_5_31/filesys_wrap.c 0000664 0000000 0000000 00001042337 14703210004 0022251 0 ustar 00root root 0000000 0000000 /* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (https://www.swig.org).
* Version 4.1.1
*
* Do not make changes to this file unless you know what you are doing - modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
#define SWIG_VERSION 0x040101
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_BUILTIN
#define SWIGPYTHON_FASTPROXY
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if defined(__GNUC__)
# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
/* Intel's compiler complains if a variable which was never initialised is
* cast to void, which is a common idiom which we use to indicate that we
* are aware a variable isn't used. So we just silence that warning.
* See: https://github.com/swig/swig/issues/192 for more discussion.
*/
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include
#endif
#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
* See https://github.com/swig/swig/issues/2090 */
# include
#endif
# undef _DEBUG
# include
# define _DEBUG 1
#else
# include
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
creating a static or dynamic library from the SWIG runtime code.
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
But only do this if strictly necessary, ie, if you have problems
with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif
#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif
/* Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
#define SWIG_POINTER_NO_NULL 0x4
#define SWIG_POINTER_CLEAR 0x8
#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
if (SWIG_IsOK(res)) {
// success code
if (SWIG_IsNewObj(res) {
...
delete *ptr;
} else {
...
}
} else {
// fail code
}
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if () {
if () {
*ptr = ;
return SWIG_NEWOBJ;
} else {
*ptr = ;
return SWIG_OLDOBJ;
}
} else {
return SWIG_BADOBJ;
}
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows returning the 'cast rank', for example, if you have this
int food(double)
int fooi(int);
and you call
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
*/
#define SWIG_OK (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ (SWIG_ERROR)
#define SWIG_OLDOBJ (SWIG_OK)
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
# define SWIG_TypeRank unsigned long
# endif
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
# define SWIG_MAXCASTRANK (2)
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
# define SWIG_AddCast(r) (r)
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
#include
#ifdef __cplusplus
extern "C" {
#endif
typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
void *clientdata; /* language specific type data */
int owndata; /* flag if the structure owns the clientdata */
} swig_type_info;
/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
swig_type_info *type; /* pointer to type that is equivalent to this type */
swig_converter_func converter; /* function to cast the void pointers */
struct swig_cast_info *next; /* pointer to next cast in linked list */
struct swig_cast_info *prev; /* pointer to the previous cast */
} swig_cast_info;
/* Structure used to store module information
* Each module generates one structure like this, and the runtime collects
* all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
size_t size; /* Number of types in this module */
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
swig_type_info **type_initial; /* Array of initially generated type structures */
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
void *clientdata; /* Language specific module data */
} swig_module_info;
/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class" == "Class", etc.
Return 0 when the two name types are equivalent, as in
strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
const char *f2, const char *l2) {
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
while ((*f1 == ' ') && (f1 != l1)) ++f1;
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
return (int)((l1 - f1) - (l2 - f2));
}
/*
Check type equivalence in a name list like ||...
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
}
/*
Check type equivalence in a name list like ||...
Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (strcmp(iter->type->name, c) == 0) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (iter->type == from) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
swig_type_info *lastty = ty;
if (!ty || !ty->dcast) return ty;
while (ty && (ty->dcast)) {
ty = (*ty->dcast)(ptr);
if (ty) lastty = ty;
}
return lastty;
}
/*
Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
return ty->name;
}
/*
Return the pretty name associated with this type,
that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
/* The "str" field contains the equivalent pretty names of the
type, separated by vertical-bar characters. Choose the last
name. It should be the most specific; a fully resolved name
but not necessarily with default template parameters expanded. */
if (!type) return NULL;
if (type->str != NULL) {
const char *last_name = type->str;
const char *s;
for (s = type->str; *s; s++)
if (*s == '|') last_name = s+1;
return last_name;
}
else
return type->name;
}
/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
}
cast = cast->next;
}
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
size_t l = 0;
size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
r = i - 1;
} else {
break;
}
} else if (compare > 0) {
l = i + 1;
}
} else {
break; /* should never happen */
}
} while (l <= r);
}
iter = iter->next;
} while (iter != end);
return 0;
}
/*
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
if (ret) {
return ret;
} else {
/* STEP 2: If the type hasn't been found, do a complete search
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
}
iter = iter->next;
} while (iter != end);
}
/* neither found a match */
return 0;
}
/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
const unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
char d = *(c++);
unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
uu = (unsigned char)((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
uu |= (unsigned char)(d - ('a'-10));
else
return (char *) 0;
*u = uu;
}
return c;
}
/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
char *r = buff;
if ((2*sizeof(void *) + 2) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,&ptr,sizeof(void *));
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
strcpy(r,name);
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
*ptr = (void *) 0;
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sizeof(void *));
}
SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
char *r = buff;
size_t lname = (name ? strlen(name) : 0);
if ((2*sz + 2 + lname) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
if (lname) {
strncpy(r,name,lname+1);
} else {
*r = 0;
}
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
memset(ptr,0,sz);
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sz);
}
#ifdef __cplusplus
}
#endif
/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
#endif
#ifndef Py_TYPE
# define Py_TYPE(op) ((op)->ob_type)
#endif
/* SWIG APIs for compatibility of both Python 2 & 3 */
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
# define SWIG_Python_str_FromFormat PyString_FromFormat
#endif
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03030000
return (char *)PyUnicode_AsUTF8(str);
#else
return PyString_AsString(str);
#endif
}
/* Was useful for Python 3.0.x-3.2.x - now provided only for compatibility
* with any uses in user interface files. */
#define SWIG_Python_str_DelForPy3(x)
SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromString(c);
#else
return PyString_FromString(c);
#endif
}
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif
/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif
/* -----------------------------------------------------------------------------
* error manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
PyObject* type = 0;
switch(code) {
case SWIG_MemoryError:
type = PyExc_MemoryError;
break;
case SWIG_IOError:
type = PyExc_IOError;
break;
case SWIG_RuntimeError:
type = PyExc_RuntimeError;
break;
case SWIG_IndexError:
type = PyExc_IndexError;
break;
case SWIG_TypeError:
type = PyExc_TypeError;
break;
case SWIG_DivisionByZero:
type = PyExc_ZeroDivisionError;
break;
case SWIG_OverflowError:
type = PyExc_OverflowError;
break;
case SWIG_SyntaxError:
type = PyExc_SyntaxError;
break;
case SWIG_ValueError:
type = PyExc_ValueError;
break;
case SWIG_SystemError:
type = PyExc_SystemError;
break;
case SWIG_AttributeError:
type = PyExc_AttributeError;
break;
default:
type = PyExc_RuntimeError;
}
return type;
}
SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
if (PyErr_Occurred())
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
PyErr_Clear();
Py_XINCREF(type);
if (tmp)
PyErr_Format(type, "%s %s", tmp, mesg);
else
PyErr_Format(type, "%s", mesg);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
PyErr_SetString(PyExc_RuntimeError, mesg);
}
}
SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
PyObject *error;
if (obj)
return 0;
error = PyErr_Occurred();
return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}
SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
if (SWIG_Python_TypeErrorOccurred(NULL)) {
/* Use existing TypeError to preserve stacktrace and enhance with given message */
PyObject *newvalue;
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
if (newvalue) {
Py_XDECREF(value);
PyErr_Restore(type, newvalue, traceback);
} else {
PyErr_Restore(type, value, traceback);
}
} else {
/* Raise TypeError using given message */
PyErr_SetString(PyExc_TypeError, message);
}
}
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
# undef SWIG_PYTHON_THREADS
# endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
# define SWIG_PYTHON_USE_GIL
# endif
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# if PY_VERSION_HEX < 0x03070000
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
# else
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# endif
# ifdef __cplusplus /* C++ code */
class SWIG_Python_Thread_Block {
bool status;
PyGILState_STATE state;
public:
void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block() { end(); }
};
class SWIG_Python_Thread_Allow {
bool status;
PyThreadState *save;
public:
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow() { end(); }
};
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
# else /* C code */
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
# endif
# else /* Old thread way, not implemented, user must provide it */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
# define SWIG_PYTHON_THREAD_END_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# endif
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
# define SWIG_PYTHON_THREAD_END_ALLOW
# endif
# endif
#else /* No thread support */
# define SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# define SWIG_PYTHON_THREAD_END_BLOCK
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# define SWIG_PYTHON_THREAD_END_ALLOW
#endif
/* -----------------------------------------------------------------------------
* Python API portion that goes into the runtime
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* Constant declarations
* ----------------------------------------------------------------------------- */
/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY 5
/* Constant information structure */
typedef struct swig_const_info {
int type;
const char *name;
long lvalue;
double dvalue;
void *pvalue;
swig_type_info **ptype;
} swig_const_info;
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* pyrun.swg
*
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* type checking.
*
* ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif
#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#endif
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif
#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
#define SWIG_fail goto fail
/* Runtime API implementation */
/* Error manipulation */
SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetObject(errtype, obj);
Py_DECREF(obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetString(errtype, msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
/* Set a constant value */
#if defined(SWIGPYTHON_BUILTIN)
SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
PyObject *s = PyString_InternFromString(key);
PyList_Append(seq, s);
Py_DECREF(s);
}
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
if (public_interface)
SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}
#else
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
}
#endif
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyList_Check(result)) {
PyObject *o2 = result;
result = PyList_New(1);
if (result) {
PyList_SET_ITEM(result, 0, o2);
} else {
Py_DECREF(obj);
return o2;
}
}
PyList_Append(result,obj);
Py_DECREF(obj);
}
return result;
}
/* Unpack the argument tuple */
SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
if (!PyTuple_Check(args)) {
if (min <= 1 && max >= 1) {
Py_ssize_t i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
}
return 2;
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
Py_ssize_t i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
for (; l < max; ++l) {
objs[l] = 0;
}
return i + 1;
}
}
}
SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
int no_kwargs = 1;
if (kwargs) {
assert(PyDict_Check(kwargs));
if (PyDict_Size(kwargs) > 0) {
PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
no_kwargs = 0;
}
}
return no_kwargs;
}
/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
/*
Helper for static pointer initialization for both C and C++ code, for example
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var) var
#else
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Python-specific SWIG API */
#define SWIG_newvarlink() SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
/* -----------------------------------------------------------------------------
* global variable support code.
* ----------------------------------------------------------------------------- */
typedef struct swig_globalvar {
char *name; /* Name of global variable */
PyObject *(*get_attr)(void); /* Return the current value */
int (*set_attr)(PyObject *); /* Set the value */
struct swig_globalvar *next;
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar *vars;
} swig_varlinkobject;
SWIGINTERN PyObject *
swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_InternFromString("");
#else
return PyString_FromString("");
#endif
}
SWIGINTERN PyObject *
swig_varlink_str(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
PyObject *str = PyUnicode_InternFromString("(");
PyObject *tail;
PyObject *joined;
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
tail = PyUnicode_FromString(var->name);
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
if (var->next) {
tail = PyUnicode_InternFromString(", ");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
}
}
tail = PyUnicode_InternFromString(")");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
#else
PyObject *str = PyString_FromString("(");
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
return str;
}
SWIGINTERN void
swig_varlink_dealloc(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
swig_globalvar *var = v->vars;
while (var) {
swig_globalvar *n = var->next;
free(var->name);
free(var);
var = n;
}
}
SWIGINTERN PyObject *
swig_varlink_getattr(PyObject *o, char *n) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
PyObject *res = NULL;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->get_attr)();
break;
}
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN int
swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
int res = 1;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->set_attr)(p);
break;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
static char varlink__doc__[] = "Swig var link object";
static PyTypeObject varlink_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"swigvarlink", /* tp_name */
sizeof(swig_varlinkobject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) swig_varlink_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc) swig_varlink_getattr, /* tp_getattr */
(setattrfunc) swig_varlink_setattr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc) swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
varlink__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
varlink_type = tmp;
type_init = 1;
if (PyType_Ready(&varlink_type) < 0)
return NULL;
}
return &varlink_type;
}
/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
if (result) {
result->vars = 0;
}
return ((PyObject*) result);
}
SWIGINTERN void
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
memcpy(gv->name, name, size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
}
}
v->vars = gv;
}
static PyObject *Swig_Globals_global = NULL;
SWIGINTERN PyObject *
SWIG_globals(void) {
if (Swig_Globals_global == NULL) {
Swig_Globals_global = SWIG_newvarlink();
}
return Swig_Globals_global;
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* Pointer declarations
* ----------------------------------------------------------------------------- */
/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
#ifdef __cplusplus
extern "C" {
#endif
/* The python void return value */
SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)
{
PyObject *none = Py_None;
Py_INCREF(none);
return none;
}
/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
PyTypeObject *pytype;
} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
int fail = data ? data->implicitconv : 0;
if (fail)
PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
return fail;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
/* the newraw method and newargs arguments used to create a new raw instance */
if (PyClass_Check(obj)) {
data->newraw = 0;
Py_INCREF(obj);
data->newargs = obj;
} else {
data->newraw = PyObject_GetAttrString(data->klass, "__new__");
if (data->newraw) {
data->newargs = PyTuple_New(1);
if (data->newargs) {
Py_INCREF(obj);
PyTuple_SET_ITEM(data->newargs, 0, obj);
} else {
Py_DECREF(data->newraw);
Py_DECREF(data->klass);
free(data);
return 0;
}
} else {
Py_INCREF(obj);
data->newargs = obj;
}
}
/* the destroy method, aka as the C++ delete method */
data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
}
if (data->destroy) {
data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
} else {
data->delargs = 0;
}
data->implicitconv = 0;
data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData *data)
{
Py_XDECREF(data->klass);
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
free(data);
}
/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
PyObject *dict;
#endif
} SwigPyObject;
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
if (!sobj->dict)
sobj->dict = PyDict_New();
Py_XINCREF(sobj->dict);
return sobj->dict;
}
#endif
SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
PyObject *val = SwigPyObject_long(v);
if (val) {
PyObject *ofmt;
PyTuple_SET_ITEM(args, 0, val);
ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
res = PyUnicode_Format(ofmt,args);
#else
res = PyString_Format(ofmt,args);
#endif
Py_DECREF(ofmt);
}
}
Py_DECREF(args);
}
return res;
}
SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v);
if (repr && v->next) {
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
PyObject *joined = PyUnicode_Concat(repr, nrep);
Py_DecRef(repr);
Py_DecRef(nrep);
repr = joined;
# else
PyString_ConcatAndDel(&repr,nrep);
# endif
} else {
Py_DecRef(repr);
repr = NULL;
}
}
return repr;
}
/* We need a version taking two PyObject* parameters so it's a valid
* PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
return SwigPyObject_repr((SwigPyObject*)v);
}
SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
PyObject* res;
if( op != Py_EQ && op != Py_NE ) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
return res;
}
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
SwigPyClientData *cd;
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
assert(cd);
assert(cd->pytype);
return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
#endif
SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
PyTypeObject *target_tp = SwigPyObject_type();
if (PyType_IsSubtype(op->ob_type, target_tp))
return 1;
return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
return (Py_TYPE(op) == SwigPyObject_type())
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
static PyObject* Swig_Capsule_global = NULL;
SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
/* PyObject_CallFunction() has the potential to silently drop
the active exception. In cases of unnamed temporary
variable or where we just finished iterating over a generator
StopIteration will be active right now, and this needs to
remain true upon return from SwigPyObject_dealloc. So save
and restore. */
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
if (data->delargs) {
/* we need to create a temporary object to carry the destroy operation */
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
if (tmp) {
res = SWIG_Python_CallFunctor(destroy, tmp);
} else {
res = 0;
}
Py_XDECREF(tmp);
} else {
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
PyObject *mself = PyCFunction_GET_SELF(destroy);
res = ((*meth)(mself, v));
}
if (!res)
PyErr_WriteUnraisable(destroy);
PyErr_Restore(type, value, traceback);
Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
else {
const char *name = SWIG_TypePrettyName(ty);
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
#endif
Py_XDECREF(Swig_Capsule_global);
}
Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
Py_XDECREF(sobj->dict);
#endif
PyObject_DEL(v);
}
SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject* v, PyObject* next)
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (!SwigPyObject_Check(next)) {
PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
((SwigPyObject *)next)->next = sobj->next;
sobj->next = next;
Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
return NULL;
} else {
SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
if (PyObject_IsTrue(val)) {
Py_DECREF(SwigPyObject_acquire(v,args));
} else {
Py_DECREF(SwigPyObject_disown(v,args));
}
}
return obj;
}
}
static PyMethodDef
swigobject_methods[] = {
{"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
{"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
{"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
{"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
{"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
{"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
{0, 0, 0, 0}
};
SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
/* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
#endif
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
(unaryfunc)0, /*nb_negative*/
(unaryfunc)0, /*nb_positive*/
(unaryfunc)0, /*nb_absolute*/
(inquiry)0, /*nb_nonzero*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
0, /*nb_coerce*/
#endif
(unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_long, /*nb_long*/
#else
0, /*nb_reserved*/
#endif
(unaryfunc)0, /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
};
static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyObject", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
(cmpfunc)SwigPyObject_compare, /* tp_compare */
#endif
(reprfunc)SwigPyObject_repr, /* tp_repr */
&SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigobject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
(richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
swigobject_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobject_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpyobject_type) != 0)
return NULL;
}
return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
sobj->own = own;
sobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
sobj->dict = 0;
#endif
if (own == SWIG_POINTER_OWN) {
/* Obtain a reference to the Python capsule wrapping the module information, so that the
* module information is correctly destroyed after all SWIG python objects have been freed
* by the GC (and corresponding destructors invoked) */
Py_XINCREF(Swig_Capsule_global);
}
}
return (PyObject *)sobj;
}
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
void *pack;
swig_type_info *ty;
size_t size;
} SwigPyPacked;
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return SWIG_Python_str_FromFormat("", result, v->ty->name);
} else {
return SWIG_Python_str_FromFormat("", v->ty->name);
}
}
SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}
SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
return ((op)->ob_type == SwigPyPacked_TypeOnce())
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
if (SwigPyPacked_Check(v)) {
SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyPacked", /* tp_name */
sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
0, /* tp_reserved in 3.0.1 */
#else
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
#endif
(reprfunc)SwigPyPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigpacked_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpypacked_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpypacked_type) != 0)
return NULL;
}
return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
memcpy(pack, ptr, size);
sobj->pack = pack;
sobj->ty = ty;
sobj->size = size;
} else {
PyObject_DEL((PyObject *) sobj);
sobj = 0;
}
}
return (PyObject *) sobj;
}
SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (SwigPyPacked_Check(obj)) {
SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
} else {
return 0;
}
}
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
static PyObject *Swig_This_global = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
if (Swig_This_global == NULL)
Swig_This_global = SWIG_Python_str_FromChar("this");
return Swig_This_global;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS
#endif
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
PyObject *obj;
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
#ifdef SWIGPYTHON_BUILTIN
(void)obj;
# ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
pyobj = PyWeakref_GET_OBJECT(pyobj);
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
# endif
return NULL;
#else
obj = 0;
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
}
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
#endif
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
return oldown;
}
}
return 0;
}
/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
int res;
SwigPyObject *sobj;
int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
if (!obj)
return SWIG_ERROR;
if (obj == Py_None && !implicit_conv) {
if (ptr)
*ptr = 0;
return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
}
res = SWIG_ERROR;
sobj = SWIG_Python_GetSwigThis(obj);
if (own)
*own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
swig_type_info *to = sobj->ty;
if (to == ty) {
/* no type cast needed */
if (ptr) *ptr = vptr;
break;
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
sobj = (SwigPyObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
if (own)
*own = *own | SWIG_CAST_NEW_MEMORY;
}
}
break;
}
}
} else {
if (ptr) *ptr = vptr;
break;
}
}
if (sobj) {
if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
res = SWIG_ERROR_RELEASE_NOT_OWNED;
} else {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
if (flags & SWIG_POINTER_CLEAR) {
sobj->ptr = 0;
}
res = SWIG_OK;
}
} else {
if (implicit_conv) {
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
PyObject *impconv;
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
impconv = SWIG_Python_CallFunctor(klass, obj);
data->implicitconv = 0;
if (PyErr_Occurred()) {
PyErr_Clear();
impconv = 0;
}
if (impconv) {
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
if (SWIG_IsOK(res)) {
if (ptr) {
*ptr = vptr;
/* transfer the ownership to 'ptr' */
iobj->own = 0;
res = SWIG_AddCast(res);
res = SWIG_AddNewMask(res);
} else {
res = SWIG_AddCast(res);
}
}
}
Py_DECREF(impconv);
}
}
}
if (!SWIG_IsOK(res) && obj == Py_None) {
if (ptr)
*ptr = 0;
if (PyErr_Occurred())
PyErr_Clear();
res = SWIG_OK;
}
}
}
return res;
}
/* Convert a function ptr value */
SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
if (!PyCFunction_Check(obj)) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
swig_cast_info *tc;
/* here we get the method pointer for callbacks */
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
if (!desc)
return SWIG_ERROR;
tc = SWIG_TypeCheck(desc,ty);
if (tc) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
} else {
return SWIG_ERROR;
}
return SWIG_OK;
}
}
/* Convert a packed pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
/* check type cast? */
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* -----------------------------------------------------------------------------
* Create a new pointer object
* ----------------------------------------------------------------------------- */
/*
Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
inst = PyObject_Call(newraw, data->newargs, NULL);
if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
Py_DECREF(inst);
inst = 0;
}
}
#else
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
}
#endif
}
} else {
#if PY_VERSION_HEX >= 0x03000000
PyObject *empty_args = PyTuple_New(0);
if (empty_args) {
PyObject *empty_kwargs = PyDict_New();
if (empty_kwargs) {
inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
Py_DECREF(empty_kwargs);
if (inst) {
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
} else {
PyType_Modified(Py_TYPE(inst));
}
}
}
Py_DECREF(empty_args);
}
#else
PyObject *dict = PyDict_New();
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
}
#endif
}
return inst;
}
SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
return PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
return -1;
}
}
#endif
return PyObject_SetAttr(inst, SWIG_This(), swig_this);
}
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
return NULL;
} else {
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
} else {
if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
return NULL;
}
return SWIG_Py_Void();
}
}
/* Create a new pointer object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
SwigPyClientData *clientdata;
PyObject * robj;
int own;
if (!ptr)
return SWIG_Py_Void();
clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
if (clientdata && clientdata->pytype) {
SwigPyObject *newobj;
if (flags & SWIG_BUILTIN_TP_INIT) {
newobj = (SwigPyObject*) self;
if (newobj->ptr) {
PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
while (newobj->next)
newobj = (SwigPyObject *) newobj->next;
newobj->next = next_self;
newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
newobj->dict = 0;
#endif
}
} else {
newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
if (newobj) {
newobj->dict = 0;
}
#endif
}
if (newobj) {
newobj->ptr = ptr;
newobj->ty = type;
newobj->own = own;
newobj->next = 0;
return (PyObject*) newobj;
}
return SWIG_Py_Void();
}
assert(!(flags & SWIG_BUILTIN_TP_INIT));
robj = SwigPyObject_New(ptr, type, own);
if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
Py_DECREF(robj);
robj = inst;
}
return robj;
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
* Get type list
* -----------------------------------------------------------------------------*/
#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif
static PyObject *Swig_TypeCache_global = NULL;
/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
if (Swig_TypeCache_global == NULL) {
Swig_TypeCache_global = PyDict_New();
}
return Swig_TypeCache_global;
}
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
}
#else
void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
}
#endif
return (swig_module_info *) type_pointer;
}
static int interpreter_counter = 0; // how many (sub-)interpreters are using swig_module's types
SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
swig_type_info **types = swig_module->types;
size_t i;
if (--interpreter_counter != 0) // another sub-interpreter may still be using the swig_module's types
return;
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
ty->clientdata = 0;
if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
Swig_This_global = NULL;
Py_DECREF(SWIG_globals());
Swig_Globals_global = NULL;
Py_DECREF(SWIG_Python_TypeCache());
Swig_TypeCache_global = NULL;
Swig_Capsule_global = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
/* Add a dummy module object into sys.modules */
PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && module) {
if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
++interpreter_counter;
Swig_Capsule_global = pointer;
} else {
Py_DECREF(pointer);
}
} else {
Py_XDECREF(pointer);
}
}
SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
PyObject *key = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
} else {
swig_module_info *swig_module = SWIG_GetModule(0);
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
obj = PyCapsule_New((void*) descriptor, NULL, NULL);
if (obj) {
PyDict_SetItem(cache, key, obj);
Py_DECREF(obj);
}
}
}
Py_DECREF(key);
return descriptor;
}
/*
For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION 0
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
const char *errmesg = tmp ? tmp : "Invalid error message";
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, errmesg);
} else {
PyErr_Format(type, "%s %s", errmesg, mesg);
}
Py_DECREF(old_str);
}
return 1;
} else {
return 0;
}
}
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
if (PyErr_Occurred()) {
/* add information about failing argument */
char mesg[256];
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
} else {
return 0;
}
}
SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : "";
}
SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
if (obj && SwigPyObject_Check(obj)) {
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
type, otype);
return;
}
} else
#endif
{
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
}
Py_XDECREF(str);
return;
}
}
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
} else {
PyErr_Format(PyExc_TypeError, "unexpected type is received");
}
}
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
}
return result;
}
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
PyTypeObject *tp = obj->ob_type;
PyObject *descr;
PyObject *encoded_name;
descrsetfunc f;
int res = -1;
# ifdef Py_USING_UNICODE
if (PyString_Check(name)) {
name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
if (!name)
return -1;
} else if (!PyUnicode_Check(name))
# else
if (!PyString_Check(name))
# endif
{
PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
return -1;
} else {
Py_INCREF(name);
}
if (!tp->tp_dict) {
if (PyType_Ready(tp) != 0)
goto done;
}
descr = _PyType_Lookup(tp, name);
f = NULL;
if (descr != NULL)
f = descr->ob_type->tp_descr_set;
if (!f) {
if (PyString_Check(name)) {
encoded_name = name;
Py_INCREF(name);
} else {
encoded_name = PyUnicode_AsUTF8String(name);
if (!encoded_name)
goto done;
}
PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
Py_DECREF(encoded_name);
} else {
res = f(descr, obj, value);
}
done:
Py_DECREF(name);
return res;
}
#endif
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN Py_hash_t
SwigPyObject_hash(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
void *ptr = sobj->ptr;
#if PY_VERSION_HEX < 0x03020000
return (Py_hash_t)(Py_ssize_t)ptr;
#else
return (Py_hash_t)ptr;
#endif
}
SWIGINTERN Py_hash_t
SWIG_PyNumber_AsPyHash(PyObject *obj) {
Py_hash_t result = -1;
#if PY_VERSION_HEX < 0x03020000
if (PyInt_Check(obj))
result = PyInt_AsLong(obj);
else if (PyLong_Check(obj))
result = PyLong_AsLong(obj);
#else
if (PyNumber_Check(obj))
result = PyNumber_AsSsize_t(obj, NULL);
#endif
else
PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
return PyErr_Occurred() ? -1 : result;
}
SWIGINTERN int
SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
return -1;
}
SWIGINTERN void
SwigPyBuiltin_BadDealloc(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
if (sobj->own) {
PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", obj->ob_type->tp_name);
}
}
typedef struct {
PyCFunction get;
PyCFunction set;
} SwigPyGetSet;
SWIGINTERN PyObject *
SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
tuple = PyTuple_New(0);
assert(tuple);
result = (*getset->get)(obj, tuple);
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyObject *
SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
result = (*getset->get)(obj, NULL);
return result;
}
SWIGINTERN int
SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(val);
PyTuple_SET_ITEM(tuple, 0, val);
result = (*getset->set)(obj, tuple);
Py_DECREF(tuple);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN int
SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
result = (*getset->set)(obj, val);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN void
SwigPyStaticVar_dealloc(PyDescrObject *descr) {
PyObject_GC_UnTrack(descr);
Py_XDECREF(PyDescr_TYPE(descr));
Py_XDECREF(PyDescr_NAME(descr));
PyObject_GC_Del(descr);
}
SWIGINTERN PyObject *
SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromFormat("", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
return PyString_FromFormat("", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
}
SWIGINTERN int
SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
PyDescrObject *descr;
descr = (PyDescrObject *)self;
Py_VISIT((PyObject*) PyDescr_TYPE(descr));
return 0;
}
SWIGINTERN PyObject *
SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
if (descr->d_getset->get != NULL)
return descr->d_getset->get(obj, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return NULL;
}
SWIGINTERN int
SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
if (descr->d_getset->set != NULL)
return descr->d_getset->set(obj, value, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return -1;
}
SWIGINTERN int
SwigPyObjectType_setattro(PyObject *typeobject, PyObject *name, PyObject *value) {
PyObject *attribute;
PyTypeObject *type;
descrsetfunc local_set;
assert(PyType_Check(typeobject));
type = (PyTypeObject *)typeobject;
attribute = _PyType_Lookup(type, name);
if (attribute != NULL) {
/* Implement descriptor functionality, if any */
local_set = attribute->ob_type->tp_descr_set;
if (local_set != NULL)
return local_set(attribute, (PyObject *)type, value);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
} else {
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
}
return -1;
}
SWIGINTERN PyTypeObject*
SwigPyStaticVar_Type(void) {
static PyTypeObject staticvar_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"swig_static_var_getset_descriptor", /* tp_name */
sizeof(PyGetSetDescrObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyStaticVar_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
(reprfunc)SwigPyStaticVar_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
0, /* tp_doc */
SwigPyStaticVar_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc)SwigPyStaticVar_get, /* tp_descr_get */
(descrsetfunc)SwigPyStaticVar_set, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
staticvar_type = tmp;
type_init = 1;
if (PyType_Ready(&staticvar_type) < 0)
return NULL;
}
return &staticvar_type;
}
SWIGINTERN PyTypeObject*
SwigPyObjectType(void) {
static char swigpyobjecttype_doc[] = "Metaclass for SWIG wrapped types";
static PyTypeObject swigpyobjecttype_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"SwigPyObjectType", /* tp_name */
PyType_Type.tp_basicsize, /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
SwigPyObjectType_setattro, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
swigpyobjecttype_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobjecttype_type = tmp;
type_init = 1;
swigpyobjecttype_type.tp_base = &PyType_Type;
if (PyType_Ready(&swigpyobjecttype_type) < 0)
return NULL;
}
return &swigpyobjecttype_type;
}
SWIGINTERN PyGetSetDescrObject *
SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
PyGetSetDescrObject *descr;
descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
assert(descr);
Py_XINCREF(type);
PyDescr_TYPE(descr) = type;
PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
descr->d_getset = getset;
if (PyDescr_NAME(descr) == NULL) {
Py_DECREF(descr);
descr = NULL;
}
return descr;
}
SWIGINTERN void
SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
Py_ssize_t base_count = 0;
PyTypeObject **b;
PyObject *tuple;
Py_ssize_t i;
if (!bases[0]) {
bases[0] = SwigPyObject_type();
bases[1] = NULL;
}
type->tp_base = bases[0];
Py_INCREF((PyObject *)bases[0]);
for (b = bases; *b != NULL; ++b)
++base_count;
tuple = PyTuple_New(base_count);
for (i = 0; i < base_count; ++i) {
Py_INCREF((PyObject *)bases[i]);
PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
}
type->tp_bases = tuple;
}
SWIGINTERN PyObject *
SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
PyObject *result;
result = (PyObject *)SWIG_Python_GetSwigThis(self);
Py_XINCREF(result);
return result;
}
SWIGINTERN void
SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
{
#if PY_VERSION_HEX >= 0x030900a4
Py_SET_TYPE(type, metatype);
#else
Py_TYPE(type) = metatype;
#endif
}
/* Start of callback function macros for use in PyTypeObject */
typedef PyObject *(*SwigPyWrapperFunction)(PyObject *, PyObject *);
#define SWIGPY_UNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_unaryfunc_closure(PyObject *a) { \
return SwigPyBuiltin_unaryfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_unaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper) \
SWIGINTERN void \
wrapper##_destructor_closure(PyObject *a) { \
SwigPyBuiltin_destructor_closure(wrapper, #wrapper, a); \
}
SWIGINTERN void
SwigPyBuiltin_destructor_closure(SwigPyWrapperFunction wrapper, const char *wrappername, PyObject *a) {
SwigPyObject *sobj;
sobj = (SwigPyObject *)a;
Py_XDECREF(sobj->dict);
if (sobj->own) {
PyObject *o;
PyObject *type = 0, *value = 0, *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
o = wrapper(a, NULL);
if (!o) {
PyObject *deallocname = PyString_FromString(wrappername);
PyErr_WriteUnraisable(deallocname);
Py_DECREF(deallocname);
}
PyErr_Restore(type, value, traceback);
Py_XDECREF(o);
}
if (PyType_IS_GC(a->ob_type)) {
PyObject_GC_Del(a);
} else {
PyObject_Del(a);
}
}
#define SWIGPY_INQUIRY_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_inquiry_closure(PyObject *a) { \
return SwigPyBuiltin_inquiry_closure(wrapper, a); \
}
SWIGINTERN int
SwigPyBuiltin_inquiry_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
int result;
pyresult = wrapper(a, NULL);
result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_GETITERFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_getiterfunc_closure(PyObject *a) { \
return SwigPyBuiltin_getiterfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_getiterfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_BINARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_binaryfunc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_binaryfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_binaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
typedef ternaryfunc ternarycallfunc;
#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternaryfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternaryfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternarycallfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternarycallfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternarycallfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
(void) c;
return wrapper(a, b);
}
#define SWIGPY_LENFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_ssize_t \
wrapper##_lenfunc_closure(PyObject *a) { \
return SwigPyBuiltin_lenfunc_closure(wrapper, a); \
}
SWIGINTERN Py_ssize_t
SwigPyBuiltin_lenfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *resultobj;
Py_ssize_t result;
resultobj = wrapper(a, NULL);
result = PyNumber_AsSsize_t(resultobj, NULL);
Py_DECREF(resultobj);
return result;
}
#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizessizeargfunc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) { \
return SwigPyBuiltin_ssizessizeargfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizessizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizessizeobjargproc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
return SwigPyBuiltin_ssizessizeobjargproc_closure(wrapper, a, b, c, d); \
}
SWIGINTERN int
SwigPyBuiltin_ssizessizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(d ? 3 : 2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
if (d) {
Py_INCREF(d);
PyTuple_SET_ITEM(tuple, 2, d);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_DECREF(tuple);
Py_XDECREF(resultobj);
return result;
}
#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_funpack_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_funpack_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *arg, *result;
arg = _PyLong_FromSsize_t(b);
result = wrapper(a, arg);
Py_DECREF(arg);
return result;
}
#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizeobjargproc_closure(PyObject *a, Py_ssize_t b, PyObject *c) { \
return SwigPyBuiltin_ssizeobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_ssizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
PyObject *tuple;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
pyresult = wrapper(a, tuple);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_funpack_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_funpack_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
pyresult = wrapper(a, b);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjargproc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_objobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_objobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(c ? 2 : 1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
if (c) {
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_REPRFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_reprfunc_closure(PyObject *a) { \
return SwigPyBuiltin_reprfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_reprfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_HASHFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_hash_t \
wrapper##_hashfunc_closure(PyObject *a) { \
return SwigPyBuiltin_hashfunc_closure(wrapper, a); \
}
SWIGINTERN Py_hash_t
SwigPyBuiltin_hashfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
Py_hash_t result;
pyresult = wrapper(a, NULL);
if (!pyresult)
return -1;
result = SWIG_PyNumber_AsPyHash(pyresult);
Py_DECREF(pyresult);
return result;
}
#define SWIGPY_ITERNEXTFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_iternextfunc_closure(PyObject *a) { \
return SwigPyBuiltin_iternextfunc_closure(wrapper, a);\
}
SWIGINTERN PyObject *
SwigPyBuiltin_iternextfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
/* End of callback function macros for use in PyTypeObject */
#ifdef __cplusplus
}
#endif
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_CameraFileAccessType swig_types[0]
#define SWIGTYPE_p_CameraFileInfoFields swig_types[1]
#define SWIGTYPE_p_CameraFilePermissions swig_types[2]
#define SWIGTYPE_p_CameraFileStatus swig_types[3]
#define SWIGTYPE_p_CameraFileType swig_types[4]
#define SWIGTYPE_p_CameraStorageAccessType swig_types[5]
#define SWIGTYPE_p_CameraStorageFilesystemType swig_types[6]
#define SWIGTYPE_p_CameraStorageInfoFields swig_types[7]
#define SWIGTYPE_p_CameraStorageType swig_types[8]
#define SWIGTYPE_p_SwigPyObject swig_types[9]
#define SWIGTYPE_p__CameraFile swig_types[10]
#define SWIGTYPE_p__CameraFileHandler swig_types[11]
#define SWIGTYPE_p__CameraFileInfo swig_types[12]
#define SWIGTYPE_p__CameraFileInfoAudio swig_types[13]
#define SWIGTYPE_p__CameraFileInfoFile swig_types[14]
#define SWIGTYPE_p__CameraFileInfoPreview swig_types[15]
#define SWIGTYPE_p__CameraStorageInformation swig_types[16]
#define SWIGTYPE_p_char swig_types[17]
#define SWIGTYPE_p_int swig_types[18]
#define SWIGTYPE_p_long swig_types[19]
#define SWIGTYPE_p_long_long swig_types[20]
#define SWIGTYPE_p_short swig_types[21]
#define SWIGTYPE_p_signed_char swig_types[22]
#define SWIGTYPE_p_unsigned_char swig_types[23]
#define SWIGTYPE_p_unsigned_int swig_types[24]
#define SWIGTYPE_p_unsigned_long_long swig_types[25]
#define SWIGTYPE_p_unsigned_short swig_types[26]
static swig_type_info *swig_types[28];
static swig_module_info swig_module = {swig_types, 27, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery
/*-----------------------------------------------
@(target):= _filesys.so
------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_init PyInit__filesys
#else
# define SWIG_init init_filesys
#endif
#define SWIG_name "_filesys"
#define SWIG_as_voidptr(a) (void *)((const void *)(a))
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
#include
#include "gphoto2/gphoto2.h"
PyObject *PyExc_GPhoto2Error = NULL;
#include // Use the C99 official header
SWIGINTERNINLINE PyObject*
SWIG_From_int (int value)
{
return PyInt_FromLong((long) value);
}
#include
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
# define LLONG_MAX __LONG_LONG_MAX__
# define LLONG_MIN (-LLONG_MAX - 1LL)
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif
SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
int res = SWIG_TypeError;
if (PyFloat_Check(obj)) {
if (val) *val = PyFloat_AsDouble(obj);
return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
} else if (PyInt_Check(obj)) {
if (val) *val = (double) PyInt_AsLong(obj);
return SWIG_OK;
#endif
} else if (PyLong_Check(obj)) {
double v = PyLong_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
double d = PyFloat_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = d;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
} else {
PyErr_Clear();
}
}
}
#endif
return res;
}
#include
#include
SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
double x = *d;
if ((min <= x && x <= max)) {
double fx = floor(x);
double cx = ceil(x);
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
if ((errno == EDOM) || (errno == ERANGE)) {
errno = 0;
} else {
double summ, reps, diff;
if (rd < x) {
diff = x - rd;
} else if (rd > x) {
diff = rd - x;
} else {
return 1;
}
summ = rd + x;
reps = diff/summ;
if (reps < 8*DBL_EPSILON) {
*d = rd;
return 1;
}
}
}
return 0;
}
SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
} else
#endif
if (PyLong_Check(obj)) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
return SWIG_OverflowError;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
long v = PyInt_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
if (val) *val = (long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
long v;
int res = SWIG_AsVal_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v < INT_MIN || v > INT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = (int)(v);
}
}
return res;
}
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
{
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
long v = PyInt_AsLong(obj);
if (v >= 0) {
if (val) *val = v;
return SWIG_OK;
} else {
return SWIG_OverflowError;
}
} else
#endif
if (PyLong_Check(obj)) {
unsigned long v = PyLong_AsUnsignedLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
return SWIG_OverflowError;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
unsigned long v = PyLong_AsUnsignedLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
if (val) *val = (unsigned long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
# define SWIG_LONG_LONG_AVAILABLE
#endif
#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
int res = SWIG_TypeError;
if (PyLong_Check(obj)) {
unsigned long long v = PyLong_AsUnsignedLongLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
res = SWIG_OverflowError;
}
} else {
unsigned long v;
res = SWIG_AsVal_unsigned_SS_long (obj,&v);
if (SWIG_IsOK(res)) {
if (val) *val = v;
return res;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
const double mant_max = 1LL << DBL_MANT_DIG;
double d;
res = SWIG_AsVal_double (obj,&d);
if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
return SWIG_OverflowError;
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
if (val) *val = (unsigned long long)(d);
return SWIG_AddCast(res);
}
res = SWIG_TypeError;
}
#endif
return res;
}
#endif
#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject*
SWIG_From_unsigned_SS_long_SS_long (unsigned long long value)
{
return (value > LONG_MAX) ?
PyLong_FromUnsignedLongLong(value) : PyInt_FromLong((long)(value));
}
#endif
SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
static int init = 0;
static swig_type_info* info = 0;
if (!init) {
info = SWIG_TypeQuery("_p_char");
init = 1;
}
return info;
}
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (PyBytes_Check(obj))
#else
if (PyUnicode_Check(obj))
#endif
#else
if (PyString_Check(obj))
#endif
{
char *cstr; Py_ssize_t len;
int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (!alloc && cptr) {
/* We can't allow converting without allocation, since the internal
representation of string in Python 3 is UCS-2/UCS-4 but we require
a UTF-8 representation.
TODO(bhy) More detailed explanation */
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (alloc)
*alloc = SWIG_NEWOBJ;
#endif
if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#else
if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#endif
if (cptr) {
if (alloc) {
if (*alloc == SWIG_NEWOBJ) {
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
*alloc = SWIG_NEWOBJ;
} else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
}
} else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
*cptr = PyBytes_AsString(obj);
#else
assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
*cptr = SWIG_Python_str_AsChar(obj);
if (!*cptr)
ret = SWIG_TypeError;
#endif
}
}
if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
Py_XDECREF(obj);
#endif
return ret;
} else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
if (PyUnicode_Check(obj)) {
char *cstr; Py_ssize_t len;
if (!alloc && cptr) {
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
if (cptr) {
if (alloc) *alloc = SWIG_NEWOBJ;
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
}
if (psize) *psize = len + 1;
Py_XDECREF(obj);
return SWIG_OK;
} else {
Py_XDECREF(obj);
}
}
#endif
#endif
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
if (pchar_descriptor) {
void* vptr = 0;
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
if (cptr) *cptr = (char *) vptr;
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
if (alloc) *alloc = SWIG_OLDOBJ;
return SWIG_OK;
}
}
}
return SWIG_TypeError;
}
SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{
char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
if (SWIG_IsOK(res)) {
/* special case of single char conversion when we don't need space for NUL */
if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
if (csize <= size) {
if (val) {
if (csize) memcpy(val, cptr, csize*sizeof(char));
if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
}
if (alloc == SWIG_NEWOBJ) {
free((char*)cptr);
res = SWIG_DelNewMask(res);
}
return res;
}
if (alloc == SWIG_NEWOBJ) free((char*)cptr);
}
return SWIG_TypeError;
}
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
if (carray) {
if (size > INT_MAX) {
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
return pchar_descriptor ?
SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
} else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
#else
return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
#endif
#else
return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
#endif
}
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN size_t
SWIG_strnlen(const char* s, size_t maxlen)
{
const char *p;
for (p = s; maxlen-- && *p; p++)
;
return p - s;
}
SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
{
unsigned long v;
int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v > UINT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = (unsigned int)(v);
}
}
return res;
}
SWIGINTERNINLINE PyObject*
SWIG_From_unsigned_SS_int (unsigned int value)
{
return PyInt_FromSize_t((size_t) value);
}
#define SWIG_From_long PyInt_FromLong
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_fields_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
CameraFileInfoFields arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoFile_fields_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_fields_set" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoFile_fields_set" "', argument " "2"" of type '" "CameraFileInfoFields""'");
}
arg2 = (CameraFileInfoFields)(val2);
if (arg1) (arg1)->fields = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_fields_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraFileInfoFields result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoFile_fields_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_fields_get" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
result = (CameraFileInfoFields) ((arg1)->fields);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_status_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
CameraFileStatus arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoFile_status_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_status_set" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoFile_status_set" "', argument " "2"" of type '" "CameraFileStatus""'");
}
arg2 = (CameraFileStatus)(val2);
if (arg1) (arg1)->status = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_status_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraFileStatus result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoFile_status_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_status_get" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
result = (CameraFileStatus) ((arg1)->status);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_size_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
uint64_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned long long val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoFile_size_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_size_set" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoFile_size_set" "', argument " "2"" of type '" "uint64_t""'");
}
arg2 = (uint64_t)(val2);
if (arg1) (arg1)->size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_size_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
uint64_t result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoFile_size_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_size_get" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
result = (uint64_t) ((arg1)->size);
resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_type_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[64] ;
int res2 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoFile_type_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_type_set" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 64);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraFileInfoFile_type_set" "', argument " "2"" of type '" "char [64]""'");
}
arg2 = (char *)(temp2);
if (arg2) memcpy(arg1->type,arg2,64*sizeof(char));
else memset(arg1->type,0,64*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_type_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoFile_type_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_type_get" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
result = (char *)(char *) ((arg1)->type);
{
size_t size = SWIG_strnlen(result, 64);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_width_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
uint32_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoFile_width_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_width_set" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoFile_width_set" "', argument " "2"" of type '" "uint32_t""'");
}
arg2 = (uint32_t)(val2);
if (arg1) (arg1)->width = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_width_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
uint32_t result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoFile_width_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_width_get" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
result = (uint32_t) ((arg1)->width);
resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_height_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
uint32_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoFile_height_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_height_set" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoFile_height_set" "', argument " "2"" of type '" "uint32_t""'");
}
arg2 = (uint32_t)(val2);
if (arg1) (arg1)->height = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_height_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
uint32_t result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoFile_height_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_height_get" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
result = (uint32_t) ((arg1)->height);
resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_permissions_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
CameraFilePermissions arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoFile_permissions_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_permissions_set" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoFile_permissions_set" "', argument " "2"" of type '" "CameraFilePermissions""'");
}
arg2 = (CameraFilePermissions)(val2);
if (arg1) (arg1)->permissions = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_permissions_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraFilePermissions result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoFile_permissions_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_permissions_get" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
result = (CameraFilePermissions) ((arg1)->permissions);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_mtime_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
time_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
long val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoFile_mtime_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_mtime_set" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
ecode2 = SWIG_AsVal_long(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoFile_mtime_set" "', argument " "2"" of type '" "time_t""'");
}
arg2 = (time_t)(val2);
if (arg1) (arg1)->mtime = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoFile_mtime_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
time_t result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoFile_mtime_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoFile_mtime_get" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
result = (time_t) ((arg1)->mtime);
resultobj = SWIG_From_long((long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CameraFileInfoFile(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoFile *arg1 = (struct _CameraFileInfoFile *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CameraFileInfoFile takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoFile, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraFileInfoFile" "', argument " "1"" of type '" "struct _CameraFileInfoFile *""'");
}
arg1 = (struct _CameraFileInfoFile *)(argp1);
free((char *) arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraFileInfoFile) /* defines _wrap_delete_CameraFileInfoFile_destructor_closure */
SWIGINTERN PyObject *_wrap_CameraFileInfoPreview_fields_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
CameraFileInfoFields arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoPreview_fields_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoPreview_fields_set" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoPreview_fields_set" "', argument " "2"" of type '" "CameraFileInfoFields""'");
}
arg2 = (CameraFileInfoFields)(val2);
if (arg1) (arg1)->fields = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoPreview_fields_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraFileInfoFields result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoPreview_fields_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoPreview_fields_get" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
result = (CameraFileInfoFields) ((arg1)->fields);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoPreview_status_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
CameraFileStatus arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoPreview_status_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoPreview_status_set" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoPreview_status_set" "', argument " "2"" of type '" "CameraFileStatus""'");
}
arg2 = (CameraFileStatus)(val2);
if (arg1) (arg1)->status = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoPreview_status_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraFileStatus result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoPreview_status_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoPreview_status_get" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
result = (CameraFileStatus) ((arg1)->status);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoPreview_size_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
uint64_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned long long val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoPreview_size_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoPreview_size_set" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoPreview_size_set" "', argument " "2"" of type '" "uint64_t""'");
}
arg2 = (uint64_t)(val2);
if (arg1) (arg1)->size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoPreview_size_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
uint64_t result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoPreview_size_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoPreview_size_get" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
result = (uint64_t) ((arg1)->size);
resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoPreview_type_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[64] ;
int res2 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoPreview_type_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoPreview_type_set" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 64);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraFileInfoPreview_type_set" "', argument " "2"" of type '" "char [64]""'");
}
arg2 = (char *)(temp2);
if (arg2) memcpy(arg1->type,arg2,64*sizeof(char));
else memset(arg1->type,0,64*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoPreview_type_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoPreview_type_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoPreview_type_get" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
result = (char *)(char *) ((arg1)->type);
{
size_t size = SWIG_strnlen(result, 64);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoPreview_width_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
uint32_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoPreview_width_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoPreview_width_set" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoPreview_width_set" "', argument " "2"" of type '" "uint32_t""'");
}
arg2 = (uint32_t)(val2);
if (arg1) (arg1)->width = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoPreview_width_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
uint32_t result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoPreview_width_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoPreview_width_get" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
result = (uint32_t) ((arg1)->width);
resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoPreview_height_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
uint32_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoPreview_height_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoPreview_height_set" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoPreview_height_set" "', argument " "2"" of type '" "uint32_t""'");
}
arg2 = (uint32_t)(val2);
if (arg1) (arg1)->height = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoPreview_height_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
uint32_t result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoPreview_height_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoPreview_height_get" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
result = (uint32_t) ((arg1)->height);
resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CameraFileInfoPreview(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoPreview *arg1 = (struct _CameraFileInfoPreview *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CameraFileInfoPreview takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoPreview, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraFileInfoPreview" "', argument " "1"" of type '" "struct _CameraFileInfoPreview *""'");
}
arg1 = (struct _CameraFileInfoPreview *)(argp1);
free((char *) arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraFileInfoPreview) /* defines _wrap_delete_CameraFileInfoPreview_destructor_closure */
SWIGINTERN PyObject *_wrap_CameraFileInfoAudio_fields_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoAudio *arg1 = (struct _CameraFileInfoAudio *) 0 ;
CameraFileInfoFields arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoAudio_fields_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoAudio, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoAudio_fields_set" "', argument " "1"" of type '" "struct _CameraFileInfoAudio *""'");
}
arg1 = (struct _CameraFileInfoAudio *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoAudio_fields_set" "', argument " "2"" of type '" "CameraFileInfoFields""'");
}
arg2 = (CameraFileInfoFields)(val2);
if (arg1) (arg1)->fields = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoAudio_fields_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoAudio *arg1 = (struct _CameraFileInfoAudio *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraFileInfoFields result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoAudio_fields_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoAudio, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoAudio_fields_get" "', argument " "1"" of type '" "struct _CameraFileInfoAudio *""'");
}
arg1 = (struct _CameraFileInfoAudio *)(argp1);
result = (CameraFileInfoFields) ((arg1)->fields);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoAudio_status_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoAudio *arg1 = (struct _CameraFileInfoAudio *) 0 ;
CameraFileStatus arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoAudio_status_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoAudio, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoAudio_status_set" "', argument " "1"" of type '" "struct _CameraFileInfoAudio *""'");
}
arg1 = (struct _CameraFileInfoAudio *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoAudio_status_set" "', argument " "2"" of type '" "CameraFileStatus""'");
}
arg2 = (CameraFileStatus)(val2);
if (arg1) (arg1)->status = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoAudio_status_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoAudio *arg1 = (struct _CameraFileInfoAudio *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraFileStatus result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoAudio_status_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoAudio, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoAudio_status_get" "', argument " "1"" of type '" "struct _CameraFileInfoAudio *""'");
}
arg1 = (struct _CameraFileInfoAudio *)(argp1);
result = (CameraFileStatus) ((arg1)->status);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoAudio_size_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoAudio *arg1 = (struct _CameraFileInfoAudio *) 0 ;
uint64_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned long long val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoAudio_size_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoAudio, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoAudio_size_set" "', argument " "1"" of type '" "struct _CameraFileInfoAudio *""'");
}
arg1 = (struct _CameraFileInfoAudio *)(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraFileInfoAudio_size_set" "', argument " "2"" of type '" "uint64_t""'");
}
arg2 = (uint64_t)(val2);
if (arg1) (arg1)->size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoAudio_size_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoAudio *arg1 = (struct _CameraFileInfoAudio *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
uint64_t result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoAudio_size_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoAudio, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoAudio_size_get" "', argument " "1"" of type '" "struct _CameraFileInfoAudio *""'");
}
arg1 = (struct _CameraFileInfoAudio *)(argp1);
result = (uint64_t) ((arg1)->size);
resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoAudio_type_set(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoAudio *arg1 = (struct _CameraFileInfoAudio *) 0 ;
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char temp2[64] ;
int res2 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraFileInfoAudio_type_set", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoAudio, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoAudio_type_set" "', argument " "1"" of type '" "struct _CameraFileInfoAudio *""'");
}
arg1 = (struct _CameraFileInfoAudio *)(argp1);
res2 = SWIG_AsCharArray(obj1, temp2, 64);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraFileInfoAudio_type_set" "', argument " "2"" of type '" "char [64]""'");
}
arg2 = (char *)(temp2);
if (arg2) memcpy(arg1->type,arg2,64*sizeof(char));
else memset(arg1->type,0,64*sizeof(char));
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfoAudio_type_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoAudio *arg1 = (struct _CameraFileInfoAudio *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfoAudio_type_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoAudio, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfoAudio_type_get" "', argument " "1"" of type '" "struct _CameraFileInfoAudio *""'");
}
arg1 = (struct _CameraFileInfoAudio *)(argp1);
result = (char *)(char *) ((arg1)->type);
{
size_t size = SWIG_strnlen(result, 64);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CameraFileInfoAudio(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfoAudio *arg1 = (struct _CameraFileInfoAudio *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CameraFileInfoAudio takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfoAudio, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraFileInfoAudio" "', argument " "1"" of type '" "struct _CameraFileInfoAudio *""'");
}
arg1 = (struct _CameraFileInfoAudio *)(argp1);
free((char *) arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraFileInfoAudio) /* defines _wrap_delete_CameraFileInfoAudio_destructor_closure */
SWIGINTERN PyObject *_wrap_CameraFileInfo_preview_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfo *arg1 = (struct _CameraFileInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraFileInfoPreview *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfo_preview_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfo_preview_get" "', argument " "1"" of type '" "struct _CameraFileInfo *""'");
}
arg1 = (struct _CameraFileInfo *)(argp1);
result = (CameraFileInfoPreview *)& ((arg1)->preview);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraFileInfoPreview, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfo_file_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfo *arg1 = (struct _CameraFileInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraFileInfoFile *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfo_file_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfo_file_get" "', argument " "1"" of type '" "struct _CameraFileInfo *""'");
}
arg1 = (struct _CameraFileInfo *)(argp1);
result = (CameraFileInfoFile *)& ((arg1)->file);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraFileInfoFile, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraFileInfo_audio_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfo *arg1 = (struct _CameraFileInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraFileInfoAudio *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraFileInfo_audio_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraFileInfo_audio_get" "', argument " "1"" of type '" "struct _CameraFileInfo *""'");
}
arg1 = (struct _CameraFileInfo *)(argp1);
result = (CameraFileInfoAudio *)& ((arg1)->audio);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraFileInfoAudio, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN int _wrap_new_CameraFileInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
struct _CameraFileInfo *result = 0 ;
(void)self;
if (!SWIG_Python_CheckNoKeywords(kwargs, "new_CameraFileInfo")) SWIG_fail;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "new_CameraFileInfo takes no arguments");
result = (struct _CameraFileInfo *)calloc(1, sizeof(struct _CameraFileInfo));
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraFileInfo, SWIG_BUILTIN_INIT | 0 );
return resultobj == Py_None ? -1 : 0;
fail:
return -1;
}
SWIGINTERN PyObject *_wrap_delete_CameraFileInfo(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraFileInfo *arg1 = (struct _CameraFileInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CameraFileInfo takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraFileInfo, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraFileInfo" "', argument " "1"" of type '" "struct _CameraFileInfo *""'");
}
arg1 = (struct _CameraFileInfo *)(argp1);
free((char *) arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraFileInfo) /* defines _wrap_delete_CameraFileInfo_destructor_closure */
SWIGINTERN PyObject *_wrap_CameraStorageInformation_fields_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraStorageInformation *arg1 = (struct _CameraStorageInformation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraStorageInfoFields result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraStorageInformation_fields_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraStorageInformation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraStorageInformation_fields_get" "', argument " "1"" of type '" "struct _CameraStorageInformation *""'");
}
arg1 = (struct _CameraStorageInformation *)(argp1);
result = (CameraStorageInfoFields) ((arg1)->fields);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraStorageInformation_basedir_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraStorageInformation *arg1 = (struct _CameraStorageInformation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraStorageInformation_basedir_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraStorageInformation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraStorageInformation_basedir_get" "', argument " "1"" of type '" "struct _CameraStorageInformation *""'");
}
arg1 = (struct _CameraStorageInformation *)(argp1);
result = (char *)(char *) ((arg1)->basedir);
{
size_t size = SWIG_strnlen(result, 256);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraStorageInformation_label_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraStorageInformation *arg1 = (struct _CameraStorageInformation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraStorageInformation_label_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraStorageInformation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraStorageInformation_label_get" "', argument " "1"" of type '" "struct _CameraStorageInformation *""'");
}
arg1 = (struct _CameraStorageInformation *)(argp1);
result = (char *)(char *) ((arg1)->label);
{
size_t size = SWIG_strnlen(result, 256);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraStorageInformation_description_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraStorageInformation *arg1 = (struct _CameraStorageInformation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraStorageInformation_description_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraStorageInformation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraStorageInformation_description_get" "', argument " "1"" of type '" "struct _CameraStorageInformation *""'");
}
arg1 = (struct _CameraStorageInformation *)(argp1);
result = (char *)(char *) ((arg1)->description);
{
size_t size = SWIG_strnlen(result, 256);
resultobj = SWIG_FromCharPtrAndSize(result, size);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraStorageInformation_type_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraStorageInformation *arg1 = (struct _CameraStorageInformation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraStorageType result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraStorageInformation_type_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraStorageInformation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraStorageInformation_type_get" "', argument " "1"" of type '" "struct _CameraStorageInformation *""'");
}
arg1 = (struct _CameraStorageInformation *)(argp1);
result = (CameraStorageType) ((arg1)->type);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraStorageInformation_fstype_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraStorageInformation *arg1 = (struct _CameraStorageInformation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraStorageFilesystemType result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraStorageInformation_fstype_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraStorageInformation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraStorageInformation_fstype_get" "', argument " "1"" of type '" "struct _CameraStorageInformation *""'");
}
arg1 = (struct _CameraStorageInformation *)(argp1);
result = (CameraStorageFilesystemType) ((arg1)->fstype);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraStorageInformation_access_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraStorageInformation *arg1 = (struct _CameraStorageInformation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraStorageAccessType result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraStorageInformation_access_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraStorageInformation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraStorageInformation_access_get" "', argument " "1"" of type '" "struct _CameraStorageInformation *""'");
}
arg1 = (struct _CameraStorageInformation *)(argp1);
result = (CameraStorageAccessType) ((arg1)->access);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraStorageInformation_capacitykbytes_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraStorageInformation *arg1 = (struct _CameraStorageInformation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
uint64_t result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraStorageInformation_capacitykbytes_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraStorageInformation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraStorageInformation_capacitykbytes_get" "', argument " "1"" of type '" "struct _CameraStorageInformation *""'");
}
arg1 = (struct _CameraStorageInformation *)(argp1);
result = (uint64_t) ((arg1)->capacitykbytes);
resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraStorageInformation_freekbytes_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraStorageInformation *arg1 = (struct _CameraStorageInformation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
uint64_t result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraStorageInformation_freekbytes_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraStorageInformation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraStorageInformation_freekbytes_get" "', argument " "1"" of type '" "struct _CameraStorageInformation *""'");
}
arg1 = (struct _CameraStorageInformation *)(argp1);
result = (uint64_t) ((arg1)->freekbytes);
resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraStorageInformation_freeimages_get(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraStorageInformation *arg1 = (struct _CameraStorageInformation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
uint64_t result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraStorageInformation_freeimages_get takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraStorageInformation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraStorageInformation_freeimages_get" "', argument " "1"" of type '" "struct _CameraStorageInformation *""'");
}
arg1 = (struct _CameraStorageInformation *)(argp1);
result = (uint64_t) ((arg1)->freeimages);
resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CameraStorageInformation(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraStorageInformation *arg1 = (struct _CameraStorageInformation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CameraStorageInformation takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraStorageInformation, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraStorageInformation" "', argument " "1"" of type '" "struct _CameraStorageInformation *""'");
}
arg1 = (struct _CameraStorageInformation *)(argp1);
free((char *) arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraStorageInformation) /* defines _wrap_delete_CameraStorageInformation_destructor_closure */
static PyMethodDef SwigMethods[] = {
{ NULL, NULL, 0, NULL }
};
static SwigPyGetSet CameraFileInfoFile_type_getset = { _wrap_CameraFileInfoFile_type_get, _wrap_CameraFileInfoFile_type_set };
static SwigPyGetSet CameraFileInfoFile_size_getset = { _wrap_CameraFileInfoFile_size_get, _wrap_CameraFileInfoFile_size_set };
static SwigPyGetSet CameraFileInfoFile_status_getset = { _wrap_CameraFileInfoFile_status_get, _wrap_CameraFileInfoFile_status_set };
static SwigPyGetSet CameraFileInfoFile_permissions_getset = { _wrap_CameraFileInfoFile_permissions_get, _wrap_CameraFileInfoFile_permissions_set };
static SwigPyGetSet CameraFileInfoFile___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet CameraFileInfoFile_fields_getset = { _wrap_CameraFileInfoFile_fields_get, _wrap_CameraFileInfoFile_fields_set };
static SwigPyGetSet CameraFileInfoFile_width_getset = { _wrap_CameraFileInfoFile_width_get, _wrap_CameraFileInfoFile_width_set };
static SwigPyGetSet CameraFileInfoFile_height_getset = { _wrap_CameraFileInfoFile_height_get, _wrap_CameraFileInfoFile_height_set };
static SwigPyGetSet CameraFileInfoFile_mtime_getset = { _wrap_CameraFileInfoFile_mtime_get, _wrap_CameraFileInfoFile_mtime_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin___CameraFileInfoFile_getset[] = {
{ (char *)"type", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"type", &CameraFileInfoFile_type_getset },
{ (char *)"size", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"size", &CameraFileInfoFile_size_getset },
{ (char *)"status", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"status", &CameraFileInfoFile_status_getset },
{ (char *)"permissions", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"permissions", &CameraFileInfoFile_permissions_getset },
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"fields", &CameraFileInfoFile___dict___getset },
{ (char *)"fields", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"fields", &CameraFileInfoFile_fields_getset },
{ (char *)"width", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"width", &CameraFileInfoFile_width_getset },
{ (char *)"height", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"height", &CameraFileInfoFile_height_getset },
{ (char *)"mtime", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"mtime", &CameraFileInfoFile_mtime_getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___CameraFileInfoFile_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___CameraFileInfoFile_methods[] = {
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___CameraFileInfoFile_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.filesys.CameraFileInfoFile", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CameraFileInfoFile_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___CameraFileInfoFile_type.as_number, /* tp_as_number */
&SwigPyBuiltin___CameraFileInfoFile_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___CameraFileInfoFile_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___CameraFileInfoFile_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"\n"
"File information of a regular file. \n"
"\n"
"Contains information a regular file with fields being set depending on\n"
"the bitmask in the fields member. \n"
"\n"
"C++ includes: gphoto2-filesys.h\n"
"",/* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___CameraFileInfoFile_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___CameraFileInfoFile_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___CameraFileInfoFile_getset,/* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
SwigPyBuiltin_BadInit, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___CameraFileInfoFile_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___CameraFileInfoFile_type};
static SwigPyGetSet CameraFileInfoPreview_type_getset = { _wrap_CameraFileInfoPreview_type_get, _wrap_CameraFileInfoPreview_type_set };
static SwigPyGetSet CameraFileInfoPreview_size_getset = { _wrap_CameraFileInfoPreview_size_get, _wrap_CameraFileInfoPreview_size_set };
static SwigPyGetSet CameraFileInfoPreview_status_getset = { _wrap_CameraFileInfoPreview_status_get, _wrap_CameraFileInfoPreview_status_set };
static SwigPyGetSet CameraFileInfoPreview___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet CameraFileInfoPreview_fields_getset = { _wrap_CameraFileInfoPreview_fields_get, _wrap_CameraFileInfoPreview_fields_set };
static SwigPyGetSet CameraFileInfoPreview_width_getset = { _wrap_CameraFileInfoPreview_width_get, _wrap_CameraFileInfoPreview_width_set };
static SwigPyGetSet CameraFileInfoPreview_height_getset = { _wrap_CameraFileInfoPreview_height_get, _wrap_CameraFileInfoPreview_height_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin___CameraFileInfoPreview_getset[] = {
{ (char *)"type", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"type", &CameraFileInfoPreview_type_getset },
{ (char *)"size", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"size", &CameraFileInfoPreview_size_getset },
{ (char *)"status", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"status", &CameraFileInfoPreview_status_getset },
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"fields", &CameraFileInfoPreview___dict___getset },
{ (char *)"fields", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"fields", &CameraFileInfoPreview_fields_getset },
{ (char *)"width", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"width", &CameraFileInfoPreview_width_getset },
{ (char *)"height", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"height", &CameraFileInfoPreview_height_getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___CameraFileInfoPreview_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___CameraFileInfoPreview_methods[] = {
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___CameraFileInfoPreview_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.filesys.CameraFileInfoPreview", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CameraFileInfoPreview_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___CameraFileInfoPreview_type.as_number, /* tp_as_number */
&SwigPyBuiltin___CameraFileInfoPreview_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___CameraFileInfoPreview_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___CameraFileInfoPreview_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"\n"
"File information of a preview file. \n"
"\n"
"Contains information of a preview file with fields being set depending\n"
"on the bitmask in the fields member. \n"
"\n"
"C++ includes: gphoto2-filesys.h\n"
"",/* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___CameraFileInfoPreview_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___CameraFileInfoPreview_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___CameraFileInfoPreview_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
SwigPyBuiltin_BadInit, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___CameraFileInfoPreview_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___CameraFileInfoPreview_type};
static SwigPyGetSet CameraFileInfoAudio_type_getset = { _wrap_CameraFileInfoAudio_type_get, _wrap_CameraFileInfoAudio_type_set };
static SwigPyGetSet CameraFileInfoAudio_size_getset = { _wrap_CameraFileInfoAudio_size_get, _wrap_CameraFileInfoAudio_size_set };
static SwigPyGetSet CameraFileInfoAudio_status_getset = { _wrap_CameraFileInfoAudio_status_get, _wrap_CameraFileInfoAudio_status_set };
static SwigPyGetSet CameraFileInfoAudio___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet CameraFileInfoAudio_fields_getset = { _wrap_CameraFileInfoAudio_fields_get, _wrap_CameraFileInfoAudio_fields_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin___CameraFileInfoAudio_getset[] = {
{ (char *)"type", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"type", &CameraFileInfoAudio_type_getset },
{ (char *)"size", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"size", &CameraFileInfoAudio_size_getset },
{ (char *)"status", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"status", &CameraFileInfoAudio_status_getset },
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"fields", &CameraFileInfoAudio___dict___getset },
{ (char *)"fields", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, (char *)"fields", &CameraFileInfoAudio_fields_getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___CameraFileInfoAudio_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___CameraFileInfoAudio_methods[] = {
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___CameraFileInfoAudio_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.filesys.CameraFileInfoAudio", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CameraFileInfoAudio_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___CameraFileInfoAudio_type.as_number, /* tp_as_number */
&SwigPyBuiltin___CameraFileInfoAudio_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___CameraFileInfoAudio_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___CameraFileInfoAudio_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"\n"
"File information of an audio file. \n"
"\n"
"Contains information of an audio file with fields being set depending on\n"
"the bitmask in the fields member. \n"
"\n"
"C++ includes: gphoto2-filesys.h\n"
"",/* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___CameraFileInfoAudio_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___CameraFileInfoAudio_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___CameraFileInfoAudio_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
SwigPyBuiltin_BadInit, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___CameraFileInfoAudio_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___CameraFileInfoAudio_type};
static SwigPyGetSet CameraFileInfo_file_getset = { _wrap_CameraFileInfo_file_get, 0 };
static SwigPyGetSet CameraFileInfo_audio_getset = { _wrap_CameraFileInfo_audio_get, 0 };
static SwigPyGetSet CameraFileInfo_preview_getset = { _wrap_CameraFileInfo_preview_get, 0 };
static SwigPyGetSet CameraFileInfo___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin___CameraFileInfo_getset[] = {
{ (char *)"file", SwigPyBuiltin_GetterClosure, 0, (char *)"file", &CameraFileInfo_file_getset },
{ (char *)"audio", SwigPyBuiltin_GetterClosure, 0, (char *)"audio", &CameraFileInfo_audio_getset },
{ (char *)"preview", SwigPyBuiltin_GetterClosure, 0, (char *)"preview", &CameraFileInfo_preview_getset },
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"preview", &CameraFileInfo___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___CameraFileInfo_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___CameraFileInfo_methods[] = {
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___CameraFileInfo_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.filesys.CameraFileInfo", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CameraFileInfo_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___CameraFileInfo_type.as_number, /* tp_as_number */
&SwigPyBuiltin___CameraFileInfo_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___CameraFileInfo_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___CameraFileInfo_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"\n"
"File information structure. \n"
"\n"
"Contains the normal, preview and audio file information structures for a\n"
"specific file. \n"
"\n"
"C++ includes: gphoto2-filesys.h\n"
"",/* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___CameraFileInfo_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___CameraFileInfo_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___CameraFileInfo_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
_wrap_new_CameraFileInfo, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___CameraFileInfo_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___CameraFileInfo_type};
static SwigPyGetSet CameraStorageInformation_type_getset = { _wrap_CameraStorageInformation_type_get, 0 };
static SwigPyGetSet CameraStorageInformation_basedir_getset = { _wrap_CameraStorageInformation_basedir_get, 0 };
static SwigPyGetSet CameraStorageInformation_fstype_getset = { _wrap_CameraStorageInformation_fstype_get, 0 };
static SwigPyGetSet CameraStorageInformation_capacitykbytes_getset = { _wrap_CameraStorageInformation_capacitykbytes_get, 0 };
static SwigPyGetSet CameraStorageInformation_freekbytes_getset = { _wrap_CameraStorageInformation_freekbytes_get, 0 };
static SwigPyGetSet CameraStorageInformation___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet CameraStorageInformation_fields_getset = { _wrap_CameraStorageInformation_fields_get, 0 };
static SwigPyGetSet CameraStorageInformation_label_getset = { _wrap_CameraStorageInformation_label_get, 0 };
static SwigPyGetSet CameraStorageInformation_description_getset = { _wrap_CameraStorageInformation_description_get, 0 };
static SwigPyGetSet CameraStorageInformation_freeimages_getset = { _wrap_CameraStorageInformation_freeimages_get, 0 };
static SwigPyGetSet CameraStorageInformation_access_getset = { _wrap_CameraStorageInformation_access_get, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin___CameraStorageInformation_getset[] = {
{ (char *)"type", SwigPyBuiltin_GetterClosure, 0, (char *)"type", &CameraStorageInformation_type_getset },
{ (char *)"basedir", SwigPyBuiltin_GetterClosure, 0, (char *)"basedir", &CameraStorageInformation_basedir_getset },
{ (char *)"fstype", SwigPyBuiltin_GetterClosure, 0, (char *)"fstype", &CameraStorageInformation_fstype_getset },
{ (char *)"capacitykbytes", SwigPyBuiltin_GetterClosure, 0, (char *)"capacitykbytes", &CameraStorageInformation_capacitykbytes_getset },
{ (char *)"freekbytes", SwigPyBuiltin_GetterClosure, 0, (char *)"freekbytes", &CameraStorageInformation_freekbytes_getset },
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"fields", &CameraStorageInformation___dict___getset },
{ (char *)"fields", SwigPyBuiltin_GetterClosure, 0, (char *)"fields", &CameraStorageInformation_fields_getset },
{ (char *)"label", SwigPyBuiltin_GetterClosure, 0, (char *)"label", &CameraStorageInformation_label_getset },
{ (char *)"description", SwigPyBuiltin_GetterClosure, 0, (char *)"description", &CameraStorageInformation_description_getset },
{ (char *)"freeimages", SwigPyBuiltin_GetterClosure, 0, (char *)"freeimages", &CameraStorageInformation_freeimages_getset },
{ (char *)"access", SwigPyBuiltin_GetterClosure, 0, (char *)"access", &CameraStorageInformation_access_getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___CameraStorageInformation_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___CameraStorageInformation_methods[] = {
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___CameraStorageInformation_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.filesys.CameraStorageInformation", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CameraStorageInformation_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___CameraStorageInformation_type.as_number, /* tp_as_number */
&SwigPyBuiltin___CameraStorageInformation_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___CameraStorageInformation_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___CameraStorageInformation_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"\n"
"Storage information structue. \n"
"\n"
"This structure contains the information of a specific camera storage.\n"
"Only the members as specified by the *fields* member are valid. \n"
"\n"
"C++ includes: gphoto2-filesys.h\n"
"",/* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___CameraStorageInformation_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___CameraStorageInformation_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___CameraStorageInformation_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
SwigPyBuiltin_BadInit, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___CameraStorageInformation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___CameraStorageInformation_type};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_CameraFileAccessType = {"_p_CameraFileAccessType", "CameraFileAccessType *|enum CameraFileAccessType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFileInfoFields = {"_p_CameraFileInfoFields", "CameraFileInfoFields *|enum CameraFileInfoFields *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFilePermissions = {"_p_CameraFilePermissions", "CameraFilePermissions *|enum CameraFilePermissions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFileStatus = {"_p_CameraFileStatus", "CameraFileStatus *|enum CameraFileStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraFileType = {"_p_CameraFileType", "CameraFileType *|enum CameraFileType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraStorageAccessType = {"_p_CameraStorageAccessType", "CameraStorageAccessType *|enum CameraStorageAccessType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraStorageFilesystemType = {"_p_CameraStorageFilesystemType", "CameraStorageFilesystemType *|enum CameraStorageFilesystemType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraStorageInfoFields = {"_p_CameraStorageInfoFields", "CameraStorageInfoFields *|enum CameraStorageInfoFields *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraStorageType = {"_p_CameraStorageType", "CameraStorageType *|enum CameraStorageType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwigPyObject = {"_p_SwigPyObject", "SwigPyObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraFile = {"_p__CameraFile", "CameraFile *|struct _CameraFile *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraFileHandler = {"_p__CameraFileHandler", "CameraFileHandler *|struct _CameraFileHandler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraFileInfo = {"_p__CameraFileInfo", "CameraFileInfo *|struct _CameraFileInfo *|_CameraFileInfo *", 0, 0, (void*)&SwigPyBuiltin___CameraFileInfo_clientdata, 0};
static swig_type_info _swigt__p__CameraFileInfoAudio = {"_p__CameraFileInfoAudio", "CameraFileInfoAudio *|struct _CameraFileInfoAudio *|_CameraFileInfoAudio *", 0, 0, (void*)&SwigPyBuiltin___CameraFileInfoAudio_clientdata, 0};
static swig_type_info _swigt__p__CameraFileInfoFile = {"_p__CameraFileInfoFile", "CameraFileInfoFile *|struct _CameraFileInfoFile *|_CameraFileInfoFile *", 0, 0, (void*)&SwigPyBuiltin___CameraFileInfoFile_clientdata, 0};
static swig_type_info _swigt__p__CameraFileInfoPreview = {"_p__CameraFileInfoPreview", "CameraFileInfoPreview *|struct _CameraFileInfoPreview *|_CameraFileInfoPreview *", 0, 0, (void*)&SwigPyBuiltin___CameraFileInfoPreview_clientdata, 0};
static swig_type_info _swigt__p__CameraStorageInformation = {"_p__CameraStorageInformation", "CameraStorageInformation *|struct _CameraStorageInformation *|_CameraStorageInformation *", 0, 0, (void*)&SwigPyBuiltin___CameraStorageInformation_clientdata, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int32_t *|int_fast16_t *|int_fast32_t *|int_least32_t *|intptr_t *|int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long = {"_p_long", "time_t *|long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "int64_t *|int_fast64_t *|int_least64_t *|intmax_t *|long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "int16_t *|int_least16_t *|short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "int8_t *|int_fast8_t *|int_least8_t *|signed char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "uint8_t *|uint_fast8_t *|uint_least8_t *|unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uint32_t *|uint_fast16_t *|uint_fast32_t *|uint_least32_t *|uintptr_t *|unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint64_t *|uint_fast64_t *|uint_least64_t *|uintmax_t *|unsigned long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "uint16_t *|uint_least16_t *|unsigned short *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_CameraFileAccessType,
&_swigt__p_CameraFileInfoFields,
&_swigt__p_CameraFilePermissions,
&_swigt__p_CameraFileStatus,
&_swigt__p_CameraFileType,
&_swigt__p_CameraStorageAccessType,
&_swigt__p_CameraStorageFilesystemType,
&_swigt__p_CameraStorageInfoFields,
&_swigt__p_CameraStorageType,
&_swigt__p_SwigPyObject,
&_swigt__p__CameraFile,
&_swigt__p__CameraFileHandler,
&_swigt__p__CameraFileInfo,
&_swigt__p__CameraFileInfoAudio,
&_swigt__p__CameraFileInfoFile,
&_swigt__p__CameraFileInfoPreview,
&_swigt__p__CameraStorageInformation,
&_swigt__p_char,
&_swigt__p_int,
&_swigt__p_long,
&_swigt__p_long_long,
&_swigt__p_short,
&_swigt__p_signed_char,
&_swigt__p_unsigned_char,
&_swigt__p_unsigned_int,
&_swigt__p_unsigned_long_long,
&_swigt__p_unsigned_short,
};
static swig_cast_info _swigc__p_CameraFileAccessType[] = { {&_swigt__p_CameraFileAccessType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFileInfoFields[] = { {&_swigt__p_CameraFileInfoFields, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFilePermissions[] = { {&_swigt__p_CameraFilePermissions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFileStatus[] = { {&_swigt__p_CameraFileStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraFileType[] = { {&_swigt__p_CameraFileType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraStorageAccessType[] = { {&_swigt__p_CameraStorageAccessType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraStorageFilesystemType[] = { {&_swigt__p_CameraStorageFilesystemType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraStorageInfoFields[] = { {&_swigt__p_CameraStorageInfoFields, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraStorageType[] = { {&_swigt__p_CameraStorageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwigPyObject[] = { {&_swigt__p_SwigPyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFile[] = { {&_swigt__p__CameraFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFileHandler[] = { {&_swigt__p__CameraFileHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFileInfo[] = { {&_swigt__p__CameraFileInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFileInfoAudio[] = { {&_swigt__p__CameraFileInfoAudio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFileInfoFile[] = { {&_swigt__p__CameraFileInfoFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraFileInfoPreview[] = { {&_swigt__p__CameraFileInfoPreview, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraStorageInformation[] = { {&_swigt__p__CameraStorageInformation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_CameraFileAccessType,
_swigc__p_CameraFileInfoFields,
_swigc__p_CameraFilePermissions,
_swigc__p_CameraFileStatus,
_swigc__p_CameraFileType,
_swigc__p_CameraStorageAccessType,
_swigc__p_CameraStorageFilesystemType,
_swigc__p_CameraStorageInfoFields,
_swigc__p_CameraStorageType,
_swigc__p_SwigPyObject,
_swigc__p__CameraFile,
_swigc__p__CameraFileHandler,
_swigc__p__CameraFileInfo,
_swigc__p__CameraFileInfoAudio,
_swigc__p__CameraFileInfoFile,
_swigc__p__CameraFileInfoPreview,
_swigc__p__CameraStorageInformation,
_swigc__p_char,
_swigc__p_int,
_swigc__p_long,
_swigc__p_long_long,
_swigc__p_short,
_swigc__p_signed_char,
_swigc__p_unsigned_char,
_swigc__p_unsigned_int,
_swigc__p_unsigned_long_long,
_swigc__p_unsigned_short,
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};
#ifdef __cplusplus
}
#endif
static PyTypeObject *builtin_bases[2];
/* -----------------------------------------------------------------------------
* Type initialization:
* This problem is tough by the requirement that no dynamic
* memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
* to swig_type_info structures, we need some lookup code at initialization.
* The idea is that swig generates all the structures that are needed.
* The runtime then collects these partially filled structures.
* The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
* The generated swig_type_info structures are assigned statically to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
* cast linked list. The cast data is initially stored in something like a
* two-dimensional array. Each row corresponds to a type (there are the same
* number of rows as there are in the swig_type_initial array). Each entry in
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
* we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
* First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
* 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
* swig_cast_info to the linked list (because the cast->type) pointer will
* be correct.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif
#if 0
#define SWIGRUNTIME_DEBUG
#endif
#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif
SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
size_t i;
swig_module_info *module_head, *iter;
int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* Initialize the swig_module */
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
init = 1;
} else {
init = 0;
}
/* Try and load any already created modules */
module_head = SWIG_GetModule(clientdata);
if (!module_head) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
iter=module_head;
do {
if (iter==&swig_module) {
/* Our module is already in the list, so there's nothing more to do. */
return;
}
iter=iter->next;
} while (iter!= module_head);
/* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpreters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
if (init == 0) return;
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
if (swig_module.next != &swig_module) {
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
}
if (type) {
/* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
if (swig_module.type_initial[i]->clientdata) {
type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
}
} else {
type = swig_module.type_initial[i];
}
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
if (swig_module.next != &swig_module) {
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
}
if (ret) {
if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
cast->type = ret;
ret = 0;
} else {
/* Check for casting already in the list */
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
if (!ocast) ret = 0;
}
}
if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
if (type->cast) {
type->cast->prev = cast;
cast->next = type->cast;
}
type->cast = cast;
}
cast++;
}
/* Set entry in modules->types array equal to the type */
swig_module.types[i] = type;
}
swig_module.types[i] = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("**** SWIG_InitializeModule: Cast List ******\n");
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
++j;
}
printf("---- Total casts: %d\n",j);
}
printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}
/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types. It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
size_t i;
swig_cast_info *equiv;
static int init_run = 0;
if (init_run) return;
init_run = 1;
for (i = 0; i < swig_module.size; i++) {
if (swig_module.types[i]->clientdata) {
equiv = swig_module.types[i]->cast;
while (equiv) {
if (!equiv->converter) {
if (equiv->type && !equiv->type->clientdata)
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
}
equiv = equiv->next;
}
}
}
}
#ifdef __cplusplus
#if 0
{
/* c-mode */
#endif
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* constants/methods manipulation
* ----------------------------------------------------------------------------- */
/* Install Constants */
SWIGINTERN void
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
PyObject *obj = 0;
size_t i;
for (i = 0; constants[i].type; ++i) {
switch(constants[i].type) {
case SWIG_PY_POINTER:
obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_PY_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
break;
default:
obj = 0;
break;
}
if (obj) {
PyDict_SetItemString(d, constants[i].name, obj);
Py_DECREF(obj);
}
}
}
/* -----------------------------------------------------------------------------
* Patch %callback methods' docstrings to hold the callback ptrs
* -----------------------------------------------------------------------------*/
SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
size_t i;
for (i = 0; methods[i].ml_name; ++i) {
const char *c = methods[i].ml_doc;
if (!c) continue;
c = strstr(c, "swig_ptr: ");
if (c) {
int j;
const swig_const_info *ci = 0;
const char *name = c + 10;
for (j = 0; const_table[j].type; ++j) {
if (strncmp(const_table[j].name, name,
strlen(const_table[j].name)) == 0) {
ci = &(const_table[j]);
break;
}
}
if (ci) {
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
if (ptr) {
size_t shift = (ci->ptype) - types;
swig_type_info *ty = types_initial[shift];
size_t ldoc = (c - methods[i].ml_doc);
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
char *ndoc = (char*)malloc(ldoc + lptr + 10);
if (ndoc) {
char *buff = ndoc;
memcpy(buff, methods[i].ml_doc, ldoc);
buff += ldoc;
memcpy(buff, "swig_ptr: ", 10);
buff += 10;
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
methods[i].ml_doc = ndoc;
}
}
}
}
}
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------*
* Partial Init method
* -----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
PyObject *m, *d, *md, *globals;
#if PY_VERSION_HEX >= 0x03000000
static struct PyModuleDef SWIG_module = {
PyModuleDef_HEAD_INIT,
SWIG_name,
NULL,
-1,
SwigMethods,
NULL,
NULL,
NULL,
NULL
};
#endif
#if defined(SWIGPYTHON_BUILTIN)
static SwigPyClientData SwigPyObject_clientdata = {
0, 0, 0, 0, 0, 0, 0
};
static PyGetSetDef this_getset_def = {
(char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
};
static SwigPyGetSet thisown_getset_closure = {
SwigPyObject_own,
SwigPyObject_own
};
static PyGetSetDef thisown_getset_def = {
(char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
};
PyTypeObject *builtin_pytype;
int builtin_base_count;
swig_type_info *builtin_basetype;
PyObject *tuple;
PyGetSetDescrObject *static_getset;
PyTypeObject *metatype;
PyTypeObject *swigpyobject;
SwigPyClientData *cd;
PyObject *public_interface, *public_symbol;
PyObject *this_descr;
PyObject *thisown_descr;
PyObject *self = 0;
int i;
(void)builtin_pytype;
(void)builtin_base_count;
(void)builtin_basetype;
(void)tuple;
(void)static_getset;
(void)self;
/* Metaclass is used to implement static member variables */
metatype = SwigPyObjectType();
assert(metatype);
#endif
(void)globals;
/* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
SWIG_This();
SWIG_Python_TypeCache();
SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
SwigPyObject_type();
#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
#if PY_VERSION_HEX >= 0x03000000
m = PyModule_Create(&SWIG_module);
#else
m = Py_InitModule(SWIG_name, SwigMethods);
#endif
md = d = PyModule_GetDict(m);
(void)md;
SWIG_InitializeModule(0);
#ifdef SWIGPYTHON_BUILTIN
swigpyobject = SwigPyObject_TypeOnce();
SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
if (!cd) {
SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
SwigPyObject_clientdata.pytype = swigpyobject;
} else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
return NULL;
# else
return;
# endif
}
/* All objects have a 'this' attribute */
this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
(void)this_descr;
/* All objects have a 'thisown' attribute */
thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
(void)thisown_descr;
public_interface = PyList_New(0);
public_symbol = 0;
(void)public_symbol;
PyDict_SetItemString(md, "__all__", public_interface);
Py_DECREF(public_interface);
for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
for (i = 0; swig_const_table[i].name != 0; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
SWIG_InstallConstants(d,swig_const_table);
{
PyObject *module = PyImport_ImportModule("gphoto2");
if (module != NULL) {
PyExc_GPhoto2Error = PyObject_GetAttrString(module, "GPhoto2Error");
Py_DECREF(module);
}
if (PyExc_GPhoto2Error == NULL)
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_INFO_NONE",SWIG_From_int((int)(GP_FILE_INFO_NONE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_INFO_TYPE",SWIG_From_int((int)(GP_FILE_INFO_TYPE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_INFO_SIZE",SWIG_From_int((int)(GP_FILE_INFO_SIZE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_INFO_WIDTH",SWIG_From_int((int)(GP_FILE_INFO_WIDTH)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_INFO_HEIGHT",SWIG_From_int((int)(GP_FILE_INFO_HEIGHT)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_INFO_PERMISSIONS",SWIG_From_int((int)(GP_FILE_INFO_PERMISSIONS)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_INFO_STATUS",SWIG_From_int((int)(GP_FILE_INFO_STATUS)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_INFO_MTIME",SWIG_From_int((int)(GP_FILE_INFO_MTIME)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_INFO_ALL",SWIG_From_int((int)(GP_FILE_INFO_ALL)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_PERM_NONE",SWIG_From_int((int)(GP_FILE_PERM_NONE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_PERM_READ",SWIG_From_int((int)(GP_FILE_PERM_READ)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_PERM_DELETE",SWIG_From_int((int)(GP_FILE_PERM_DELETE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_PERM_ALL",SWIG_From_int((int)(GP_FILE_PERM_ALL)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_STATUS_NOT_DOWNLOADED",SWIG_From_int((int)(GP_FILE_STATUS_NOT_DOWNLOADED)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_FILE_STATUS_DOWNLOADED",SWIG_From_int((int)(GP_FILE_STATUS_DOWNLOADED)));
/* type '::_CameraFileInfoFile' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___CameraFileInfoFile_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraFileInfoFile'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CameraFileInfoFile", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraFileInfoFile");
d = md;
/* type '::_CameraFileInfoPreview' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___CameraFileInfoPreview_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraFileInfoPreview'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CameraFileInfoPreview", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraFileInfoPreview");
d = md;
/* type '::_CameraFileInfoAudio' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___CameraFileInfoAudio_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraFileInfoAudio'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CameraFileInfoAudio", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraFileInfoAudio");
d = md;
/* type '::_CameraFileInfo' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___CameraFileInfo_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraFileInfo'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CameraFileInfo", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraFileInfo");
d = md;
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_BASE",SWIG_From_int((int)(GP_STORAGEINFO_BASE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_LABEL",SWIG_From_int((int)(GP_STORAGEINFO_LABEL)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_DESCRIPTION",SWIG_From_int((int)(GP_STORAGEINFO_DESCRIPTION)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_ACCESS",SWIG_From_int((int)(GP_STORAGEINFO_ACCESS)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_STORAGETYPE",SWIG_From_int((int)(GP_STORAGEINFO_STORAGETYPE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_FILESYSTEMTYPE",SWIG_From_int((int)(GP_STORAGEINFO_FILESYSTEMTYPE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_MAXCAPACITY",SWIG_From_int((int)(GP_STORAGEINFO_MAXCAPACITY)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_FREESPACEKBYTES",SWIG_From_int((int)(GP_STORAGEINFO_FREESPACEKBYTES)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_FREESPACEIMAGES",SWIG_From_int((int)(GP_STORAGEINFO_FREESPACEIMAGES)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_ST_UNKNOWN",SWIG_From_int((int)(GP_STORAGEINFO_ST_UNKNOWN)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_ST_FIXED_ROM",SWIG_From_int((int)(GP_STORAGEINFO_ST_FIXED_ROM)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_ST_REMOVABLE_ROM",SWIG_From_int((int)(GP_STORAGEINFO_ST_REMOVABLE_ROM)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_ST_FIXED_RAM",SWIG_From_int((int)(GP_STORAGEINFO_ST_FIXED_RAM)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_ST_REMOVABLE_RAM",SWIG_From_int((int)(GP_STORAGEINFO_ST_REMOVABLE_RAM)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_AC_READWRITE",SWIG_From_int((int)(GP_STORAGEINFO_AC_READWRITE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_AC_READONLY",SWIG_From_int((int)(GP_STORAGEINFO_AC_READONLY)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_AC_READONLY_WITH_DELETE",SWIG_From_int((int)(GP_STORAGEINFO_AC_READONLY_WITH_DELETE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_FST_UNDEFINED",SWIG_From_int((int)(GP_STORAGEINFO_FST_UNDEFINED)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_FST_GENERICFLAT",SWIG_From_int((int)(GP_STORAGEINFO_FST_GENERICFLAT)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_FST_GENERICHIERARCHICAL",SWIG_From_int((int)(GP_STORAGEINFO_FST_GENERICHIERARCHICAL)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_STORAGEINFO_FST_DCF",SWIG_From_int((int)(GP_STORAGEINFO_FST_DCF)));
/* type '::_CameraStorageInformation' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___CameraStorageInformation_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraStorageInformation'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CameraStorageInformation", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraStorageInformation");
d = md;
#if PY_VERSION_HEX >= 0x03000000
return m;
#else
return;
#endif
}
python-gphoto2-2.5.1/src/swig-gp2_5_31/list.py 0000664 0000000 0000000 00000000636 14703210004 0020716 0 ustar 00root root 0000000 0000000 # This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
# Pull in all the attributes from the low-level C/C++ module
if __package__ or "." in __name__:
from ._list import *
else:
from _list import *
python-gphoto2-2.5.1/src/swig-gp2_5_31/list_wrap.c 0000664 0000000 0000000 00000665601 14703210004 0021552 0 ustar 00root root 0000000 0000000 /* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (https://www.swig.org).
* Version 4.1.1
*
* Do not make changes to this file unless you know what you are doing - modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
#define SWIG_VERSION 0x040101
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_BUILTIN
#define SWIGPYTHON_FASTPROXY
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if defined(__GNUC__)
# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
/* Intel's compiler complains if a variable which was never initialised is
* cast to void, which is a common idiom which we use to indicate that we
* are aware a variable isn't used. So we just silence that warning.
* See: https://github.com/swig/swig/issues/192 for more discussion.
*/
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include
#endif
#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
* See https://github.com/swig/swig/issues/2090 */
# include
#endif
# undef _DEBUG
# include
# define _DEBUG 1
#else
# include
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
creating a static or dynamic library from the SWIG runtime code.
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
But only do this if strictly necessary, ie, if you have problems
with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif
#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif
/* Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
#define SWIG_POINTER_NO_NULL 0x4
#define SWIG_POINTER_CLEAR 0x8
#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
if (SWIG_IsOK(res)) {
// success code
if (SWIG_IsNewObj(res) {
...
delete *ptr;
} else {
...
}
} else {
// fail code
}
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if () {
if () {
*ptr = ;
return SWIG_NEWOBJ;
} else {
*ptr = ;
return SWIG_OLDOBJ;
}
} else {
return SWIG_BADOBJ;
}
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows returning the 'cast rank', for example, if you have this
int food(double)
int fooi(int);
and you call
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
*/
#define SWIG_OK (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ (SWIG_ERROR)
#define SWIG_OLDOBJ (SWIG_OK)
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
# define SWIG_TypeRank unsigned long
# endif
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
# define SWIG_MAXCASTRANK (2)
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
# define SWIG_AddCast(r) (r)
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
#include
#ifdef __cplusplus
extern "C" {
#endif
typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
void *clientdata; /* language specific type data */
int owndata; /* flag if the structure owns the clientdata */
} swig_type_info;
/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
swig_type_info *type; /* pointer to type that is equivalent to this type */
swig_converter_func converter; /* function to cast the void pointers */
struct swig_cast_info *next; /* pointer to next cast in linked list */
struct swig_cast_info *prev; /* pointer to the previous cast */
} swig_cast_info;
/* Structure used to store module information
* Each module generates one structure like this, and the runtime collects
* all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
size_t size; /* Number of types in this module */
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
swig_type_info **type_initial; /* Array of initially generated type structures */
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
void *clientdata; /* Language specific module data */
} swig_module_info;
/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class" == "Class", etc.
Return 0 when the two name types are equivalent, as in
strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
const char *f2, const char *l2) {
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
while ((*f1 == ' ') && (f1 != l1)) ++f1;
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
return (int)((l1 - f1) - (l2 - f2));
}
/*
Check type equivalence in a name list like ||...
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
}
/*
Check type equivalence in a name list like ||...
Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (strcmp(iter->type->name, c) == 0) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (iter->type == from) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
swig_type_info *lastty = ty;
if (!ty || !ty->dcast) return ty;
while (ty && (ty->dcast)) {
ty = (*ty->dcast)(ptr);
if (ty) lastty = ty;
}
return lastty;
}
/*
Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
return ty->name;
}
/*
Return the pretty name associated with this type,
that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
/* The "str" field contains the equivalent pretty names of the
type, separated by vertical-bar characters. Choose the last
name. It should be the most specific; a fully resolved name
but not necessarily with default template parameters expanded. */
if (!type) return NULL;
if (type->str != NULL) {
const char *last_name = type->str;
const char *s;
for (s = type->str; *s; s++)
if (*s == '|') last_name = s+1;
return last_name;
}
else
return type->name;
}
/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
}
cast = cast->next;
}
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
size_t l = 0;
size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
r = i - 1;
} else {
break;
}
} else if (compare > 0) {
l = i + 1;
}
} else {
break; /* should never happen */
}
} while (l <= r);
}
iter = iter->next;
} while (iter != end);
return 0;
}
/*
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
if (ret) {
return ret;
} else {
/* STEP 2: If the type hasn't been found, do a complete search
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
}
iter = iter->next;
} while (iter != end);
}
/* neither found a match */
return 0;
}
/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
const unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
char d = *(c++);
unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
uu = (unsigned char)((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
uu |= (unsigned char)(d - ('a'-10));
else
return (char *) 0;
*u = uu;
}
return c;
}
/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
char *r = buff;
if ((2*sizeof(void *) + 2) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,&ptr,sizeof(void *));
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
strcpy(r,name);
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
*ptr = (void *) 0;
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sizeof(void *));
}
SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
char *r = buff;
size_t lname = (name ? strlen(name) : 0);
if ((2*sz + 2 + lname) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
if (lname) {
strncpy(r,name,lname+1);
} else {
*r = 0;
}
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
memset(ptr,0,sz);
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sz);
}
#ifdef __cplusplus
}
#endif
/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
#endif
#ifndef Py_TYPE
# define Py_TYPE(op) ((op)->ob_type)
#endif
/* SWIG APIs for compatibility of both Python 2 & 3 */
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
# define SWIG_Python_str_FromFormat PyString_FromFormat
#endif
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03030000
return (char *)PyUnicode_AsUTF8(str);
#else
return PyString_AsString(str);
#endif
}
/* Was useful for Python 3.0.x-3.2.x - now provided only for compatibility
* with any uses in user interface files. */
#define SWIG_Python_str_DelForPy3(x)
SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromString(c);
#else
return PyString_FromString(c);
#endif
}
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif
/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif
/* -----------------------------------------------------------------------------
* error manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
PyObject* type = 0;
switch(code) {
case SWIG_MemoryError:
type = PyExc_MemoryError;
break;
case SWIG_IOError:
type = PyExc_IOError;
break;
case SWIG_RuntimeError:
type = PyExc_RuntimeError;
break;
case SWIG_IndexError:
type = PyExc_IndexError;
break;
case SWIG_TypeError:
type = PyExc_TypeError;
break;
case SWIG_DivisionByZero:
type = PyExc_ZeroDivisionError;
break;
case SWIG_OverflowError:
type = PyExc_OverflowError;
break;
case SWIG_SyntaxError:
type = PyExc_SyntaxError;
break;
case SWIG_ValueError:
type = PyExc_ValueError;
break;
case SWIG_SystemError:
type = PyExc_SystemError;
break;
case SWIG_AttributeError:
type = PyExc_AttributeError;
break;
default:
type = PyExc_RuntimeError;
}
return type;
}
SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
if (PyErr_Occurred())
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
PyErr_Clear();
Py_XINCREF(type);
if (tmp)
PyErr_Format(type, "%s %s", tmp, mesg);
else
PyErr_Format(type, "%s", mesg);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
PyErr_SetString(PyExc_RuntimeError, mesg);
}
}
SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
PyObject *error;
if (obj)
return 0;
error = PyErr_Occurred();
return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}
SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
if (SWIG_Python_TypeErrorOccurred(NULL)) {
/* Use existing TypeError to preserve stacktrace and enhance with given message */
PyObject *newvalue;
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
if (newvalue) {
Py_XDECREF(value);
PyErr_Restore(type, newvalue, traceback);
} else {
PyErr_Restore(type, value, traceback);
}
} else {
/* Raise TypeError using given message */
PyErr_SetString(PyExc_TypeError, message);
}
}
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
# undef SWIG_PYTHON_THREADS
# endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
# define SWIG_PYTHON_USE_GIL
# endif
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# if PY_VERSION_HEX < 0x03070000
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
# else
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# endif
# ifdef __cplusplus /* C++ code */
class SWIG_Python_Thread_Block {
bool status;
PyGILState_STATE state;
public:
void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block() { end(); }
};
class SWIG_Python_Thread_Allow {
bool status;
PyThreadState *save;
public:
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow() { end(); }
};
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
# else /* C code */
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
# endif
# else /* Old thread way, not implemented, user must provide it */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
# define SWIG_PYTHON_THREAD_END_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# endif
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
# define SWIG_PYTHON_THREAD_END_ALLOW
# endif
# endif
#else /* No thread support */
# define SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# define SWIG_PYTHON_THREAD_END_BLOCK
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# define SWIG_PYTHON_THREAD_END_ALLOW
#endif
/* -----------------------------------------------------------------------------
* Python API portion that goes into the runtime
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* Constant declarations
* ----------------------------------------------------------------------------- */
/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY 5
/* Constant information structure */
typedef struct swig_const_info {
int type;
const char *name;
long lvalue;
double dvalue;
void *pvalue;
swig_type_info **ptype;
} swig_const_info;
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* pyrun.swg
*
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* type checking.
*
* ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif
#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#endif
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif
#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
#define SWIG_fail goto fail
/* Runtime API implementation */
/* Error manipulation */
SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetObject(errtype, obj);
Py_DECREF(obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetString(errtype, msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
/* Set a constant value */
#if defined(SWIGPYTHON_BUILTIN)
SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
PyObject *s = PyString_InternFromString(key);
PyList_Append(seq, s);
Py_DECREF(s);
}
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
if (public_interface)
SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}
#else
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
}
#endif
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyList_Check(result)) {
PyObject *o2 = result;
result = PyList_New(1);
if (result) {
PyList_SET_ITEM(result, 0, o2);
} else {
Py_DECREF(obj);
return o2;
}
}
PyList_Append(result,obj);
Py_DECREF(obj);
}
return result;
}
/* Unpack the argument tuple */
SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
if (!PyTuple_Check(args)) {
if (min <= 1 && max >= 1) {
Py_ssize_t i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
}
return 2;
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
Py_ssize_t i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
for (; l < max; ++l) {
objs[l] = 0;
}
return i + 1;
}
}
}
SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
int no_kwargs = 1;
if (kwargs) {
assert(PyDict_Check(kwargs));
if (PyDict_Size(kwargs) > 0) {
PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
no_kwargs = 0;
}
}
return no_kwargs;
}
/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
/*
Helper for static pointer initialization for both C and C++ code, for example
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var) var
#else
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Python-specific SWIG API */
#define SWIG_newvarlink() SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
/* -----------------------------------------------------------------------------
* global variable support code.
* ----------------------------------------------------------------------------- */
typedef struct swig_globalvar {
char *name; /* Name of global variable */
PyObject *(*get_attr)(void); /* Return the current value */
int (*set_attr)(PyObject *); /* Set the value */
struct swig_globalvar *next;
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar *vars;
} swig_varlinkobject;
SWIGINTERN PyObject *
swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_InternFromString("");
#else
return PyString_FromString("");
#endif
}
SWIGINTERN PyObject *
swig_varlink_str(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
PyObject *str = PyUnicode_InternFromString("(");
PyObject *tail;
PyObject *joined;
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
tail = PyUnicode_FromString(var->name);
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
if (var->next) {
tail = PyUnicode_InternFromString(", ");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
}
}
tail = PyUnicode_InternFromString(")");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
#else
PyObject *str = PyString_FromString("(");
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
return str;
}
SWIGINTERN void
swig_varlink_dealloc(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
swig_globalvar *var = v->vars;
while (var) {
swig_globalvar *n = var->next;
free(var->name);
free(var);
var = n;
}
}
SWIGINTERN PyObject *
swig_varlink_getattr(PyObject *o, char *n) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
PyObject *res = NULL;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->get_attr)();
break;
}
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN int
swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
int res = 1;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->set_attr)(p);
break;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
static char varlink__doc__[] = "Swig var link object";
static PyTypeObject varlink_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"swigvarlink", /* tp_name */
sizeof(swig_varlinkobject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) swig_varlink_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc) swig_varlink_getattr, /* tp_getattr */
(setattrfunc) swig_varlink_setattr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc) swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
varlink__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
varlink_type = tmp;
type_init = 1;
if (PyType_Ready(&varlink_type) < 0)
return NULL;
}
return &varlink_type;
}
/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
if (result) {
result->vars = 0;
}
return ((PyObject*) result);
}
SWIGINTERN void
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
memcpy(gv->name, name, size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
}
}
v->vars = gv;
}
static PyObject *Swig_Globals_global = NULL;
SWIGINTERN PyObject *
SWIG_globals(void) {
if (Swig_Globals_global == NULL) {
Swig_Globals_global = SWIG_newvarlink();
}
return Swig_Globals_global;
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* Pointer declarations
* ----------------------------------------------------------------------------- */
/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
#ifdef __cplusplus
extern "C" {
#endif
/* The python void return value */
SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)
{
PyObject *none = Py_None;
Py_INCREF(none);
return none;
}
/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
PyTypeObject *pytype;
} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
int fail = data ? data->implicitconv : 0;
if (fail)
PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
return fail;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
/* the newraw method and newargs arguments used to create a new raw instance */
if (PyClass_Check(obj)) {
data->newraw = 0;
Py_INCREF(obj);
data->newargs = obj;
} else {
data->newraw = PyObject_GetAttrString(data->klass, "__new__");
if (data->newraw) {
data->newargs = PyTuple_New(1);
if (data->newargs) {
Py_INCREF(obj);
PyTuple_SET_ITEM(data->newargs, 0, obj);
} else {
Py_DECREF(data->newraw);
Py_DECREF(data->klass);
free(data);
return 0;
}
} else {
Py_INCREF(obj);
data->newargs = obj;
}
}
/* the destroy method, aka as the C++ delete method */
data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
}
if (data->destroy) {
data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
} else {
data->delargs = 0;
}
data->implicitconv = 0;
data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData *data)
{
Py_XDECREF(data->klass);
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
free(data);
}
/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
PyObject *dict;
#endif
} SwigPyObject;
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
if (!sobj->dict)
sobj->dict = PyDict_New();
Py_XINCREF(sobj->dict);
return sobj->dict;
}
#endif
SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
PyObject *val = SwigPyObject_long(v);
if (val) {
PyObject *ofmt;
PyTuple_SET_ITEM(args, 0, val);
ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
res = PyUnicode_Format(ofmt,args);
#else
res = PyString_Format(ofmt,args);
#endif
Py_DECREF(ofmt);
}
}
Py_DECREF(args);
}
return res;
}
SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v);
if (repr && v->next) {
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
PyObject *joined = PyUnicode_Concat(repr, nrep);
Py_DecRef(repr);
Py_DecRef(nrep);
repr = joined;
# else
PyString_ConcatAndDel(&repr,nrep);
# endif
} else {
Py_DecRef(repr);
repr = NULL;
}
}
return repr;
}
/* We need a version taking two PyObject* parameters so it's a valid
* PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
return SwigPyObject_repr((SwigPyObject*)v);
}
SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
PyObject* res;
if( op != Py_EQ && op != Py_NE ) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
return res;
}
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
SwigPyClientData *cd;
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
assert(cd);
assert(cd->pytype);
return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
#endif
SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
PyTypeObject *target_tp = SwigPyObject_type();
if (PyType_IsSubtype(op->ob_type, target_tp))
return 1;
return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
return (Py_TYPE(op) == SwigPyObject_type())
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
static PyObject* Swig_Capsule_global = NULL;
SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
/* PyObject_CallFunction() has the potential to silently drop
the active exception. In cases of unnamed temporary
variable or where we just finished iterating over a generator
StopIteration will be active right now, and this needs to
remain true upon return from SwigPyObject_dealloc. So save
and restore. */
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
if (data->delargs) {
/* we need to create a temporary object to carry the destroy operation */
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
if (tmp) {
res = SWIG_Python_CallFunctor(destroy, tmp);
} else {
res = 0;
}
Py_XDECREF(tmp);
} else {
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
PyObject *mself = PyCFunction_GET_SELF(destroy);
res = ((*meth)(mself, v));
}
if (!res)
PyErr_WriteUnraisable(destroy);
PyErr_Restore(type, value, traceback);
Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
else {
const char *name = SWIG_TypePrettyName(ty);
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
#endif
Py_XDECREF(Swig_Capsule_global);
}
Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
Py_XDECREF(sobj->dict);
#endif
PyObject_DEL(v);
}
SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject* v, PyObject* next)
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (!SwigPyObject_Check(next)) {
PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
((SwigPyObject *)next)->next = sobj->next;
sobj->next = next;
Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
return NULL;
} else {
SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
if (PyObject_IsTrue(val)) {
Py_DECREF(SwigPyObject_acquire(v,args));
} else {
Py_DECREF(SwigPyObject_disown(v,args));
}
}
return obj;
}
}
static PyMethodDef
swigobject_methods[] = {
{"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
{"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
{"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
{"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
{"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
{"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
{0, 0, 0, 0}
};
SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
/* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
#endif
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
(unaryfunc)0, /*nb_negative*/
(unaryfunc)0, /*nb_positive*/
(unaryfunc)0, /*nb_absolute*/
(inquiry)0, /*nb_nonzero*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
0, /*nb_coerce*/
#endif
(unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_long, /*nb_long*/
#else
0, /*nb_reserved*/
#endif
(unaryfunc)0, /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
};
static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyObject", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
(cmpfunc)SwigPyObject_compare, /* tp_compare */
#endif
(reprfunc)SwigPyObject_repr, /* tp_repr */
&SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigobject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
(richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
swigobject_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobject_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpyobject_type) != 0)
return NULL;
}
return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
sobj->own = own;
sobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
sobj->dict = 0;
#endif
if (own == SWIG_POINTER_OWN) {
/* Obtain a reference to the Python capsule wrapping the module information, so that the
* module information is correctly destroyed after all SWIG python objects have been freed
* by the GC (and corresponding destructors invoked) */
Py_XINCREF(Swig_Capsule_global);
}
}
return (PyObject *)sobj;
}
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
void *pack;
swig_type_info *ty;
size_t size;
} SwigPyPacked;
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return SWIG_Python_str_FromFormat("", result, v->ty->name);
} else {
return SWIG_Python_str_FromFormat("", v->ty->name);
}
}
SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}
SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
return ((op)->ob_type == SwigPyPacked_TypeOnce())
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
if (SwigPyPacked_Check(v)) {
SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyPacked", /* tp_name */
sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
0, /* tp_reserved in 3.0.1 */
#else
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
#endif
(reprfunc)SwigPyPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigpacked_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpypacked_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpypacked_type) != 0)
return NULL;
}
return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
memcpy(pack, ptr, size);
sobj->pack = pack;
sobj->ty = ty;
sobj->size = size;
} else {
PyObject_DEL((PyObject *) sobj);
sobj = 0;
}
}
return (PyObject *) sobj;
}
SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (SwigPyPacked_Check(obj)) {
SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
} else {
return 0;
}
}
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
static PyObject *Swig_This_global = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
if (Swig_This_global == NULL)
Swig_This_global = SWIG_Python_str_FromChar("this");
return Swig_This_global;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS
#endif
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
PyObject *obj;
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
#ifdef SWIGPYTHON_BUILTIN
(void)obj;
# ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
pyobj = PyWeakref_GET_OBJECT(pyobj);
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
# endif
return NULL;
#else
obj = 0;
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
}
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
#endif
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
return oldown;
}
}
return 0;
}
/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
int res;
SwigPyObject *sobj;
int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
if (!obj)
return SWIG_ERROR;
if (obj == Py_None && !implicit_conv) {
if (ptr)
*ptr = 0;
return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
}
res = SWIG_ERROR;
sobj = SWIG_Python_GetSwigThis(obj);
if (own)
*own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
swig_type_info *to = sobj->ty;
if (to == ty) {
/* no type cast needed */
if (ptr) *ptr = vptr;
break;
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
sobj = (SwigPyObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
if (own)
*own = *own | SWIG_CAST_NEW_MEMORY;
}
}
break;
}
}
} else {
if (ptr) *ptr = vptr;
break;
}
}
if (sobj) {
if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
res = SWIG_ERROR_RELEASE_NOT_OWNED;
} else {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
if (flags & SWIG_POINTER_CLEAR) {
sobj->ptr = 0;
}
res = SWIG_OK;
}
} else {
if (implicit_conv) {
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
PyObject *impconv;
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
impconv = SWIG_Python_CallFunctor(klass, obj);
data->implicitconv = 0;
if (PyErr_Occurred()) {
PyErr_Clear();
impconv = 0;
}
if (impconv) {
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
if (SWIG_IsOK(res)) {
if (ptr) {
*ptr = vptr;
/* transfer the ownership to 'ptr' */
iobj->own = 0;
res = SWIG_AddCast(res);
res = SWIG_AddNewMask(res);
} else {
res = SWIG_AddCast(res);
}
}
}
Py_DECREF(impconv);
}
}
}
if (!SWIG_IsOK(res) && obj == Py_None) {
if (ptr)
*ptr = 0;
if (PyErr_Occurred())
PyErr_Clear();
res = SWIG_OK;
}
}
}
return res;
}
/* Convert a function ptr value */
SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
if (!PyCFunction_Check(obj)) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
swig_cast_info *tc;
/* here we get the method pointer for callbacks */
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
if (!desc)
return SWIG_ERROR;
tc = SWIG_TypeCheck(desc,ty);
if (tc) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
} else {
return SWIG_ERROR;
}
return SWIG_OK;
}
}
/* Convert a packed pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
/* check type cast? */
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* -----------------------------------------------------------------------------
* Create a new pointer object
* ----------------------------------------------------------------------------- */
/*
Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
inst = PyObject_Call(newraw, data->newargs, NULL);
if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
Py_DECREF(inst);
inst = 0;
}
}
#else
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
}
#endif
}
} else {
#if PY_VERSION_HEX >= 0x03000000
PyObject *empty_args = PyTuple_New(0);
if (empty_args) {
PyObject *empty_kwargs = PyDict_New();
if (empty_kwargs) {
inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
Py_DECREF(empty_kwargs);
if (inst) {
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
} else {
PyType_Modified(Py_TYPE(inst));
}
}
}
Py_DECREF(empty_args);
}
#else
PyObject *dict = PyDict_New();
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
}
#endif
}
return inst;
}
SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
return PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
return -1;
}
}
#endif
return PyObject_SetAttr(inst, SWIG_This(), swig_this);
}
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
return NULL;
} else {
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
} else {
if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
return NULL;
}
return SWIG_Py_Void();
}
}
/* Create a new pointer object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
SwigPyClientData *clientdata;
PyObject * robj;
int own;
if (!ptr)
return SWIG_Py_Void();
clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
if (clientdata && clientdata->pytype) {
SwigPyObject *newobj;
if (flags & SWIG_BUILTIN_TP_INIT) {
newobj = (SwigPyObject*) self;
if (newobj->ptr) {
PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
while (newobj->next)
newobj = (SwigPyObject *) newobj->next;
newobj->next = next_self;
newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
newobj->dict = 0;
#endif
}
} else {
newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
if (newobj) {
newobj->dict = 0;
}
#endif
}
if (newobj) {
newobj->ptr = ptr;
newobj->ty = type;
newobj->own = own;
newobj->next = 0;
return (PyObject*) newobj;
}
return SWIG_Py_Void();
}
assert(!(flags & SWIG_BUILTIN_TP_INIT));
robj = SwigPyObject_New(ptr, type, own);
if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
Py_DECREF(robj);
robj = inst;
}
return robj;
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
* Get type list
* -----------------------------------------------------------------------------*/
#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif
static PyObject *Swig_TypeCache_global = NULL;
/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
if (Swig_TypeCache_global == NULL) {
Swig_TypeCache_global = PyDict_New();
}
return Swig_TypeCache_global;
}
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
}
#else
void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
}
#endif
return (swig_module_info *) type_pointer;
}
static int interpreter_counter = 0; // how many (sub-)interpreters are using swig_module's types
SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
swig_type_info **types = swig_module->types;
size_t i;
if (--interpreter_counter != 0) // another sub-interpreter may still be using the swig_module's types
return;
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
ty->clientdata = 0;
if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
Swig_This_global = NULL;
Py_DECREF(SWIG_globals());
Swig_Globals_global = NULL;
Py_DECREF(SWIG_Python_TypeCache());
Swig_TypeCache_global = NULL;
Swig_Capsule_global = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
/* Add a dummy module object into sys.modules */
PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && module) {
if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
++interpreter_counter;
Swig_Capsule_global = pointer;
} else {
Py_DECREF(pointer);
}
} else {
Py_XDECREF(pointer);
}
}
SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
PyObject *key = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
} else {
swig_module_info *swig_module = SWIG_GetModule(0);
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
obj = PyCapsule_New((void*) descriptor, NULL, NULL);
if (obj) {
PyDict_SetItem(cache, key, obj);
Py_DECREF(obj);
}
}
}
Py_DECREF(key);
return descriptor;
}
/*
For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION 0
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
const char *errmesg = tmp ? tmp : "Invalid error message";
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, errmesg);
} else {
PyErr_Format(type, "%s %s", errmesg, mesg);
}
Py_DECREF(old_str);
}
return 1;
} else {
return 0;
}
}
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
if (PyErr_Occurred()) {
/* add information about failing argument */
char mesg[256];
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
} else {
return 0;
}
}
SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : "";
}
SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
if (obj && SwigPyObject_Check(obj)) {
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
type, otype);
return;
}
} else
#endif
{
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
}
Py_XDECREF(str);
return;
}
}
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
} else {
PyErr_Format(PyExc_TypeError, "unexpected type is received");
}
}
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
}
return result;
}
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
PyTypeObject *tp = obj->ob_type;
PyObject *descr;
PyObject *encoded_name;
descrsetfunc f;
int res = -1;
# ifdef Py_USING_UNICODE
if (PyString_Check(name)) {
name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
if (!name)
return -1;
} else if (!PyUnicode_Check(name))
# else
if (!PyString_Check(name))
# endif
{
PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
return -1;
} else {
Py_INCREF(name);
}
if (!tp->tp_dict) {
if (PyType_Ready(tp) != 0)
goto done;
}
descr = _PyType_Lookup(tp, name);
f = NULL;
if (descr != NULL)
f = descr->ob_type->tp_descr_set;
if (!f) {
if (PyString_Check(name)) {
encoded_name = name;
Py_INCREF(name);
} else {
encoded_name = PyUnicode_AsUTF8String(name);
if (!encoded_name)
goto done;
}
PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
Py_DECREF(encoded_name);
} else {
res = f(descr, obj, value);
}
done:
Py_DECREF(name);
return res;
}
#endif
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN Py_hash_t
SwigPyObject_hash(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
void *ptr = sobj->ptr;
#if PY_VERSION_HEX < 0x03020000
return (Py_hash_t)(Py_ssize_t)ptr;
#else
return (Py_hash_t)ptr;
#endif
}
SWIGINTERN Py_hash_t
SWIG_PyNumber_AsPyHash(PyObject *obj) {
Py_hash_t result = -1;
#if PY_VERSION_HEX < 0x03020000
if (PyInt_Check(obj))
result = PyInt_AsLong(obj);
else if (PyLong_Check(obj))
result = PyLong_AsLong(obj);
#else
if (PyNumber_Check(obj))
result = PyNumber_AsSsize_t(obj, NULL);
#endif
else
PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
return PyErr_Occurred() ? -1 : result;
}
SWIGINTERN int
SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
return -1;
}
SWIGINTERN void
SwigPyBuiltin_BadDealloc(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
if (sobj->own) {
PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", obj->ob_type->tp_name);
}
}
typedef struct {
PyCFunction get;
PyCFunction set;
} SwigPyGetSet;
SWIGINTERN PyObject *
SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
tuple = PyTuple_New(0);
assert(tuple);
result = (*getset->get)(obj, tuple);
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyObject *
SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
result = (*getset->get)(obj, NULL);
return result;
}
SWIGINTERN int
SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(val);
PyTuple_SET_ITEM(tuple, 0, val);
result = (*getset->set)(obj, tuple);
Py_DECREF(tuple);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN int
SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
result = (*getset->set)(obj, val);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN void
SwigPyStaticVar_dealloc(PyDescrObject *descr) {
PyObject_GC_UnTrack(descr);
Py_XDECREF(PyDescr_TYPE(descr));
Py_XDECREF(PyDescr_NAME(descr));
PyObject_GC_Del(descr);
}
SWIGINTERN PyObject *
SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromFormat("", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
return PyString_FromFormat("", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
}
SWIGINTERN int
SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
PyDescrObject *descr;
descr = (PyDescrObject *)self;
Py_VISIT((PyObject*) PyDescr_TYPE(descr));
return 0;
}
SWIGINTERN PyObject *
SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
if (descr->d_getset->get != NULL)
return descr->d_getset->get(obj, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return NULL;
}
SWIGINTERN int
SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
if (descr->d_getset->set != NULL)
return descr->d_getset->set(obj, value, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return -1;
}
SWIGINTERN int
SwigPyObjectType_setattro(PyObject *typeobject, PyObject *name, PyObject *value) {
PyObject *attribute;
PyTypeObject *type;
descrsetfunc local_set;
assert(PyType_Check(typeobject));
type = (PyTypeObject *)typeobject;
attribute = _PyType_Lookup(type, name);
if (attribute != NULL) {
/* Implement descriptor functionality, if any */
local_set = attribute->ob_type->tp_descr_set;
if (local_set != NULL)
return local_set(attribute, (PyObject *)type, value);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
} else {
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
}
return -1;
}
SWIGINTERN PyTypeObject*
SwigPyStaticVar_Type(void) {
static PyTypeObject staticvar_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"swig_static_var_getset_descriptor", /* tp_name */
sizeof(PyGetSetDescrObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyStaticVar_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
(reprfunc)SwigPyStaticVar_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
0, /* tp_doc */
SwigPyStaticVar_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc)SwigPyStaticVar_get, /* tp_descr_get */
(descrsetfunc)SwigPyStaticVar_set, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
staticvar_type = tmp;
type_init = 1;
if (PyType_Ready(&staticvar_type) < 0)
return NULL;
}
return &staticvar_type;
}
SWIGINTERN PyTypeObject*
SwigPyObjectType(void) {
static char swigpyobjecttype_doc[] = "Metaclass for SWIG wrapped types";
static PyTypeObject swigpyobjecttype_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"SwigPyObjectType", /* tp_name */
PyType_Type.tp_basicsize, /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
SwigPyObjectType_setattro, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
swigpyobjecttype_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobjecttype_type = tmp;
type_init = 1;
swigpyobjecttype_type.tp_base = &PyType_Type;
if (PyType_Ready(&swigpyobjecttype_type) < 0)
return NULL;
}
return &swigpyobjecttype_type;
}
SWIGINTERN PyGetSetDescrObject *
SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
PyGetSetDescrObject *descr;
descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
assert(descr);
Py_XINCREF(type);
PyDescr_TYPE(descr) = type;
PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
descr->d_getset = getset;
if (PyDescr_NAME(descr) == NULL) {
Py_DECREF(descr);
descr = NULL;
}
return descr;
}
SWIGINTERN void
SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
Py_ssize_t base_count = 0;
PyTypeObject **b;
PyObject *tuple;
Py_ssize_t i;
if (!bases[0]) {
bases[0] = SwigPyObject_type();
bases[1] = NULL;
}
type->tp_base = bases[0];
Py_INCREF((PyObject *)bases[0]);
for (b = bases; *b != NULL; ++b)
++base_count;
tuple = PyTuple_New(base_count);
for (i = 0; i < base_count; ++i) {
Py_INCREF((PyObject *)bases[i]);
PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
}
type->tp_bases = tuple;
}
SWIGINTERN PyObject *
SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
PyObject *result;
result = (PyObject *)SWIG_Python_GetSwigThis(self);
Py_XINCREF(result);
return result;
}
SWIGINTERN void
SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
{
#if PY_VERSION_HEX >= 0x030900a4
Py_SET_TYPE(type, metatype);
#else
Py_TYPE(type) = metatype;
#endif
}
/* Start of callback function macros for use in PyTypeObject */
typedef PyObject *(*SwigPyWrapperFunction)(PyObject *, PyObject *);
#define SWIGPY_UNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_unaryfunc_closure(PyObject *a) { \
return SwigPyBuiltin_unaryfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_unaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper) \
SWIGINTERN void \
wrapper##_destructor_closure(PyObject *a) { \
SwigPyBuiltin_destructor_closure(wrapper, #wrapper, a); \
}
SWIGINTERN void
SwigPyBuiltin_destructor_closure(SwigPyWrapperFunction wrapper, const char *wrappername, PyObject *a) {
SwigPyObject *sobj;
sobj = (SwigPyObject *)a;
Py_XDECREF(sobj->dict);
if (sobj->own) {
PyObject *o;
PyObject *type = 0, *value = 0, *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
o = wrapper(a, NULL);
if (!o) {
PyObject *deallocname = PyString_FromString(wrappername);
PyErr_WriteUnraisable(deallocname);
Py_DECREF(deallocname);
}
PyErr_Restore(type, value, traceback);
Py_XDECREF(o);
}
if (PyType_IS_GC(a->ob_type)) {
PyObject_GC_Del(a);
} else {
PyObject_Del(a);
}
}
#define SWIGPY_INQUIRY_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_inquiry_closure(PyObject *a) { \
return SwigPyBuiltin_inquiry_closure(wrapper, a); \
}
SWIGINTERN int
SwigPyBuiltin_inquiry_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
int result;
pyresult = wrapper(a, NULL);
result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_GETITERFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_getiterfunc_closure(PyObject *a) { \
return SwigPyBuiltin_getiterfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_getiterfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_BINARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_binaryfunc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_binaryfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_binaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
typedef ternaryfunc ternarycallfunc;
#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternaryfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternaryfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternarycallfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternarycallfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternarycallfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
(void) c;
return wrapper(a, b);
}
#define SWIGPY_LENFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_ssize_t \
wrapper##_lenfunc_closure(PyObject *a) { \
return SwigPyBuiltin_lenfunc_closure(wrapper, a); \
}
SWIGINTERN Py_ssize_t
SwigPyBuiltin_lenfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *resultobj;
Py_ssize_t result;
resultobj = wrapper(a, NULL);
result = PyNumber_AsSsize_t(resultobj, NULL);
Py_DECREF(resultobj);
return result;
}
#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizessizeargfunc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) { \
return SwigPyBuiltin_ssizessizeargfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizessizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizessizeobjargproc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
return SwigPyBuiltin_ssizessizeobjargproc_closure(wrapper, a, b, c, d); \
}
SWIGINTERN int
SwigPyBuiltin_ssizessizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(d ? 3 : 2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
if (d) {
Py_INCREF(d);
PyTuple_SET_ITEM(tuple, 2, d);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_DECREF(tuple);
Py_XDECREF(resultobj);
return result;
}
#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_funpack_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_funpack_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *arg, *result;
arg = _PyLong_FromSsize_t(b);
result = wrapper(a, arg);
Py_DECREF(arg);
return result;
}
#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizeobjargproc_closure(PyObject *a, Py_ssize_t b, PyObject *c) { \
return SwigPyBuiltin_ssizeobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_ssizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
PyObject *tuple;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
pyresult = wrapper(a, tuple);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_funpack_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_funpack_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
pyresult = wrapper(a, b);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjargproc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_objobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_objobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(c ? 2 : 1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
if (c) {
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_REPRFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_reprfunc_closure(PyObject *a) { \
return SwigPyBuiltin_reprfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_reprfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_HASHFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_hash_t \
wrapper##_hashfunc_closure(PyObject *a) { \
return SwigPyBuiltin_hashfunc_closure(wrapper, a); \
}
SWIGINTERN Py_hash_t
SwigPyBuiltin_hashfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
Py_hash_t result;
pyresult = wrapper(a, NULL);
if (!pyresult)
return -1;
result = SWIG_PyNumber_AsPyHash(pyresult);
Py_DECREF(pyresult);
return result;
}
#define SWIGPY_ITERNEXTFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_iternextfunc_closure(PyObject *a) { \
return SwigPyBuiltin_iternextfunc_closure(wrapper, a);\
}
SWIGINTERN PyObject *
SwigPyBuiltin_iternextfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
/* End of callback function macros for use in PyTypeObject */
#ifdef __cplusplus
}
#endif
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
#include "gphoto2/gphoto2.h"
static PyObject* CameraList_item(CameraList *list, int type, int idx);
typedef struct _CameraList_iterator CameraList_iterator;
CameraList_iterator *new_CameraList_iterator(CameraList *list, int type);
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_SwigPyObject swig_types[0]
#define SWIGTYPE_p__CameraList swig_types[1]
#define SWIGTYPE_p__CameraList_iterator swig_types[2]
#define SWIGTYPE_p_char swig_types[3]
#define SWIGTYPE_p_int swig_types[4]
#define SWIGTYPE_p_p__CameraList swig_types[5]
#define SWIGTYPE_p_p_char swig_types[6]
static swig_type_info *swig_types[8];
static swig_module_info swig_module = {swig_types, 7, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery
/*-----------------------------------------------
@(target):= _list.so
------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_init PyInit__list
#else
# define SWIG_init init_list
#endif
#define SWIG_name "_list"
#define SWIG_as_voidptr(a) (void *)((const void *)(a))
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
#include
#include "gphoto2/gphoto2.h"
PyObject *PyExc_GPhoto2Error = NULL;
SWIGINTERN struct _CameraList *new__CameraList(void){
struct _CameraList *result;
int error = gp_list_new(&result);
if (error < GP_OK)
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
return result;
}
SWIGINTERN void delete__CameraList(struct _CameraList *self){
int error = gp_list_unref(self);
if (error < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
}
#include
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
# define LLONG_MAX __LONG_LONG_MAX__
# define LLONG_MIN (-LLONG_MAX - 1LL)
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif
SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
int res = SWIG_TypeError;
if (PyFloat_Check(obj)) {
if (val) *val = PyFloat_AsDouble(obj);
return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
} else if (PyInt_Check(obj)) {
if (val) *val = (double) PyInt_AsLong(obj);
return SWIG_OK;
#endif
} else if (PyLong_Check(obj)) {
double v = PyLong_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
double d = PyFloat_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = d;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
} else {
PyErr_Clear();
}
}
}
#endif
return res;
}
#include
#include
SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
double x = *d;
if ((min <= x && x <= max)) {
double fx = floor(x);
double cx = ceil(x);
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
if ((errno == EDOM) || (errno == ERANGE)) {
errno = 0;
} else {
double summ, reps, diff;
if (rd < x) {
diff = x - rd;
} else if (rd > x) {
diff = rd - x;
} else {
return 1;
}
summ = rd + x;
reps = diff/summ;
if (reps < 8*DBL_EPSILON) {
*d = rd;
return 1;
}
}
}
return 0;
}
SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
} else
#endif
if (PyLong_Check(obj)) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
return SWIG_OverflowError;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
long v = PyInt_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
if (val) *val = (long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
long v;
int res = SWIG_AsVal_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v < INT_MIN || v > INT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = (int)(v);
}
}
return res;
}
SWIGINTERN PyObject *_CameraList___getitem____SWIG_0(struct _CameraList *self,int idx){
int count = gp_list_count(self);
if (count < GP_OK) {
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(count));
/*@SWIG@*/
return NULL;
}
if (idx < 0)
idx += count;
if (idx < 0 || idx >= count) {
PyErr_SetString(PyExc_IndexError, "CameraList index out of range");
return NULL;
}
return CameraList_item(self, 2, idx);
}
SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
static int init = 0;
static swig_type_info* info = 0;
if (!init) {
info = SWIG_TypeQuery("_p_char");
init = 1;
}
return info;
}
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (PyBytes_Check(obj))
#else
if (PyUnicode_Check(obj))
#endif
#else
if (PyString_Check(obj))
#endif
{
char *cstr; Py_ssize_t len;
int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (!alloc && cptr) {
/* We can't allow converting without allocation, since the internal
representation of string in Python 3 is UCS-2/UCS-4 but we require
a UTF-8 representation.
TODO(bhy) More detailed explanation */
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (alloc)
*alloc = SWIG_NEWOBJ;
#endif
if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#else
if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#endif
if (cptr) {
if (alloc) {
if (*alloc == SWIG_NEWOBJ) {
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
*alloc = SWIG_NEWOBJ;
} else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
}
} else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
*cptr = PyBytes_AsString(obj);
#else
assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
*cptr = SWIG_Python_str_AsChar(obj);
if (!*cptr)
ret = SWIG_TypeError;
#endif
}
}
if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
Py_XDECREF(obj);
#endif
return ret;
} else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
if (PyUnicode_Check(obj)) {
char *cstr; Py_ssize_t len;
if (!alloc && cptr) {
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
if (cptr) {
if (alloc) *alloc = SWIG_NEWOBJ;
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
}
if (psize) *psize = len + 1;
Py_XDECREF(obj);
return SWIG_OK;
} else {
Py_XDECREF(obj);
}
}
#endif
#endif
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
if (pchar_descriptor) {
void* vptr = 0;
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
if (cptr) *cptr = (char *) vptr;
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
if (alloc) *alloc = SWIG_OLDOBJ;
return SWIG_OK;
}
}
}
return SWIG_TypeError;
}
SWIGINTERN PyObject *_CameraList___getitem____SWIG_1(struct _CameraList *self,char const *name){
int idx = 0;
if (gp_list_find_by_name(self, &idx, name) < GP_OK) {
PyErr_SetString(PyExc_KeyError, name);
return NULL;
}
return CameraList_item(self, 1, idx);
}
SWIGINTERN CameraList_iterator *_CameraList_keys(struct _CameraList *self){
return new_CameraList_iterator(self, 0);
}
SWIGINTERN CameraList_iterator *_CameraList_values(struct _CameraList *self){
return new_CameraList_iterator(self, 1);
}
SWIGINTERN CameraList_iterator *_CameraList_items(struct _CameraList *self){
return new_CameraList_iterator(self, 2);
}
SWIGINTERN CameraList_iterator *_CameraList___iter__(struct _CameraList *self){
return new_CameraList_iterator(self, 2);
}
SWIGINTERN int _CameraList___len__(struct _CameraList *self){
int result = gp_list_count (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
return result;
}
SWIGINTERNINLINE PyObject*
SWIG_From_int (int value)
{
return PyInt_FromLong((long) value);
}
SWIGINTERN int _CameraList_count(struct _CameraList *self){
int result = gp_list_count (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
return result;
}
SWIGINTERN void _CameraList_append(struct _CameraList *self,char const *name,char const *value){
int result = gp_list_append (self, name, value);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraList_reset(struct _CameraList *self){
int result = gp_list_reset (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraList_sort(struct _CameraList *self){
int result = gp_list_sort (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraList_find_by_name(struct _CameraList *self,int *index,char const *name){
int result = gp_list_find_by_name (self, index, name);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraList_get_name(struct _CameraList *self,int index,char const **name){
int result = gp_list_get_name (self, index, name);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraList_get_value(struct _CameraList *self,int index,char const **value){
int result = gp_list_get_value (self, index, value);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraList_set_name(struct _CameraList *self,int index,char const *name){
int result = gp_list_set_name (self, index, name);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraList_set_value(struct _CameraList *self,int index,char const *value){
int result = gp_list_set_value (self, index, value);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _CameraList_populate(struct _CameraList *self,char const *format,int count){
int result = gp_list_populate (self, format, count);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
typedef struct _CameraList_iterator {
CameraList *list;
int type; // 0 = keys, 1 = values, 2 = items
int idx;
int count;
} CameraList_iterator;
SWIGINTERN void delete__CameraList_iterator(struct _CameraList_iterator *self){
int error = gp_list_unref(self->list);
if (error < GP_OK) {
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
}
free(self);
}
SWIGINTERN int _CameraList_iterator___len__(struct _CameraList_iterator *self){
return self->count;
}
SWIGINTERN PyObject *_CameraList_iterator___getitem__(struct _CameraList_iterator *self,int idx){
if (idx < 0)
idx += self->count;
if (idx < 0 || idx >= self->count) {
PyErr_SetString(PyExc_IndexError,
"CameraList_iterator index out of range");
return NULL;
}
return CameraList_item(self->list, self->type, idx);
}
SWIGINTERN CameraList_iterator *_CameraList_iterator___iter__(struct _CameraList_iterator *self){
return self;
}
SWIGINTERN PyObject *_CameraList_iterator___next__(struct _CameraList_iterator *self){
if (self->idx >= self->count) {
PyErr_SetNone(PyExc_StopIteration);
return NULL;
}
return CameraList_item(self->list, self->type, self->idx++);
}
static PyObject* CameraList_item(CameraList *list, int type, int idx) {
int error = GP_OK;
const char *name = NULL;
const char *value = NULL;
PyObject *py_name = NULL;
PyObject *py_value = NULL;
if (type != 1) {
error = gp_list_get_name(list, idx, &name);
if (error < GP_OK) {
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
return NULL;
}
py_name = name ? PyUnicode_FromString(name) : SWIG_Py_Void();
}
if (type == 0)
return py_name;
error = gp_list_get_value(list, idx, &value);
if (error < GP_OK) {
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
return NULL;
}
py_value = value ? PyUnicode_FromString(value) : SWIG_Py_Void();
if (type == 1)
return py_value;
return PyTuple_Pack(2, py_name, py_value);
}
CameraList_iterator *new_CameraList_iterator(CameraList *list, int type) {
int error = GP_OK;
CameraList_iterator *self = malloc(sizeof(CameraList_iterator));
if (!self) {
PyErr_SetString(
PyExc_MemoryError, "cannot allocate CameraList_iterator");
goto fail;
}
self->list = list;
self->type = type;
self->idx = 0;
self->count = gp_list_count(list);
if (self->count < GP_OK) {
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(self->count));
goto fail;
}
error = gp_list_ref(list);
if (error < GP_OK) {
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
goto fail;
}
return self;
fail:
if (self)
free(self);
return NULL;
}
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN int _wrap_new_CameraList(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
struct _CameraList *result = 0 ;
(void)self;
if (!SWIG_Python_CheckNoKeywords(kwargs, "new_CameraList")) SWIG_fail;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "new_CameraList takes no arguments");
{
result = (struct _CameraList *)new__CameraList();
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraList, SWIG_BUILTIN_INIT | 0 );
return resultobj == Py_None ? -1 : 0;
fail:
return -1;
}
SWIGINTERN PyObject *_wrap_delete_CameraList(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CameraList takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraList" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
{
delete__CameraList(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList___getitem____SWIG_0(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
PyObject *result = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraList___getitem__", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList___getitem__" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraList___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
result = (PyObject *)_CameraList___getitem____SWIG_0(arg1,arg2);
resultobj = result;
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList___getitem____SWIG_1(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj1 = 0 ;
PyObject *result = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraList___getitem__", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList___getitem__" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraList___getitem__" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
result = (PyObject *)_CameraList___getitem____SWIG_1(arg1,(char const *)arg2);
resultobj = result;
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList___getitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
PyObject *argv[3] = {
0
};
Py_ssize_t ii;
(void)self;
if (!PyTuple_Check(args)) SWIG_fail;
argc = PyObject_Length(args);
argv[0] = self;
for (ii = 0; (ii < 1) && (ii < argc); ii++) {
argv[ii + 1] = PyTuple_GET_ITEM(args,ii);
}
argc++;
if (argc == 2) {
int _v = 0;
{
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
}
if (!_v) goto check_1;
return _wrap_CameraList___getitem____SWIG_0(self, args);
}
check_1:
if (argc == 2) {
{
PyObject *retobj = _wrap_CameraList___getitem____SWIG_1(self, args);
if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
SWIG_fail;
}
}
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CameraList___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
" _CameraList::__getitem__(int)\n"
" _CameraList::__getitem__(char const *)\n");
return 0;
}
SWIGINTERN PyObject *_wrap_CameraList_keys(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraList_iterator *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraList_keys takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_keys" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
result = (CameraList_iterator *)_CameraList_keys(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraList_iterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_values(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraList_iterator *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraList_values takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_values" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
result = (CameraList_iterator *)_CameraList_values(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraList_iterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_items(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraList_iterator *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraList_items takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_items" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
result = (CameraList_iterator *)_CameraList_items(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraList_iterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList___iter__(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraList_iterator *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraList___iter__ takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList___iter__" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
result = (CameraList_iterator *)_CameraList___iter__(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraList_iterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList___len__(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraList___len__ takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList___len__" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
{
result = (int)_CameraList___len__(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_count(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraList_count takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_count" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
{
result = (int)_CameraList_count(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_append(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraList_append", 2, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_append" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraList_append" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CameraList_append" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
{
_CameraList_append(arg1,(char const *)arg2,(char const *)arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_reset(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraList_reset takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_reset" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
{
_CameraList_reset(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_sort(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraList_sort takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_sort" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
{
_CameraList_sort(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_find_by_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
int *arg2 = (int *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int temp2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj1 = 0 ;
arg2 = &temp2;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraList_find_by_name", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_find_by_name" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CameraList_find_by_name" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
{
_CameraList_find_by_name(arg1,arg2,(char const *)arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong(*arg2));
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_get_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
int arg2 ;
char **arg3 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
char *temp3 ;
PyObject * obj1 = 0 ;
{
temp3 = NULL;
arg3 = &temp3;
}
(void)self;
if (!PyArg_UnpackTuple(args, "CameraList_get_name", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_get_name" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraList_get_name" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
{
_CameraList_get_name(arg1,arg2,(char const **)arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg3 ? PyString_FromString(*arg3) : SWIG_Py_Void());
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_get_value(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
int arg2 ;
char **arg3 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
char *temp3 ;
PyObject * obj1 = 0 ;
{
temp3 = NULL;
arg3 = &temp3;
}
(void)self;
if (!PyArg_UnpackTuple(args, "CameraList_get_value", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_get_value" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraList_get_value" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
{
_CameraList_get_value(arg1,arg2,(char const **)arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg3 ? PyString_FromString(*arg3) : SWIG_Py_Void());
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_set_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
int arg2 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraList_set_name", 2, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_set_name" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraList_set_name" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CameraList_set_name" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
{
_CameraList_set_name(arg1,arg2,(char const *)arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_set_value(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
int arg2 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraList_set_value", 2, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_set_value" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraList_set_value" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CameraList_set_value" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
{
_CameraList_set_value(arg1,arg2,(char const *)arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_populate(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList *arg1 = (struct _CameraList *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraList_populate", 2, 2, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_populate" "', argument " "1"" of type '" "struct _CameraList *""'");
}
arg1 = (struct _CameraList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CameraList_populate" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CameraList_populate" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
{
if (PyErr_WarnEx(PyExc_DeprecationWarning,"_CameraList::populate"" is deprecated and"
" will be removed in a future release", 1) < 0) SWIG_fail;
_CameraList_populate(arg1,(char const *)arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraList) /* defines _wrap_delete_CameraList_destructor_closure */
SWIGPY_BINARYFUNC_CLOSURE(_wrap_CameraList___getitem__) /* defines _wrap_CameraList___getitem___binaryfunc_closure */
SWIGPY_GETITERFUNC_CLOSURE(_wrap_CameraList___iter__) /* defines _wrap_CameraList___iter___getiterfunc_closure */
SWIGPY_LENFUNC_CLOSURE(_wrap_CameraList___len__) /* defines _wrap_CameraList___len___lenfunc_closure */
SWIGINTERN PyObject *_wrap_delete_CameraList_iterator(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList_iterator *arg1 = (struct _CameraList_iterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_CameraList_iterator takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList_iterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraList_iterator" "', argument " "1"" of type '" "struct _CameraList_iterator *""'");
}
arg1 = (struct _CameraList_iterator *)(argp1);
{
delete__CameraList_iterator(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_iterator___len__(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList_iterator *arg1 = (struct _CameraList_iterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraList_iterator___len__ takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList_iterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_iterator___len__" "', argument " "1"" of type '" "struct _CameraList_iterator *""'");
}
arg1 = (struct _CameraList_iterator *)(argp1);
{
result = (int)_CameraList_iterator___len__(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_iterator___getitem__(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList_iterator *arg1 = (struct _CameraList_iterator *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj1 = 0 ;
PyObject *result = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "CameraList_iterator___getitem__", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList_iterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_iterator___getitem__" "', argument " "1"" of type '" "struct _CameraList_iterator *""'");
}
arg1 = (struct _CameraList_iterator *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CameraList_iterator___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
{
result = (PyObject *)_CameraList_iterator___getitem__(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = result;
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_iterator___iter__(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList_iterator *arg1 = (struct _CameraList_iterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
CameraList_iterator *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraList_iterator___iter__ takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList_iterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_iterator___iter__" "', argument " "1"" of type '" "struct _CameraList_iterator *""'");
}
arg1 = (struct _CameraList_iterator *)(argp1);
{
result = (CameraList_iterator *)_CameraList_iterator___iter__(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CameraList_iterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CameraList_iterator___next__(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _CameraList_iterator *arg1 = (struct _CameraList_iterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *result = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "CameraList_iterator___next__ takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__CameraList_iterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CameraList_iterator___next__" "', argument " "1"" of type '" "struct _CameraList_iterator *""'");
}
arg1 = (struct _CameraList_iterator *)(argp1);
{
result = (PyObject *)_CameraList_iterator___next__(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = result;
return resultobj;
fail:
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraList_iterator) /* defines _wrap_delete_CameraList_iterator_destructor_closure */
SWIGPY_LENFUNC_CLOSURE(_wrap_CameraList_iterator___len__) /* defines _wrap_CameraList_iterator___len___lenfunc_closure */
SWIGPY_SSIZEARGFUNC_CLOSURE(_wrap_CameraList_iterator___getitem__) /* defines _wrap_CameraList_iterator___getitem___ssizeargfunc_closure */
SWIGPY_GETITERFUNC_CLOSURE(_wrap_CameraList_iterator___iter__) /* defines _wrap_CameraList_iterator___iter___getiterfunc_closure */
SWIGPY_ITERNEXTFUNC_CLOSURE(_wrap_CameraList_iterator___next__) /* defines _wrap_CameraList_iterator___next___iternextfunc_closure */
SWIGINTERN PyObject *_wrap_gp_list_new(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList **arg1 = (CameraList **) 0 ;
CameraList *temp1 ;
int result;
{
temp1 = NULL;
arg1 = &temp1;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_list_new", 0, 0)) SWIG_fail;
result = (int)gp_list_new(arg1);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg1, SWIGTYPE_p__CameraList, SWIG_POINTER_OWN));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_list_count(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList *arg1 = (CameraList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_list_count", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_list_count" "', argument " "1"" of type '" "CameraList *""'");
}
arg1 = (CameraList *)(argp1);
result = (int)gp_list_count(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_list_append(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList *arg1 = (CameraList *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_list_append", 3, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_list_append" "', argument " "1"" of type '" "CameraList *""'");
}
arg1 = (CameraList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_list_append" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_list_append" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
result = (int)gp_list_append(arg1,(char const *)arg2,(char const *)arg3);
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_list_reset(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList *arg1 = (CameraList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_list_reset", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_list_reset" "', argument " "1"" of type '" "CameraList *""'");
}
arg1 = (CameraList *)(argp1);
result = (int)gp_list_reset(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_list_sort(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList *arg1 = (CameraList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_list_sort", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_list_sort" "', argument " "1"" of type '" "CameraList *""'");
}
arg1 = (CameraList *)(argp1);
result = (int)gp_list_sort(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_list_find_by_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList *arg1 = (CameraList *) 0 ;
int *arg2 = (int *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int temp2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
arg2 = &temp2;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_list_find_by_name", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_list_find_by_name" "', argument " "1"" of type '" "CameraList *""'");
}
arg1 = (CameraList *)(argp1);
res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_list_find_by_name" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
result = (int)gp_list_find_by_name(arg1,arg2,(char const *)arg3);
resultobj = SWIG_From_int((int)(result));
resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong(*arg2));
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_list_get_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList *arg1 = (CameraList *) 0 ;
int arg2 ;
char **arg3 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
char *temp3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
temp3 = NULL;
arg3 = &temp3;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_list_get_name", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_list_get_name" "', argument " "1"" of type '" "CameraList *""'");
}
arg1 = (CameraList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gp_list_get_name" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
result = (int)gp_list_get_name(arg1,arg2,(char const **)arg3);
resultobj = SWIG_From_int((int)(result));
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg3 ? PyString_FromString(*arg3) : SWIG_Py_Void());
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_list_get_value(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList *arg1 = (CameraList *) 0 ;
int arg2 ;
char **arg3 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
char *temp3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
temp3 = NULL;
arg3 = &temp3;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_list_get_value", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_list_get_value" "', argument " "1"" of type '" "CameraList *""'");
}
arg1 = (CameraList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gp_list_get_value" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
result = (int)gp_list_get_value(arg1,arg2,(char const **)arg3);
resultobj = SWIG_From_int((int)(result));
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg3 ? PyString_FromString(*arg3) : SWIG_Py_Void());
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_list_set_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList *arg1 = (CameraList *) 0 ;
int arg2 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_list_set_name", 3, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_list_set_name" "', argument " "1"" of type '" "CameraList *""'");
}
arg1 = (CameraList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gp_list_set_name" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_list_set_name" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
result = (int)gp_list_set_name(arg1,arg2,(char const *)arg3);
resultobj = SWIG_From_int((int)(result));
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_list_set_value(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList *arg1 = (CameraList *) 0 ;
int arg2 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_list_set_value", 3, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_list_set_value" "', argument " "1"" of type '" "CameraList *""'");
}
arg1 = (CameraList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gp_list_set_value" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_list_set_value" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
result = (int)gp_list_set_value(arg1,arg2,(char const *)arg3);
resultobj = SWIG_From_int((int)(result));
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_list_populate(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
CameraList *arg1 = (CameraList *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_list_populate", 3, 3, &obj0, &obj1, &obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CameraList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_list_populate" "', argument " "1"" of type '" "CameraList *""'");
}
arg1 = (CameraList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_list_populate" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gp_list_populate" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
{
if (PyErr_WarnEx(PyExc_DeprecationWarning,"gp_list_populate"" is deprecated and"
" will be removed in a future release", 1) < 0) SWIG_fail;
result = (int)gp_list_populate(arg1,(char const *)arg2,arg3);
}
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
static PyMethodDef SwigMethods[] = {
{ "gp_list_new", _wrap_gp_list_new, METH_VARARGS, "\n"
"gp_list_new() -> int\n"
"Creates a new CameraList. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.CameraList\n"
""},
{ "gp_list_count", _wrap_gp_list_count, METH_VARARGS, "\n"
"gp_list_count(list) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraList\n"
"\n"
"Counts the entries in the `list`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.CameraList.count\n"
""},
{ "gp_list_append", _wrap_gp_list_append, METH_VARARGS, "\n"
"gp_list_append(list, name, value) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraList\n"
"name: str\n"
"value: str\n"
"\n"
"Appends `name` and `value` to the `list`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"* `name` : \n"
" the name of the entry to append \n"
"* `value` : \n"
" the value of the entry to append \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.CameraList.append\n"
""},
{ "gp_list_reset", _wrap_gp_list_reset, METH_VARARGS, "\n"
"gp_list_reset(list) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraList\n"
"\n"
"Resets the `list` and removes all entries. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.CameraList.reset\n"
""},
{ "gp_list_sort", _wrap_gp_list_sort, METH_VARARGS, "\n"
"gp_list_sort(list) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraList\n"
"\n"
"Sorts the `list` entries with respect to the names. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.CameraList.sort\n"
""},
{ "gp_list_find_by_name", _wrap_gp_list_find_by_name, METH_VARARGS, "\n"
"gp_list_find_by_name(list, name) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraList\n"
"name: str\n"
"\n"
"Retrieves the `index` of an arbitrary entry with `name`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"* `index` : \n"
" pointer to the result index (may be NULL, only set if found) \n"
"* `name` : \n"
" name of the entry \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code: GP_OK if found. \n"
"\n"
"No guarantees as to the speed of the search, or in what sequence the\n"
"list is searched.\n"
"\n"
"See also gphoto2.CameraList.find_by_name\n"
""},
{ "gp_list_get_name", _wrap_gp_list_get_name, METH_VARARGS, "\n"
"gp_list_get_name(list, index) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraList\n"
"index: int\n"
"\n"
"Retrieves the `name` of entry with `index`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"* `index` : \n"
" index of the entry \n"
"* `name` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.CameraList.get_name\n"
""},
{ "gp_list_get_value", _wrap_gp_list_get_value, METH_VARARGS, "\n"
"gp_list_get_value(list, index) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraList\n"
"index: int\n"
"\n"
"Retrieves the value of entry with `index`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"* `index` : \n"
" index of the entry \n"
"* `value` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.CameraList.get_value\n"
""},
{ "gp_list_set_name", _wrap_gp_list_set_name, METH_VARARGS, "\n"
"gp_list_set_name(list, index, name) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraList\n"
"index: int\n"
"name: str\n"
"\n"
"Sets the name of an entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"* `index` : \n"
" index of entry \n"
"* `name` : \n"
" name to be set \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.CameraList.set_name\n"
""},
{ "gp_list_set_value", _wrap_gp_list_set_value, METH_VARARGS, "\n"
"gp_list_set_value(list, index, value) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraList\n"
"index: int\n"
"value: str\n"
"\n"
"Sets the `value` of an entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"* `index` : \n"
" index of the entry \n"
"* `value` : \n"
" the value to be set \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.CameraList.set_value\n"
""},
{ "gp_list_populate", _wrap_gp_list_populate, METH_VARARGS, "\n"
"gp_list_populate(list, format, count) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.CameraList\n"
"format: str\n"
"count: int\n"
"\n"
"This function is deprecated and will be removed in a future release.\n"
""},
{ NULL, NULL, 0, NULL }
};
static SwigPyGetSet CameraList___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin___CameraList_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"_CameraList", &CameraList___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___CameraList_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___CameraList_methods[] = {
{ "__getitem__", _wrap_CameraList___getitem__, METH_VARARGS, "\n"
"__getitem__(self, idx) -> PyObject *\n"
"\n"
"Parameters\n"
"----------\n"
"idx: int\n"
"\n"
"__getitem__(self, name) -> PyObject\n"
"\n"
"Parameters\n"
"----------\n"
"name: str\n"
"\n"
"" },
{ "keys", _wrap_CameraList_keys, METH_VARARGS, "\n"
"keys(self) -> CameraList_iterator\n"
"Return an iterator over the names in the list.\n"
"" },
{ "values", _wrap_CameraList_values, METH_VARARGS, "\n"
"values(self) -> CameraList_iterator\n"
"Return an iterator over the values in the list.\n"
"" },
{ "items", _wrap_CameraList_items, METH_VARARGS, "\n"
"items(self) -> CameraList_iterator\n"
"Return an iterator over the (name, value) pairs in the list.\n"
"" },
{ "__iter__", _wrap_CameraList___iter__, METH_VARARGS, "__iter__(self) -> CameraList_iterator" },
{ "__len__", _wrap_CameraList___len__, METH_VARARGS, "__len__(self) -> int" },
{ "count", _wrap_CameraList_count, METH_VARARGS, "\n"
"count(self) -> int\n"
"Counts the entries in the `list`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_list_count\n"
"" },
{ "append", _wrap_CameraList_append, METH_VARARGS, "\n"
"append(self, name, value)\n"
"\n"
"Parameters\n"
"----------\n"
"name: str\n"
"value: str\n"
"\n"
"Appends `name` and `value` to the `list`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"* `name` : \n"
" the name of the entry to append \n"
"* `value` : \n"
" the value of the entry to append \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_list_append\n"
"" },
{ "reset", _wrap_CameraList_reset, METH_VARARGS, "\n"
"reset(self)\n"
"Resets the `list` and removes all entries. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_list_reset\n"
"" },
{ "sort", _wrap_CameraList_sort, METH_VARARGS, "\n"
"sort(self)\n"
"Sorts the `list` entries with respect to the names. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_list_sort\n"
"" },
{ "find_by_name", _wrap_CameraList_find_by_name, METH_VARARGS, "\n"
"find_by_name(self, name)\n"
"\n"
"Parameters\n"
"----------\n"
"name: str\n"
"\n"
"Retrieves the `index` of an arbitrary entry with `name`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"* `index` : \n"
" pointer to the result index (may be NULL, only set if found) \n"
"* `name` : \n"
" name of the entry \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code: GP_OK if found. \n"
"\n"
"No guarantees as to the speed of the search, or in what sequence the\n"
"list is searched.\n"
"\n"
"See also gphoto2.gp_list_find_by_name\n"
"" },
{ "get_name", _wrap_CameraList_get_name, METH_VARARGS, "\n"
"get_name(self, index)\n"
"\n"
"Parameters\n"
"----------\n"
"index: int\n"
"\n"
"Retrieves the `name` of entry with `index`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"* `index` : \n"
" index of the entry \n"
"* `name` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code.\n"
"\n"
"See also gphoto2.gp_list_get_name\n"
"" },
{ "get_value", _wrap_CameraList_get_value, METH_VARARGS, "\n"
"get_value(self, index)\n"
"\n"
"Parameters\n"
"----------\n"
"index: int\n"
"\n"
"Retrieves the value of entry with `index`. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"* `index` : \n"
" index of the entry \n"
"* `value` : \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_list_get_value\n"
"" },
{ "set_name", _wrap_CameraList_set_name, METH_VARARGS, "\n"
"set_name(self, index, name)\n"
"\n"
"Parameters\n"
"----------\n"
"index: int\n"
"name: str\n"
"\n"
"Sets the name of an entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"* `index` : \n"
" index of entry \n"
"* `name` : \n"
" name to be set \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_list_set_name\n"
"" },
{ "set_value", _wrap_CameraList_set_value, METH_VARARGS, "\n"
"set_value(self, index, value)\n"
"\n"
"Parameters\n"
"----------\n"
"index: int\n"
"value: str\n"
"\n"
"Sets the `value` of an entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a CameraList \n"
"* `index` : \n"
" index of the entry \n"
"* `value` : \n"
" the value to be set \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_list_set_value\n"
"" },
{ "populate", _wrap_CameraList_populate, METH_VARARGS, "\n"
"populate(self, format, count)\n"
"\n"
"Parameters\n"
"----------\n"
"format: str\n"
"count: int\n"
"\n"
"This function is deprecated and will be removed in a future release.\n"
"" },
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___CameraList_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.list.CameraList", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CameraList_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___CameraList_type.as_number, /* tp_as_number */
&SwigPyBuiltin___CameraList_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___CameraList_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___CameraList_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"::_CameraList", /* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___CameraList_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
_wrap_CameraList___iter___getiterfunc_closure, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___CameraList_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___CameraList_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
_wrap_new_CameraList, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
_wrap_CameraList___getitem___binaryfunc_closure, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
_wrap_CameraList___len___lenfunc_closure, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___CameraList_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___CameraList_type};
static SwigPyGetSet CameraList_iterator___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin___CameraList_iterator_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"~_CameraList_iterator", &CameraList_iterator___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___CameraList_iterator_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___CameraList_iterator_methods[] = {
{ "__len__", _wrap_CameraList_iterator___len__, METH_VARARGS, "__len__(self) -> int" },
{ "__getitem__", _wrap_CameraList_iterator___getitem__, METH_VARARGS, "\n"
"__getitem__(self, idx) -> PyObject *\n"
"\n"
"Parameters\n"
"----------\n"
"idx: int\n"
"\n"
"" },
{ "__iter__", _wrap_CameraList_iterator___iter__, METH_VARARGS, "__iter__(self) -> CameraList_iterator" },
{ "__next__", _wrap_CameraList_iterator___next__, METH_VARARGS, "__next__(self) -> PyObject *" },
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___CameraList_iterator_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.list.CameraList_iterator", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_CameraList_iterator_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___CameraList_iterator_type.as_number, /* tp_as_number */
&SwigPyBuiltin___CameraList_iterator_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___CameraList_iterator_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___CameraList_iterator_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"\n"
"Iterator over CameraList keys, values, or (key, value) pairs.\n"
"\n"
"In addition to the usual iterator methods the values can be read by\n"
"indexing, for example iterator[4] gets the 4th value.\n"
"",/* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___CameraList_iterator_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
_wrap_CameraList_iterator___iter___getiterfunc_closure, /* tp_iter */
_wrap_CameraList_iterator___next___iternextfunc_closure, /* tp_iternext */
SwigPyBuiltin___CameraList_iterator_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___CameraList_iterator_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
SwigPyBuiltin_BadInit, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
_wrap_CameraList_iterator___len___lenfunc_closure, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
_wrap_CameraList_iterator___getitem___ssizeargfunc_closure, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___CameraList_iterator_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___CameraList_iterator_type};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_SwigPyObject = {"_p_SwigPyObject", "SwigPyObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CameraList = {"_p__CameraList", "CameraList *|struct _CameraList *|_CameraList *", 0, 0, (void*)&SwigPyBuiltin___CameraList_clientdata, 0};
static swig_type_info _swigt__p__CameraList_iterator = {"_p__CameraList_iterator", "CameraList_iterator *|struct _CameraList_iterator *|_CameraList_iterator *", 0, 0, (void*)&SwigPyBuiltin___CameraList_iterator_clientdata, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__CameraList = {"_p_p__CameraList", "CameraList **|struct _CameraList **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_SwigPyObject,
&_swigt__p__CameraList,
&_swigt__p__CameraList_iterator,
&_swigt__p_char,
&_swigt__p_int,
&_swigt__p_p__CameraList,
&_swigt__p_p_char,
};
static swig_cast_info _swigc__p_SwigPyObject[] = { {&_swigt__p_SwigPyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraList[] = { {&_swigt__p__CameraList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CameraList_iterator[] = { {&_swigt__p__CameraList_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__CameraList[] = { {&_swigt__p_p__CameraList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_SwigPyObject,
_swigc__p__CameraList,
_swigc__p__CameraList_iterator,
_swigc__p_char,
_swigc__p_int,
_swigc__p_p__CameraList,
_swigc__p_p_char,
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};
#ifdef __cplusplus
}
#endif
static PyTypeObject *builtin_bases[2];
/* -----------------------------------------------------------------------------
* Type initialization:
* This problem is tough by the requirement that no dynamic
* memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
* to swig_type_info structures, we need some lookup code at initialization.
* The idea is that swig generates all the structures that are needed.
* The runtime then collects these partially filled structures.
* The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
* The generated swig_type_info structures are assigned statically to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
* cast linked list. The cast data is initially stored in something like a
* two-dimensional array. Each row corresponds to a type (there are the same
* number of rows as there are in the swig_type_initial array). Each entry in
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
* we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
* First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
* 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
* swig_cast_info to the linked list (because the cast->type) pointer will
* be correct.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif
#if 0
#define SWIGRUNTIME_DEBUG
#endif
#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif
SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
size_t i;
swig_module_info *module_head, *iter;
int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* Initialize the swig_module */
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
init = 1;
} else {
init = 0;
}
/* Try and load any already created modules */
module_head = SWIG_GetModule(clientdata);
if (!module_head) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
iter=module_head;
do {
if (iter==&swig_module) {
/* Our module is already in the list, so there's nothing more to do. */
return;
}
iter=iter->next;
} while (iter!= module_head);
/* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpreters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
if (init == 0) return;
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
if (swig_module.next != &swig_module) {
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
}
if (type) {
/* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
if (swig_module.type_initial[i]->clientdata) {
type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
}
} else {
type = swig_module.type_initial[i];
}
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
if (swig_module.next != &swig_module) {
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
}
if (ret) {
if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
cast->type = ret;
ret = 0;
} else {
/* Check for casting already in the list */
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
if (!ocast) ret = 0;
}
}
if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
if (type->cast) {
type->cast->prev = cast;
cast->next = type->cast;
}
type->cast = cast;
}
cast++;
}
/* Set entry in modules->types array equal to the type */
swig_module.types[i] = type;
}
swig_module.types[i] = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("**** SWIG_InitializeModule: Cast List ******\n");
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
++j;
}
printf("---- Total casts: %d\n",j);
}
printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}
/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types. It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
size_t i;
swig_cast_info *equiv;
static int init_run = 0;
if (init_run) return;
init_run = 1;
for (i = 0; i < swig_module.size; i++) {
if (swig_module.types[i]->clientdata) {
equiv = swig_module.types[i]->cast;
while (equiv) {
if (!equiv->converter) {
if (equiv->type && !equiv->type->clientdata)
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
}
equiv = equiv->next;
}
}
}
}
#ifdef __cplusplus
#if 0
{
/* c-mode */
#endif
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* constants/methods manipulation
* ----------------------------------------------------------------------------- */
/* Install Constants */
SWIGINTERN void
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
PyObject *obj = 0;
size_t i;
for (i = 0; constants[i].type; ++i) {
switch(constants[i].type) {
case SWIG_PY_POINTER:
obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_PY_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
break;
default:
obj = 0;
break;
}
if (obj) {
PyDict_SetItemString(d, constants[i].name, obj);
Py_DECREF(obj);
}
}
}
/* -----------------------------------------------------------------------------
* Patch %callback methods' docstrings to hold the callback ptrs
* -----------------------------------------------------------------------------*/
SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
size_t i;
for (i = 0; methods[i].ml_name; ++i) {
const char *c = methods[i].ml_doc;
if (!c) continue;
c = strstr(c, "swig_ptr: ");
if (c) {
int j;
const swig_const_info *ci = 0;
const char *name = c + 10;
for (j = 0; const_table[j].type; ++j) {
if (strncmp(const_table[j].name, name,
strlen(const_table[j].name)) == 0) {
ci = &(const_table[j]);
break;
}
}
if (ci) {
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
if (ptr) {
size_t shift = (ci->ptype) - types;
swig_type_info *ty = types_initial[shift];
size_t ldoc = (c - methods[i].ml_doc);
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
char *ndoc = (char*)malloc(ldoc + lptr + 10);
if (ndoc) {
char *buff = ndoc;
memcpy(buff, methods[i].ml_doc, ldoc);
buff += ldoc;
memcpy(buff, "swig_ptr: ", 10);
buff += 10;
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
methods[i].ml_doc = ndoc;
}
}
}
}
}
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------*
* Partial Init method
* -----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
PyObject *m, *d, *md, *globals;
#if PY_VERSION_HEX >= 0x03000000
static struct PyModuleDef SWIG_module = {
PyModuleDef_HEAD_INIT,
SWIG_name,
NULL,
-1,
SwigMethods,
NULL,
NULL,
NULL,
NULL
};
#endif
#if defined(SWIGPYTHON_BUILTIN)
static SwigPyClientData SwigPyObject_clientdata = {
0, 0, 0, 0, 0, 0, 0
};
static PyGetSetDef this_getset_def = {
(char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
};
static SwigPyGetSet thisown_getset_closure = {
SwigPyObject_own,
SwigPyObject_own
};
static PyGetSetDef thisown_getset_def = {
(char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
};
PyTypeObject *builtin_pytype;
int builtin_base_count;
swig_type_info *builtin_basetype;
PyObject *tuple;
PyGetSetDescrObject *static_getset;
PyTypeObject *metatype;
PyTypeObject *swigpyobject;
SwigPyClientData *cd;
PyObject *public_interface, *public_symbol;
PyObject *this_descr;
PyObject *thisown_descr;
PyObject *self = 0;
int i;
(void)builtin_pytype;
(void)builtin_base_count;
(void)builtin_basetype;
(void)tuple;
(void)static_getset;
(void)self;
/* Metaclass is used to implement static member variables */
metatype = SwigPyObjectType();
assert(metatype);
#endif
(void)globals;
/* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
SWIG_This();
SWIG_Python_TypeCache();
SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
SwigPyObject_type();
#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
#if PY_VERSION_HEX >= 0x03000000
m = PyModule_Create(&SWIG_module);
#else
m = Py_InitModule(SWIG_name, SwigMethods);
#endif
md = d = PyModule_GetDict(m);
(void)md;
SWIG_InitializeModule(0);
#ifdef SWIGPYTHON_BUILTIN
swigpyobject = SwigPyObject_TypeOnce();
SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
if (!cd) {
SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
SwigPyObject_clientdata.pytype = swigpyobject;
} else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
return NULL;
# else
return;
# endif
}
/* All objects have a 'this' attribute */
this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
(void)this_descr;
/* All objects have a 'thisown' attribute */
thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
(void)thisown_descr;
public_interface = PyList_New(0);
public_symbol = 0;
(void)public_symbol;
PyDict_SetItemString(md, "__all__", public_interface);
Py_DECREF(public_interface);
for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
for (i = 0; swig_const_table[i].name != 0; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
SWIG_InstallConstants(d,swig_const_table);
{
PyObject *module = PyImport_ImportModule("gphoto2");
if (module != NULL) {
PyExc_GPhoto2Error = PyObject_GetAttrString(module, "GPhoto2Error");
Py_DECREF(module);
}
if (PyExc_GPhoto2Error == NULL)
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
/* type '::_CameraList' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___CameraList_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraList'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CameraList", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraList");
d = md;
/* type '::_CameraList_iterator' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___CameraList_iterator_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraList_iterator'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "CameraList_iterator", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraList_iterator");
d = md;
#if PY_VERSION_HEX >= 0x03000000
return m;
#else
return;
#endif
}
python-gphoto2-2.5.1/src/swig-gp2_5_31/port.py 0000664 0000000 0000000 00000000675 14703210004 0020732 0 ustar 00root root 0000000 0000000 # This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
import gphoto2.port_info_list
# Pull in all the attributes from the low-level C/C++ module
if __package__ or "." in __name__:
from ._port import *
else:
from _port import *
python-gphoto2-2.5.1/src/swig-gp2_5_31/port_info_list.py 0000664 0000000 0000000 00000000752 14703210004 0022774 0 ustar 00root root 0000000 0000000 # This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
# Pull in all the attributes from the low-level C/C++ module
if __package__ or "." in __name__:
from ._port_info_list import *
else:
from _port_info_list import *
PortInfoList = GPPortInfoList
PortInfo = GPPortInfo
python-gphoto2-2.5.1/src/swig-gp2_5_31/port_info_list_wrap.c 0000664 0000000 0000000 00000633101 14703210004 0023617 0 ustar 00root root 0000000 0000000 /* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (https://www.swig.org).
* Version 4.1.1
*
* Do not make changes to this file unless you know what you are doing - modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
#define SWIG_VERSION 0x040101
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_BUILTIN
#define SWIGPYTHON_FASTPROXY
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if defined(__GNUC__)
# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
/* Intel's compiler complains if a variable which was never initialised is
* cast to void, which is a common idiom which we use to indicate that we
* are aware a variable isn't used. So we just silence that warning.
* See: https://github.com/swig/swig/issues/192 for more discussion.
*/
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include
#endif
#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
* See https://github.com/swig/swig/issues/2090 */
# include
#endif
# undef _DEBUG
# include
# define _DEBUG 1
#else
# include
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
creating a static or dynamic library from the SWIG runtime code.
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
But only do this if strictly necessary, ie, if you have problems
with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif
#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif
/* Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
#define SWIG_POINTER_NO_NULL 0x4
#define SWIG_POINTER_CLEAR 0x8
#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
if (SWIG_IsOK(res)) {
// success code
if (SWIG_IsNewObj(res) {
...
delete *ptr;
} else {
...
}
} else {
// fail code
}
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if () {
if () {
*ptr = ;
return SWIG_NEWOBJ;
} else {
*ptr = ;
return SWIG_OLDOBJ;
}
} else {
return SWIG_BADOBJ;
}
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows returning the 'cast rank', for example, if you have this
int food(double)
int fooi(int);
and you call
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
*/
#define SWIG_OK (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ (SWIG_ERROR)
#define SWIG_OLDOBJ (SWIG_OK)
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
# define SWIG_TypeRank unsigned long
# endif
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
# define SWIG_MAXCASTRANK (2)
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
# define SWIG_AddCast(r) (r)
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
#include
#ifdef __cplusplus
extern "C" {
#endif
typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
void *clientdata; /* language specific type data */
int owndata; /* flag if the structure owns the clientdata */
} swig_type_info;
/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
swig_type_info *type; /* pointer to type that is equivalent to this type */
swig_converter_func converter; /* function to cast the void pointers */
struct swig_cast_info *next; /* pointer to next cast in linked list */
struct swig_cast_info *prev; /* pointer to the previous cast */
} swig_cast_info;
/* Structure used to store module information
* Each module generates one structure like this, and the runtime collects
* all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
size_t size; /* Number of types in this module */
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
swig_type_info **type_initial; /* Array of initially generated type structures */
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
void *clientdata; /* Language specific module data */
} swig_module_info;
/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class" == "Class", etc.
Return 0 when the two name types are equivalent, as in
strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
const char *f2, const char *l2) {
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
while ((*f1 == ' ') && (f1 != l1)) ++f1;
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
return (int)((l1 - f1) - (l2 - f2));
}
/*
Check type equivalence in a name list like ||...
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
}
/*
Check type equivalence in a name list like ||...
Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (strcmp(iter->type->name, c) == 0) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (iter->type == from) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
swig_type_info *lastty = ty;
if (!ty || !ty->dcast) return ty;
while (ty && (ty->dcast)) {
ty = (*ty->dcast)(ptr);
if (ty) lastty = ty;
}
return lastty;
}
/*
Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
return ty->name;
}
/*
Return the pretty name associated with this type,
that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
/* The "str" field contains the equivalent pretty names of the
type, separated by vertical-bar characters. Choose the last
name. It should be the most specific; a fully resolved name
but not necessarily with default template parameters expanded. */
if (!type) return NULL;
if (type->str != NULL) {
const char *last_name = type->str;
const char *s;
for (s = type->str; *s; s++)
if (*s == '|') last_name = s+1;
return last_name;
}
else
return type->name;
}
/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
}
cast = cast->next;
}
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
size_t l = 0;
size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
r = i - 1;
} else {
break;
}
} else if (compare > 0) {
l = i + 1;
}
} else {
break; /* should never happen */
}
} while (l <= r);
}
iter = iter->next;
} while (iter != end);
return 0;
}
/*
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
if (ret) {
return ret;
} else {
/* STEP 2: If the type hasn't been found, do a complete search
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
}
iter = iter->next;
} while (iter != end);
}
/* neither found a match */
return 0;
}
/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
const unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
char d = *(c++);
unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
uu = (unsigned char)((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
uu |= (unsigned char)(d - ('a'-10));
else
return (char *) 0;
*u = uu;
}
return c;
}
/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
char *r = buff;
if ((2*sizeof(void *) + 2) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,&ptr,sizeof(void *));
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
strcpy(r,name);
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
*ptr = (void *) 0;
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sizeof(void *));
}
SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
char *r = buff;
size_t lname = (name ? strlen(name) : 0);
if ((2*sz + 2 + lname) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
if (lname) {
strncpy(r,name,lname+1);
} else {
*r = 0;
}
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
memset(ptr,0,sz);
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sz);
}
#ifdef __cplusplus
}
#endif
/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
#endif
#ifndef Py_TYPE
# define Py_TYPE(op) ((op)->ob_type)
#endif
/* SWIG APIs for compatibility of both Python 2 & 3 */
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
# define SWIG_Python_str_FromFormat PyString_FromFormat
#endif
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03030000
return (char *)PyUnicode_AsUTF8(str);
#else
return PyString_AsString(str);
#endif
}
/* Was useful for Python 3.0.x-3.2.x - now provided only for compatibility
* with any uses in user interface files. */
#define SWIG_Python_str_DelForPy3(x)
SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromString(c);
#else
return PyString_FromString(c);
#endif
}
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif
/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif
/* -----------------------------------------------------------------------------
* error manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
PyObject* type = 0;
switch(code) {
case SWIG_MemoryError:
type = PyExc_MemoryError;
break;
case SWIG_IOError:
type = PyExc_IOError;
break;
case SWIG_RuntimeError:
type = PyExc_RuntimeError;
break;
case SWIG_IndexError:
type = PyExc_IndexError;
break;
case SWIG_TypeError:
type = PyExc_TypeError;
break;
case SWIG_DivisionByZero:
type = PyExc_ZeroDivisionError;
break;
case SWIG_OverflowError:
type = PyExc_OverflowError;
break;
case SWIG_SyntaxError:
type = PyExc_SyntaxError;
break;
case SWIG_ValueError:
type = PyExc_ValueError;
break;
case SWIG_SystemError:
type = PyExc_SystemError;
break;
case SWIG_AttributeError:
type = PyExc_AttributeError;
break;
default:
type = PyExc_RuntimeError;
}
return type;
}
SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
if (PyErr_Occurred())
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
PyErr_Clear();
Py_XINCREF(type);
if (tmp)
PyErr_Format(type, "%s %s", tmp, mesg);
else
PyErr_Format(type, "%s", mesg);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
PyErr_SetString(PyExc_RuntimeError, mesg);
}
}
SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
PyObject *error;
if (obj)
return 0;
error = PyErr_Occurred();
return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}
SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
if (SWIG_Python_TypeErrorOccurred(NULL)) {
/* Use existing TypeError to preserve stacktrace and enhance with given message */
PyObject *newvalue;
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
if (newvalue) {
Py_XDECREF(value);
PyErr_Restore(type, newvalue, traceback);
} else {
PyErr_Restore(type, value, traceback);
}
} else {
/* Raise TypeError using given message */
PyErr_SetString(PyExc_TypeError, message);
}
}
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
# undef SWIG_PYTHON_THREADS
# endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
# define SWIG_PYTHON_USE_GIL
# endif
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# if PY_VERSION_HEX < 0x03070000
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
# else
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# endif
# ifdef __cplusplus /* C++ code */
class SWIG_Python_Thread_Block {
bool status;
PyGILState_STATE state;
public:
void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block() { end(); }
};
class SWIG_Python_Thread_Allow {
bool status;
PyThreadState *save;
public:
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow() { end(); }
};
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
# else /* C code */
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
# endif
# else /* Old thread way, not implemented, user must provide it */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
# define SWIG_PYTHON_THREAD_END_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# endif
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
# define SWIG_PYTHON_THREAD_END_ALLOW
# endif
# endif
#else /* No thread support */
# define SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# define SWIG_PYTHON_THREAD_END_BLOCK
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# define SWIG_PYTHON_THREAD_END_ALLOW
#endif
/* -----------------------------------------------------------------------------
* Python API portion that goes into the runtime
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* Constant declarations
* ----------------------------------------------------------------------------- */
/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY 5
/* Constant information structure */
typedef struct swig_const_info {
int type;
const char *name;
long lvalue;
double dvalue;
void *pvalue;
swig_type_info **ptype;
} swig_const_info;
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* pyrun.swg
*
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* type checking.
*
* ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif
#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#endif
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif
#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
#define SWIG_fail goto fail
/* Runtime API implementation */
/* Error manipulation */
SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetObject(errtype, obj);
Py_DECREF(obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetString(errtype, msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
/* Set a constant value */
#if defined(SWIGPYTHON_BUILTIN)
SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
PyObject *s = PyString_InternFromString(key);
PyList_Append(seq, s);
Py_DECREF(s);
}
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
if (public_interface)
SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}
#else
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
}
#endif
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyList_Check(result)) {
PyObject *o2 = result;
result = PyList_New(1);
if (result) {
PyList_SET_ITEM(result, 0, o2);
} else {
Py_DECREF(obj);
return o2;
}
}
PyList_Append(result,obj);
Py_DECREF(obj);
}
return result;
}
/* Unpack the argument tuple */
SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
if (!PyTuple_Check(args)) {
if (min <= 1 && max >= 1) {
Py_ssize_t i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
}
return 2;
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
Py_ssize_t i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
for (; l < max; ++l) {
objs[l] = 0;
}
return i + 1;
}
}
}
SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
int no_kwargs = 1;
if (kwargs) {
assert(PyDict_Check(kwargs));
if (PyDict_Size(kwargs) > 0) {
PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
no_kwargs = 0;
}
}
return no_kwargs;
}
/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
/*
Helper for static pointer initialization for both C and C++ code, for example
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var) var
#else
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Python-specific SWIG API */
#define SWIG_newvarlink() SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
/* -----------------------------------------------------------------------------
* global variable support code.
* ----------------------------------------------------------------------------- */
typedef struct swig_globalvar {
char *name; /* Name of global variable */
PyObject *(*get_attr)(void); /* Return the current value */
int (*set_attr)(PyObject *); /* Set the value */
struct swig_globalvar *next;
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar *vars;
} swig_varlinkobject;
SWIGINTERN PyObject *
swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_InternFromString("");
#else
return PyString_FromString("");
#endif
}
SWIGINTERN PyObject *
swig_varlink_str(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
PyObject *str = PyUnicode_InternFromString("(");
PyObject *tail;
PyObject *joined;
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
tail = PyUnicode_FromString(var->name);
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
if (var->next) {
tail = PyUnicode_InternFromString(", ");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
}
}
tail = PyUnicode_InternFromString(")");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
#else
PyObject *str = PyString_FromString("(");
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
return str;
}
SWIGINTERN void
swig_varlink_dealloc(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
swig_globalvar *var = v->vars;
while (var) {
swig_globalvar *n = var->next;
free(var->name);
free(var);
var = n;
}
}
SWIGINTERN PyObject *
swig_varlink_getattr(PyObject *o, char *n) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
PyObject *res = NULL;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->get_attr)();
break;
}
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN int
swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
int res = 1;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->set_attr)(p);
break;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
static char varlink__doc__[] = "Swig var link object";
static PyTypeObject varlink_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"swigvarlink", /* tp_name */
sizeof(swig_varlinkobject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) swig_varlink_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc) swig_varlink_getattr, /* tp_getattr */
(setattrfunc) swig_varlink_setattr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc) swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
varlink__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
varlink_type = tmp;
type_init = 1;
if (PyType_Ready(&varlink_type) < 0)
return NULL;
}
return &varlink_type;
}
/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
if (result) {
result->vars = 0;
}
return ((PyObject*) result);
}
SWIGINTERN void
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
memcpy(gv->name, name, size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
}
}
v->vars = gv;
}
static PyObject *Swig_Globals_global = NULL;
SWIGINTERN PyObject *
SWIG_globals(void) {
if (Swig_Globals_global == NULL) {
Swig_Globals_global = SWIG_newvarlink();
}
return Swig_Globals_global;
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* Pointer declarations
* ----------------------------------------------------------------------------- */
/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
#ifdef __cplusplus
extern "C" {
#endif
/* The python void return value */
SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)
{
PyObject *none = Py_None;
Py_INCREF(none);
return none;
}
/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
PyTypeObject *pytype;
} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
int fail = data ? data->implicitconv : 0;
if (fail)
PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
return fail;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
/* the newraw method and newargs arguments used to create a new raw instance */
if (PyClass_Check(obj)) {
data->newraw = 0;
Py_INCREF(obj);
data->newargs = obj;
} else {
data->newraw = PyObject_GetAttrString(data->klass, "__new__");
if (data->newraw) {
data->newargs = PyTuple_New(1);
if (data->newargs) {
Py_INCREF(obj);
PyTuple_SET_ITEM(data->newargs, 0, obj);
} else {
Py_DECREF(data->newraw);
Py_DECREF(data->klass);
free(data);
return 0;
}
} else {
Py_INCREF(obj);
data->newargs = obj;
}
}
/* the destroy method, aka as the C++ delete method */
data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
}
if (data->destroy) {
data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
} else {
data->delargs = 0;
}
data->implicitconv = 0;
data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData *data)
{
Py_XDECREF(data->klass);
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
free(data);
}
/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
PyObject *dict;
#endif
} SwigPyObject;
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
if (!sobj->dict)
sobj->dict = PyDict_New();
Py_XINCREF(sobj->dict);
return sobj->dict;
}
#endif
SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
PyObject *val = SwigPyObject_long(v);
if (val) {
PyObject *ofmt;
PyTuple_SET_ITEM(args, 0, val);
ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
res = PyUnicode_Format(ofmt,args);
#else
res = PyString_Format(ofmt,args);
#endif
Py_DECREF(ofmt);
}
}
Py_DECREF(args);
}
return res;
}
SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v);
if (repr && v->next) {
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
PyObject *joined = PyUnicode_Concat(repr, nrep);
Py_DecRef(repr);
Py_DecRef(nrep);
repr = joined;
# else
PyString_ConcatAndDel(&repr,nrep);
# endif
} else {
Py_DecRef(repr);
repr = NULL;
}
}
return repr;
}
/* We need a version taking two PyObject* parameters so it's a valid
* PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
return SwigPyObject_repr((SwigPyObject*)v);
}
SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
PyObject* res;
if( op != Py_EQ && op != Py_NE ) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
return res;
}
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
SwigPyClientData *cd;
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
assert(cd);
assert(cd->pytype);
return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
#endif
SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
PyTypeObject *target_tp = SwigPyObject_type();
if (PyType_IsSubtype(op->ob_type, target_tp))
return 1;
return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
return (Py_TYPE(op) == SwigPyObject_type())
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
static PyObject* Swig_Capsule_global = NULL;
SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
/* PyObject_CallFunction() has the potential to silently drop
the active exception. In cases of unnamed temporary
variable or where we just finished iterating over a generator
StopIteration will be active right now, and this needs to
remain true upon return from SwigPyObject_dealloc. So save
and restore. */
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
if (data->delargs) {
/* we need to create a temporary object to carry the destroy operation */
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
if (tmp) {
res = SWIG_Python_CallFunctor(destroy, tmp);
} else {
res = 0;
}
Py_XDECREF(tmp);
} else {
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
PyObject *mself = PyCFunction_GET_SELF(destroy);
res = ((*meth)(mself, v));
}
if (!res)
PyErr_WriteUnraisable(destroy);
PyErr_Restore(type, value, traceback);
Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
else {
const char *name = SWIG_TypePrettyName(ty);
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
#endif
Py_XDECREF(Swig_Capsule_global);
}
Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
Py_XDECREF(sobj->dict);
#endif
PyObject_DEL(v);
}
SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject* v, PyObject* next)
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (!SwigPyObject_Check(next)) {
PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
((SwigPyObject *)next)->next = sobj->next;
sobj->next = next;
Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
return NULL;
} else {
SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
if (PyObject_IsTrue(val)) {
Py_DECREF(SwigPyObject_acquire(v,args));
} else {
Py_DECREF(SwigPyObject_disown(v,args));
}
}
return obj;
}
}
static PyMethodDef
swigobject_methods[] = {
{"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
{"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
{"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
{"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
{"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
{"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
{0, 0, 0, 0}
};
SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
/* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
#endif
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
(unaryfunc)0, /*nb_negative*/
(unaryfunc)0, /*nb_positive*/
(unaryfunc)0, /*nb_absolute*/
(inquiry)0, /*nb_nonzero*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
0, /*nb_coerce*/
#endif
(unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_long, /*nb_long*/
#else
0, /*nb_reserved*/
#endif
(unaryfunc)0, /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
};
static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyObject", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
(cmpfunc)SwigPyObject_compare, /* tp_compare */
#endif
(reprfunc)SwigPyObject_repr, /* tp_repr */
&SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigobject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
(richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
swigobject_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobject_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpyobject_type) != 0)
return NULL;
}
return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
sobj->own = own;
sobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
sobj->dict = 0;
#endif
if (own == SWIG_POINTER_OWN) {
/* Obtain a reference to the Python capsule wrapping the module information, so that the
* module information is correctly destroyed after all SWIG python objects have been freed
* by the GC (and corresponding destructors invoked) */
Py_XINCREF(Swig_Capsule_global);
}
}
return (PyObject *)sobj;
}
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
void *pack;
swig_type_info *ty;
size_t size;
} SwigPyPacked;
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return SWIG_Python_str_FromFormat("", result, v->ty->name);
} else {
return SWIG_Python_str_FromFormat("", v->ty->name);
}
}
SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}
SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
return ((op)->ob_type == SwigPyPacked_TypeOnce())
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
if (SwigPyPacked_Check(v)) {
SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyPacked", /* tp_name */
sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
0, /* tp_reserved in 3.0.1 */
#else
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
#endif
(reprfunc)SwigPyPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigpacked_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpypacked_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpypacked_type) != 0)
return NULL;
}
return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
memcpy(pack, ptr, size);
sobj->pack = pack;
sobj->ty = ty;
sobj->size = size;
} else {
PyObject_DEL((PyObject *) sobj);
sobj = 0;
}
}
return (PyObject *) sobj;
}
SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (SwigPyPacked_Check(obj)) {
SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
} else {
return 0;
}
}
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
static PyObject *Swig_This_global = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
if (Swig_This_global == NULL)
Swig_This_global = SWIG_Python_str_FromChar("this");
return Swig_This_global;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS
#endif
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
PyObject *obj;
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
#ifdef SWIGPYTHON_BUILTIN
(void)obj;
# ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
pyobj = PyWeakref_GET_OBJECT(pyobj);
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
# endif
return NULL;
#else
obj = 0;
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
}
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
#endif
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
return oldown;
}
}
return 0;
}
/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
int res;
SwigPyObject *sobj;
int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
if (!obj)
return SWIG_ERROR;
if (obj == Py_None && !implicit_conv) {
if (ptr)
*ptr = 0;
return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
}
res = SWIG_ERROR;
sobj = SWIG_Python_GetSwigThis(obj);
if (own)
*own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
swig_type_info *to = sobj->ty;
if (to == ty) {
/* no type cast needed */
if (ptr) *ptr = vptr;
break;
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
sobj = (SwigPyObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
if (own)
*own = *own | SWIG_CAST_NEW_MEMORY;
}
}
break;
}
}
} else {
if (ptr) *ptr = vptr;
break;
}
}
if (sobj) {
if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
res = SWIG_ERROR_RELEASE_NOT_OWNED;
} else {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
if (flags & SWIG_POINTER_CLEAR) {
sobj->ptr = 0;
}
res = SWIG_OK;
}
} else {
if (implicit_conv) {
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
PyObject *impconv;
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
impconv = SWIG_Python_CallFunctor(klass, obj);
data->implicitconv = 0;
if (PyErr_Occurred()) {
PyErr_Clear();
impconv = 0;
}
if (impconv) {
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
if (SWIG_IsOK(res)) {
if (ptr) {
*ptr = vptr;
/* transfer the ownership to 'ptr' */
iobj->own = 0;
res = SWIG_AddCast(res);
res = SWIG_AddNewMask(res);
} else {
res = SWIG_AddCast(res);
}
}
}
Py_DECREF(impconv);
}
}
}
if (!SWIG_IsOK(res) && obj == Py_None) {
if (ptr)
*ptr = 0;
if (PyErr_Occurred())
PyErr_Clear();
res = SWIG_OK;
}
}
}
return res;
}
/* Convert a function ptr value */
SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
if (!PyCFunction_Check(obj)) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
swig_cast_info *tc;
/* here we get the method pointer for callbacks */
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
if (!desc)
return SWIG_ERROR;
tc = SWIG_TypeCheck(desc,ty);
if (tc) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
} else {
return SWIG_ERROR;
}
return SWIG_OK;
}
}
/* Convert a packed pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
/* check type cast? */
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* -----------------------------------------------------------------------------
* Create a new pointer object
* ----------------------------------------------------------------------------- */
/*
Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
inst = PyObject_Call(newraw, data->newargs, NULL);
if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
Py_DECREF(inst);
inst = 0;
}
}
#else
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
}
#endif
}
} else {
#if PY_VERSION_HEX >= 0x03000000
PyObject *empty_args = PyTuple_New(0);
if (empty_args) {
PyObject *empty_kwargs = PyDict_New();
if (empty_kwargs) {
inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
Py_DECREF(empty_kwargs);
if (inst) {
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
} else {
PyType_Modified(Py_TYPE(inst));
}
}
}
Py_DECREF(empty_args);
}
#else
PyObject *dict = PyDict_New();
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
}
#endif
}
return inst;
}
SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
return PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
return -1;
}
}
#endif
return PyObject_SetAttr(inst, SWIG_This(), swig_this);
}
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
return NULL;
} else {
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
} else {
if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
return NULL;
}
return SWIG_Py_Void();
}
}
/* Create a new pointer object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
SwigPyClientData *clientdata;
PyObject * robj;
int own;
if (!ptr)
return SWIG_Py_Void();
clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
if (clientdata && clientdata->pytype) {
SwigPyObject *newobj;
if (flags & SWIG_BUILTIN_TP_INIT) {
newobj = (SwigPyObject*) self;
if (newobj->ptr) {
PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
while (newobj->next)
newobj = (SwigPyObject *) newobj->next;
newobj->next = next_self;
newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
newobj->dict = 0;
#endif
}
} else {
newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
if (newobj) {
newobj->dict = 0;
}
#endif
}
if (newobj) {
newobj->ptr = ptr;
newobj->ty = type;
newobj->own = own;
newobj->next = 0;
return (PyObject*) newobj;
}
return SWIG_Py_Void();
}
assert(!(flags & SWIG_BUILTIN_TP_INIT));
robj = SwigPyObject_New(ptr, type, own);
if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
Py_DECREF(robj);
robj = inst;
}
return robj;
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
* Get type list
* -----------------------------------------------------------------------------*/
#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif
static PyObject *Swig_TypeCache_global = NULL;
/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
if (Swig_TypeCache_global == NULL) {
Swig_TypeCache_global = PyDict_New();
}
return Swig_TypeCache_global;
}
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
}
#else
void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
}
#endif
return (swig_module_info *) type_pointer;
}
static int interpreter_counter = 0; // how many (sub-)interpreters are using swig_module's types
SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
swig_type_info **types = swig_module->types;
size_t i;
if (--interpreter_counter != 0) // another sub-interpreter may still be using the swig_module's types
return;
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
ty->clientdata = 0;
if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
Swig_This_global = NULL;
Py_DECREF(SWIG_globals());
Swig_Globals_global = NULL;
Py_DECREF(SWIG_Python_TypeCache());
Swig_TypeCache_global = NULL;
Swig_Capsule_global = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
/* Add a dummy module object into sys.modules */
PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && module) {
if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
++interpreter_counter;
Swig_Capsule_global = pointer;
} else {
Py_DECREF(pointer);
}
} else {
Py_XDECREF(pointer);
}
}
SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
PyObject *key = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
} else {
swig_module_info *swig_module = SWIG_GetModule(0);
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
obj = PyCapsule_New((void*) descriptor, NULL, NULL);
if (obj) {
PyDict_SetItem(cache, key, obj);
Py_DECREF(obj);
}
}
}
Py_DECREF(key);
return descriptor;
}
/*
For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION 0
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
const char *errmesg = tmp ? tmp : "Invalid error message";
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, errmesg);
} else {
PyErr_Format(type, "%s %s", errmesg, mesg);
}
Py_DECREF(old_str);
}
return 1;
} else {
return 0;
}
}
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
if (PyErr_Occurred()) {
/* add information about failing argument */
char mesg[256];
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
} else {
return 0;
}
}
SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : "";
}
SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
if (obj && SwigPyObject_Check(obj)) {
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
type, otype);
return;
}
} else
#endif
{
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
}
Py_XDECREF(str);
return;
}
}
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
} else {
PyErr_Format(PyExc_TypeError, "unexpected type is received");
}
}
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
}
return result;
}
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
PyTypeObject *tp = obj->ob_type;
PyObject *descr;
PyObject *encoded_name;
descrsetfunc f;
int res = -1;
# ifdef Py_USING_UNICODE
if (PyString_Check(name)) {
name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
if (!name)
return -1;
} else if (!PyUnicode_Check(name))
# else
if (!PyString_Check(name))
# endif
{
PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
return -1;
} else {
Py_INCREF(name);
}
if (!tp->tp_dict) {
if (PyType_Ready(tp) != 0)
goto done;
}
descr = _PyType_Lookup(tp, name);
f = NULL;
if (descr != NULL)
f = descr->ob_type->tp_descr_set;
if (!f) {
if (PyString_Check(name)) {
encoded_name = name;
Py_INCREF(name);
} else {
encoded_name = PyUnicode_AsUTF8String(name);
if (!encoded_name)
goto done;
}
PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
Py_DECREF(encoded_name);
} else {
res = f(descr, obj, value);
}
done:
Py_DECREF(name);
return res;
}
#endif
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN Py_hash_t
SwigPyObject_hash(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
void *ptr = sobj->ptr;
#if PY_VERSION_HEX < 0x03020000
return (Py_hash_t)(Py_ssize_t)ptr;
#else
return (Py_hash_t)ptr;
#endif
}
SWIGINTERN Py_hash_t
SWIG_PyNumber_AsPyHash(PyObject *obj) {
Py_hash_t result = -1;
#if PY_VERSION_HEX < 0x03020000
if (PyInt_Check(obj))
result = PyInt_AsLong(obj);
else if (PyLong_Check(obj))
result = PyLong_AsLong(obj);
#else
if (PyNumber_Check(obj))
result = PyNumber_AsSsize_t(obj, NULL);
#endif
else
PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
return PyErr_Occurred() ? -1 : result;
}
SWIGINTERN int
SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
return -1;
}
SWIGINTERN void
SwigPyBuiltin_BadDealloc(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
if (sobj->own) {
PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", obj->ob_type->tp_name);
}
}
typedef struct {
PyCFunction get;
PyCFunction set;
} SwigPyGetSet;
SWIGINTERN PyObject *
SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
tuple = PyTuple_New(0);
assert(tuple);
result = (*getset->get)(obj, tuple);
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyObject *
SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
result = (*getset->get)(obj, NULL);
return result;
}
SWIGINTERN int
SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(val);
PyTuple_SET_ITEM(tuple, 0, val);
result = (*getset->set)(obj, tuple);
Py_DECREF(tuple);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN int
SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
result = (*getset->set)(obj, val);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN void
SwigPyStaticVar_dealloc(PyDescrObject *descr) {
PyObject_GC_UnTrack(descr);
Py_XDECREF(PyDescr_TYPE(descr));
Py_XDECREF(PyDescr_NAME(descr));
PyObject_GC_Del(descr);
}
SWIGINTERN PyObject *
SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromFormat("", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
return PyString_FromFormat("", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
}
SWIGINTERN int
SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
PyDescrObject *descr;
descr = (PyDescrObject *)self;
Py_VISIT((PyObject*) PyDescr_TYPE(descr));
return 0;
}
SWIGINTERN PyObject *
SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
if (descr->d_getset->get != NULL)
return descr->d_getset->get(obj, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return NULL;
}
SWIGINTERN int
SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
if (descr->d_getset->set != NULL)
return descr->d_getset->set(obj, value, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return -1;
}
SWIGINTERN int
SwigPyObjectType_setattro(PyObject *typeobject, PyObject *name, PyObject *value) {
PyObject *attribute;
PyTypeObject *type;
descrsetfunc local_set;
assert(PyType_Check(typeobject));
type = (PyTypeObject *)typeobject;
attribute = _PyType_Lookup(type, name);
if (attribute != NULL) {
/* Implement descriptor functionality, if any */
local_set = attribute->ob_type->tp_descr_set;
if (local_set != NULL)
return local_set(attribute, (PyObject *)type, value);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
} else {
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
}
return -1;
}
SWIGINTERN PyTypeObject*
SwigPyStaticVar_Type(void) {
static PyTypeObject staticvar_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"swig_static_var_getset_descriptor", /* tp_name */
sizeof(PyGetSetDescrObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyStaticVar_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
(reprfunc)SwigPyStaticVar_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
0, /* tp_doc */
SwigPyStaticVar_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc)SwigPyStaticVar_get, /* tp_descr_get */
(descrsetfunc)SwigPyStaticVar_set, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
staticvar_type = tmp;
type_init = 1;
if (PyType_Ready(&staticvar_type) < 0)
return NULL;
}
return &staticvar_type;
}
SWIGINTERN PyTypeObject*
SwigPyObjectType(void) {
static char swigpyobjecttype_doc[] = "Metaclass for SWIG wrapped types";
static PyTypeObject swigpyobjecttype_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"SwigPyObjectType", /* tp_name */
PyType_Type.tp_basicsize, /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
SwigPyObjectType_setattro, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
swigpyobjecttype_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobjecttype_type = tmp;
type_init = 1;
swigpyobjecttype_type.tp_base = &PyType_Type;
if (PyType_Ready(&swigpyobjecttype_type) < 0)
return NULL;
}
return &swigpyobjecttype_type;
}
SWIGINTERN PyGetSetDescrObject *
SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
PyGetSetDescrObject *descr;
descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
assert(descr);
Py_XINCREF(type);
PyDescr_TYPE(descr) = type;
PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
descr->d_getset = getset;
if (PyDescr_NAME(descr) == NULL) {
Py_DECREF(descr);
descr = NULL;
}
return descr;
}
SWIGINTERN void
SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
Py_ssize_t base_count = 0;
PyTypeObject **b;
PyObject *tuple;
Py_ssize_t i;
if (!bases[0]) {
bases[0] = SwigPyObject_type();
bases[1] = NULL;
}
type->tp_base = bases[0];
Py_INCREF((PyObject *)bases[0]);
for (b = bases; *b != NULL; ++b)
++base_count;
tuple = PyTuple_New(base_count);
for (i = 0; i < base_count; ++i) {
Py_INCREF((PyObject *)bases[i]);
PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
}
type->tp_bases = tuple;
}
SWIGINTERN PyObject *
SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
PyObject *result;
result = (PyObject *)SWIG_Python_GetSwigThis(self);
Py_XINCREF(result);
return result;
}
SWIGINTERN void
SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
{
#if PY_VERSION_HEX >= 0x030900a4
Py_SET_TYPE(type, metatype);
#else
Py_TYPE(type) = metatype;
#endif
}
/* Start of callback function macros for use in PyTypeObject */
typedef PyObject *(*SwigPyWrapperFunction)(PyObject *, PyObject *);
#define SWIGPY_UNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_unaryfunc_closure(PyObject *a) { \
return SwigPyBuiltin_unaryfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_unaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper) \
SWIGINTERN void \
wrapper##_destructor_closure(PyObject *a) { \
SwigPyBuiltin_destructor_closure(wrapper, #wrapper, a); \
}
SWIGINTERN void
SwigPyBuiltin_destructor_closure(SwigPyWrapperFunction wrapper, const char *wrappername, PyObject *a) {
SwigPyObject *sobj;
sobj = (SwigPyObject *)a;
Py_XDECREF(sobj->dict);
if (sobj->own) {
PyObject *o;
PyObject *type = 0, *value = 0, *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
o = wrapper(a, NULL);
if (!o) {
PyObject *deallocname = PyString_FromString(wrappername);
PyErr_WriteUnraisable(deallocname);
Py_DECREF(deallocname);
}
PyErr_Restore(type, value, traceback);
Py_XDECREF(o);
}
if (PyType_IS_GC(a->ob_type)) {
PyObject_GC_Del(a);
} else {
PyObject_Del(a);
}
}
#define SWIGPY_INQUIRY_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_inquiry_closure(PyObject *a) { \
return SwigPyBuiltin_inquiry_closure(wrapper, a); \
}
SWIGINTERN int
SwigPyBuiltin_inquiry_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
int result;
pyresult = wrapper(a, NULL);
result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_GETITERFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_getiterfunc_closure(PyObject *a) { \
return SwigPyBuiltin_getiterfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_getiterfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_BINARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_binaryfunc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_binaryfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_binaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
typedef ternaryfunc ternarycallfunc;
#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternaryfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternaryfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternarycallfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternarycallfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternarycallfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
(void) c;
return wrapper(a, b);
}
#define SWIGPY_LENFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_ssize_t \
wrapper##_lenfunc_closure(PyObject *a) { \
return SwigPyBuiltin_lenfunc_closure(wrapper, a); \
}
SWIGINTERN Py_ssize_t
SwigPyBuiltin_lenfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *resultobj;
Py_ssize_t result;
resultobj = wrapper(a, NULL);
result = PyNumber_AsSsize_t(resultobj, NULL);
Py_DECREF(resultobj);
return result;
}
#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizessizeargfunc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) { \
return SwigPyBuiltin_ssizessizeargfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizessizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizessizeobjargproc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
return SwigPyBuiltin_ssizessizeobjargproc_closure(wrapper, a, b, c, d); \
}
SWIGINTERN int
SwigPyBuiltin_ssizessizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(d ? 3 : 2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
if (d) {
Py_INCREF(d);
PyTuple_SET_ITEM(tuple, 2, d);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_DECREF(tuple);
Py_XDECREF(resultobj);
return result;
}
#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_funpack_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_funpack_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *arg, *result;
arg = _PyLong_FromSsize_t(b);
result = wrapper(a, arg);
Py_DECREF(arg);
return result;
}
#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizeobjargproc_closure(PyObject *a, Py_ssize_t b, PyObject *c) { \
return SwigPyBuiltin_ssizeobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_ssizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
PyObject *tuple;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
pyresult = wrapper(a, tuple);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_funpack_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_funpack_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
pyresult = wrapper(a, b);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjargproc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_objobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_objobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(c ? 2 : 1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
if (c) {
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_REPRFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_reprfunc_closure(PyObject *a) { \
return SwigPyBuiltin_reprfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_reprfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_HASHFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_hash_t \
wrapper##_hashfunc_closure(PyObject *a) { \
return SwigPyBuiltin_hashfunc_closure(wrapper, a); \
}
SWIGINTERN Py_hash_t
SwigPyBuiltin_hashfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
Py_hash_t result;
pyresult = wrapper(a, NULL);
if (!pyresult)
return -1;
result = SWIG_PyNumber_AsPyHash(pyresult);
Py_DECREF(pyresult);
return result;
}
#define SWIGPY_ITERNEXTFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_iternextfunc_closure(PyObject *a) { \
return SwigPyBuiltin_iternextfunc_closure(wrapper, a);\
}
SWIGINTERN PyObject *
SwigPyBuiltin_iternextfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
/* End of callback function macros for use in PyTypeObject */
#ifdef __cplusplus
}
#endif
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_GPPortType swig_types[0]
#define SWIGTYPE_p_SwigPyObject swig_types[1]
#define SWIGTYPE_p__GPPortInfo swig_types[2]
#define SWIGTYPE_p__GPPortInfoList swig_types[3]
#define SWIGTYPE_p_char swig_types[4]
#define SWIGTYPE_p_p__GPPortInfo swig_types[5]
#define SWIGTYPE_p_p__GPPortInfoList swig_types[6]
#define SWIGTYPE_p_p_char swig_types[7]
static swig_type_info *swig_types[9];
static swig_module_info swig_module = {swig_types, 8, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery
/*-----------------------------------------------
@(target):= _port_info_list.so
------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_init PyInit__port_info_list
#else
# define SWIG_init init_port_info_list
#endif
#define SWIG_name "_port_info_list"
#define SWIG_as_voidptr(a) (void *)((const void *)(a))
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
#include
#include "gphoto2/gphoto2.h"
PyObject *PyExc_GPhoto2Error = NULL;
SWIGINTERN void _GPPortInfo_get_name(struct _GPPortInfo *self,char **name){
int result = gp_port_info_get_name (self, name);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _GPPortInfo_get_path(struct _GPPortInfo *self,char **path){
int result = gp_port_info_get_path (self, path);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERNINLINE PyObject*
SWIG_From_int (int value)
{
return PyInt_FromLong((long) value);
}
SWIGINTERN void _GPPortInfo_get_type(struct _GPPortInfo *self,GPPortType *type){
int result = gp_port_info_get_type (self, type);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN int _GPPortInfoList___len__(struct _GPPortInfoList *self){
int result = gp_port_info_list_count (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
return result;
}
#include
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
# define LLONG_MAX __LONG_LONG_MAX__
# define LLONG_MIN (-LLONG_MAX - 1LL)
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif
SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
int res = SWIG_TypeError;
if (PyFloat_Check(obj)) {
if (val) *val = PyFloat_AsDouble(obj);
return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
} else if (PyInt_Check(obj)) {
if (val) *val = (double) PyInt_AsLong(obj);
return SWIG_OK;
#endif
} else if (PyLong_Check(obj)) {
double v = PyLong_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
double d = PyFloat_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = d;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
} else {
PyErr_Clear();
}
}
}
#endif
return res;
}
#include
#include
SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
double x = *d;
if ((min <= x && x <= max)) {
double fx = floor(x);
double cx = ceil(x);
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
if ((errno == EDOM) || (errno == ERANGE)) {
errno = 0;
} else {
double summ, reps, diff;
if (rd < x) {
diff = x - rd;
} else if (rd > x) {
diff = rd - x;
} else {
return 1;
}
summ = rd + x;
reps = diff/summ;
if (reps < 8*DBL_EPSILON) {
*d = rd;
return 1;
}
}
}
return 0;
}
SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
} else
#endif
if (PyLong_Check(obj)) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
return SWIG_OverflowError;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
long v = PyInt_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
if (val) *val = (long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
long v;
int res = SWIG_AsVal_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v < INT_MIN || v > INT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = (int)(v);
}
}
return res;
}
SWIGINTERN void _GPPortInfoList___getitem__(struct _GPPortInfoList *self,int idx,GPPortInfo *info){
if (idx < 0 || idx >= gp_port_info_list_count(self)) {
PyErr_SetString(PyExc_IndexError, "GPPortInfoList index out of range");
return;
}
{
int error = gp_port_info_list_get_info(self, idx, info);
if (error < GP_OK) {
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
return;
}
}
}
SWIGINTERN struct _GPPortInfoList *new__GPPortInfoList(void){
struct _GPPortInfoList *result;
int error = gp_port_info_list_new(&result);
if (error < GP_OK)
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
return result;
}
SWIGINTERN void delete__GPPortInfoList(struct _GPPortInfoList *self){
int error = gp_port_info_list_free(self);
if (error < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
}
SWIGINTERN void _GPPortInfoList_append(struct _GPPortInfoList *self,GPPortInfo info){
int result = gp_port_info_list_append (self, info);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _GPPortInfoList_load(struct _GPPortInfoList *self){
int result = gp_port_info_list_load (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN int _GPPortInfoList_count(struct _GPPortInfoList *self){
int result = gp_port_info_list_count (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
return result;
}
SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
static int init = 0;
static swig_type_info* info = 0;
if (!init) {
info = SWIG_TypeQuery("_p_char");
init = 1;
}
return info;
}
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (PyBytes_Check(obj))
#else
if (PyUnicode_Check(obj))
#endif
#else
if (PyString_Check(obj))
#endif
{
char *cstr; Py_ssize_t len;
int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (!alloc && cptr) {
/* We can't allow converting without allocation, since the internal
representation of string in Python 3 is UCS-2/UCS-4 but we require
a UTF-8 representation.
TODO(bhy) More detailed explanation */
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (alloc)
*alloc = SWIG_NEWOBJ;
#endif
if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#else
if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#endif
if (cptr) {
if (alloc) {
if (*alloc == SWIG_NEWOBJ) {
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
*alloc = SWIG_NEWOBJ;
} else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
}
} else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
*cptr = PyBytes_AsString(obj);
#else
assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
*cptr = SWIG_Python_str_AsChar(obj);
if (!*cptr)
ret = SWIG_TypeError;
#endif
}
}
if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
Py_XDECREF(obj);
#endif
return ret;
} else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
if (PyUnicode_Check(obj)) {
char *cstr; Py_ssize_t len;
if (!alloc && cptr) {
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
if (cptr) {
if (alloc) *alloc = SWIG_NEWOBJ;
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
}
if (psize) *psize = len + 1;
Py_XDECREF(obj);
return SWIG_OK;
} else {
Py_XDECREF(obj);
}
}
#endif
#endif
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
if (pchar_descriptor) {
void* vptr = 0;
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
if (cptr) *cptr = (char *) vptr;
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
if (alloc) *alloc = SWIG_OLDOBJ;
return SWIG_OK;
}
}
}
return SWIG_TypeError;
}
SWIGINTERN int _GPPortInfoList_lookup_path(struct _GPPortInfoList *self,char const *path){
int result = gp_port_info_list_lookup_path (self, path);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
return result;
}
SWIGINTERN int _GPPortInfoList_lookup_name(struct _GPPortInfoList *self,char const *name){
int result = gp_port_info_list_lookup_name (self, name);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
return result;
}
SWIGINTERN void _GPPortInfoList_get_info(struct _GPPortInfoList *self,int const n,GPPortInfo *info){
int result = gp_port_info_list_get_info (self, n, info);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
#if GPHOTO2_VERSION < 0x02051e00
static int gp_port_init_localedir(const char *localedir) {
return GP_ERROR_NOT_SUPPORTED;
}
#endif
#if GPHOTO2_VERSION < 0x02051800
int GP_PORT_IP = GP_PORT_USB_SCSI + 1;
#endif
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
if (carray) {
if (size > INT_MAX) {
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
return pchar_descriptor ?
SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
} else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
#else
return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
#endif
#else
return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
#endif
}
} else {
return SWIG_Py_Void();
}
}
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtr(const char *cptr)
{
return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_GPPortInfo_get_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfo *arg1 = (struct _GPPortInfo *) 0 ;
char **arg2 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *temp2 ;
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "GPPortInfo_get_name takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPortInfo_get_name" "', argument " "1"" of type '" "struct _GPPortInfo *""'");
}
arg1 = (struct _GPPortInfo *)(argp1);
{
_GPPortInfo_get_name(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg2 ? PyString_FromString(*arg2) : SWIG_Py_Void());
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPortInfo_get_path(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfo *arg1 = (struct _GPPortInfo *) 0 ;
char **arg2 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *temp2 ;
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "GPPortInfo_get_path takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPortInfo_get_path" "', argument " "1"" of type '" "struct _GPPortInfo *""'");
}
arg1 = (struct _GPPortInfo *)(argp1);
{
_GPPortInfo_get_path(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg2 ? PyString_FromString(*arg2) : SWIG_Py_Void());
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPortInfo_get_type(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfo *arg1 = (struct _GPPortInfo *) 0 ;
GPPortType *arg2 = (GPPortType *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
GPPortType temp2 ;
int res2 = SWIG_TMPOBJ ;
arg2 = &temp2;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "GPPortInfo_get_type takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPortInfo_get_type" "', argument " "1"" of type '" "struct _GPPortInfo *""'");
}
arg1 = (struct _GPPortInfo *)(argp1);
{
_GPPortInfo_get_type(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
if (SWIG_IsTmpObj(res2)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
} else {
int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_GPPortType, new_flags));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_GPPortInfo(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfo *arg1 = (struct _GPPortInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_GPPortInfo takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfo, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GPPortInfo" "', argument " "1"" of type '" "struct _GPPortInfo *""'");
}
arg1 = (struct _GPPortInfo *)(argp1);
free((char *) arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GPPortInfo) /* defines _wrap_delete_GPPortInfo_destructor_closure */
SWIGINTERN PyObject *_wrap_GPPortInfoList___len__(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfoList *arg1 = (struct _GPPortInfoList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "GPPortInfoList___len__ takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPortInfoList___len__" "', argument " "1"" of type '" "struct _GPPortInfoList *""'");
}
arg1 = (struct _GPPortInfoList *)(argp1);
{
result = (int)_GPPortInfoList___len__(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPortInfoList___getitem__(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfoList *arg1 = (struct _GPPortInfoList *) 0 ;
int arg2 ;
GPPortInfo *arg3 = (GPPortInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
GPPortInfo temp3 ;
PyObject * obj1 = 0 ;
{
temp3 = NULL;
arg3 = &temp3;
}
(void)self;
if (!PyArg_UnpackTuple(args, "GPPortInfoList___getitem__", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPortInfoList___getitem__" "', argument " "1"" of type '" "struct _GPPortInfoList *""'");
}
arg1 = (struct _GPPortInfoList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GPPortInfoList___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
{
_GPPortInfoList___getitem__(arg1,arg2,arg3);
if (PyErr_Occurred() != NULL) {
goto fail;
}
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p__GPPortInfo, 0));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN int _wrap_new_GPPortInfoList(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
struct _GPPortInfoList *result = 0 ;
(void)self;
if (!SWIG_Python_CheckNoKeywords(kwargs, "new_GPPortInfoList")) SWIG_fail;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "new_GPPortInfoList takes no arguments");
{
result = (struct _GPPortInfoList *)new__GPPortInfoList();
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__GPPortInfoList, SWIG_BUILTIN_INIT | 0 );
return resultobj == Py_None ? -1 : 0;
fail:
return -1;
}
SWIGINTERN PyObject *_wrap_delete_GPPortInfoList(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfoList *arg1 = (struct _GPPortInfoList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_GPPortInfoList takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfoList, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GPPortInfoList" "', argument " "1"" of type '" "struct _GPPortInfoList *""'");
}
arg1 = (struct _GPPortInfoList *)(argp1);
{
delete__GPPortInfoList(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPortInfoList_append(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfoList *arg1 = (struct _GPPortInfoList *) 0 ;
GPPortInfo arg2 = (GPPortInfo) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "GPPortInfoList_append", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPortInfoList_append" "', argument " "1"" of type '" "struct _GPPortInfoList *""'");
}
arg1 = (struct _GPPortInfoList *)(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPPortInfo, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GPPortInfoList_append" "', argument " "2"" of type '" "GPPortInfo""'");
}
arg2 = (GPPortInfo)(argp2);
{
if (PyErr_WarnEx(PyExc_DeprecationWarning,"_GPPortInfoList::append"" is deprecated and"
" will be removed in a future release", 1) < 0) SWIG_fail;
_GPPortInfoList_append(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPortInfoList_load(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfoList *arg1 = (struct _GPPortInfoList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "GPPortInfoList_load takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPortInfoList_load" "', argument " "1"" of type '" "struct _GPPortInfoList *""'");
}
arg1 = (struct _GPPortInfoList *)(argp1);
{
_GPPortInfoList_load(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPortInfoList_count(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfoList *arg1 = (struct _GPPortInfoList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int result;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "GPPortInfoList_count takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPortInfoList_count" "', argument " "1"" of type '" "struct _GPPortInfoList *""'");
}
arg1 = (struct _GPPortInfoList *)(argp1);
{
result = (int)_GPPortInfoList_count(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPortInfoList_lookup_path(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfoList *arg1 = (struct _GPPortInfoList *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "GPPortInfoList_lookup_path", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPortInfoList_lookup_path" "', argument " "1"" of type '" "struct _GPPortInfoList *""'");
}
arg1 = (struct _GPPortInfoList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GPPortInfoList_lookup_path" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
{
result = (int)_GPPortInfoList_lookup_path(arg1,(char const *)arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPortInfoList_lookup_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfoList *arg1 = (struct _GPPortInfoList *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "GPPortInfoList_lookup_name", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPortInfoList_lookup_name" "', argument " "1"" of type '" "struct _GPPortInfoList *""'");
}
arg1 = (struct _GPPortInfoList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GPPortInfoList_lookup_name" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
{
result = (int)_GPPortInfoList_lookup_name(arg1,(char const *)arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPortInfoList_get_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPortInfoList *arg1 = (struct _GPPortInfoList *) 0 ;
int arg2 ;
GPPortInfo *arg3 = (GPPortInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
GPPortInfo temp3 ;
PyObject * obj1 = 0 ;
{
temp3 = NULL;
arg3 = &temp3;
}
(void)self;
if (!PyArg_UnpackTuple(args, "GPPortInfoList_get_info", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPortInfoList_get_info" "', argument " "1"" of type '" "struct _GPPortInfoList *""'");
}
arg1 = (struct _GPPortInfoList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GPPortInfoList_get_info" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
{
_GPPortInfoList_get_info(arg1,arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p__GPPortInfo, 0));
}
return resultobj;
fail:
return NULL;
}
SWIGPY_LENFUNC_CLOSURE(_wrap_GPPortInfoList___len__) /* defines _wrap_GPPortInfoList___len___lenfunc_closure */
SWIGPY_SSIZEARGFUNC_CLOSURE(_wrap_GPPortInfoList___getitem__) /* defines _wrap_GPPortInfoList___getitem___ssizeargfunc_closure */
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GPPortInfoList) /* defines _wrap_delete_GPPortInfoList_destructor_closure */
SWIGINTERN PyObject *_wrap_gp_port_info_get_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPortInfo arg1 = (GPPortInfo) 0 ;
char **arg2 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *temp2 ;
PyObject * obj0 = 0 ;
int result;
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_info_get_name", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPortInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_info_get_name" "', argument " "1"" of type '" "GPPortInfo""'");
}
arg1 = (GPPortInfo)(argp1);
result = (int)gp_port_info_get_name(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg2 ? PyString_FromString(*arg2) : SWIG_Py_Void());
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_info_get_path(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPortInfo arg1 = (GPPortInfo) 0 ;
char **arg2 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
char *temp2 ;
PyObject * obj0 = 0 ;
int result;
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_info_get_path", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPortInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_info_get_path" "', argument " "1"" of type '" "GPPortInfo""'");
}
arg1 = (GPPortInfo)(argp1);
result = (int)gp_port_info_get_path(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
resultobj = SWIG_Python_AppendOutput(resultobj,
*arg2 ? PyString_FromString(*arg2) : SWIG_Py_Void());
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_info_get_type(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPortInfo arg1 = (GPPortInfo) 0 ;
GPPortType *arg2 = (GPPortType *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
GPPortType temp2 ;
int res2 = SWIG_TMPOBJ ;
PyObject * obj0 = 0 ;
int result;
arg2 = &temp2;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_info_get_type", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPortInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_info_get_type" "', argument " "1"" of type '" "GPPortInfo""'");
}
arg1 = (GPPortInfo)(argp1);
result = (int)gp_port_info_get_type(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
if (SWIG_IsTmpObj(res2)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
} else {
int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_GPPortType, new_flags));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_info_list_new(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPortInfoList **arg1 = (GPPortInfoList **) 0 ;
GPPortInfoList *temp1 ;
int result;
{
temp1 = NULL;
arg1 = &temp1;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_info_list_new", 0, 0)) SWIG_fail;
result = (int)gp_port_info_list_new(arg1);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg1, SWIGTYPE_p__GPPortInfoList, SWIG_POINTER_OWN));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_info_list_append(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPortInfoList *arg1 = (GPPortInfoList *) 0 ;
GPPortInfo arg2 = (GPPortInfo) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_info_list_append", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_info_list_append" "', argument " "1"" of type '" "GPPortInfoList *""'");
}
arg1 = (GPPortInfoList *)(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPPortInfo, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_port_info_list_append" "', argument " "2"" of type '" "GPPortInfo""'");
}
arg2 = (GPPortInfo)(argp2);
{
if (PyErr_WarnEx(PyExc_DeprecationWarning,"gp_port_info_list_append"" is deprecated and"
" will be removed in a future release", 1) < 0) SWIG_fail;
result = (int)gp_port_info_list_append(arg1,arg2);
}
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_info_list_load(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPortInfoList *arg1 = (GPPortInfoList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_info_list_load", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_info_list_load" "', argument " "1"" of type '" "GPPortInfoList *""'");
}
arg1 = (GPPortInfoList *)(argp1);
result = (int)gp_port_info_list_load(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_info_list_count(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPortInfoList *arg1 = (GPPortInfoList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_info_list_count", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_info_list_count" "', argument " "1"" of type '" "GPPortInfoList *""'");
}
arg1 = (GPPortInfoList *)(argp1);
result = (int)gp_port_info_list_count(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_info_list_lookup_path(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPortInfoList *arg1 = (GPPortInfoList *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_info_list_lookup_path", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_info_list_lookup_path" "', argument " "1"" of type '" "GPPortInfoList *""'");
}
arg1 = (GPPortInfoList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_port_info_list_lookup_path" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
result = (int)gp_port_info_list_lookup_path(arg1,(char const *)arg2);
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_info_list_lookup_name(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPortInfoList *arg1 = (GPPortInfoList *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_info_list_lookup_name", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_info_list_lookup_name" "', argument " "1"" of type '" "GPPortInfoList *""'");
}
arg1 = (GPPortInfoList *)(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_port_info_list_lookup_name" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
result = (int)gp_port_info_list_lookup_name(arg1,(char const *)arg2);
resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_info_list_get_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPortInfoList *arg1 = (GPPortInfoList *) 0 ;
int arg2 ;
GPPortInfo *arg3 = (GPPortInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
GPPortInfo temp3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
{
temp3 = NULL;
arg3 = &temp3;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_info_list_get_info", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPortInfoList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_info_list_get_info" "', argument " "1"" of type '" "GPPortInfoList *""'");
}
arg1 = (GPPortInfoList *)(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gp_port_info_list_get_info" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
result = (int)gp_port_info_list_get_info(arg1,arg2,arg3);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg3, SWIGTYPE_p__GPPortInfo, 0));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_message_codeset(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_message_codeset", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_message_codeset" "', argument " "1"" of type '" "char const *""'");
}
arg1 = (char *)(buf1);
result = (char *)gp_port_message_codeset((char const *)arg1);
resultobj = SWIG_FromCharPtr((const char *)result);
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_init_localedir(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_init_localedir", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_init_localedir" "', argument " "1"" of type '" "char const *""'");
}
arg1 = (char *)(buf1);
result = (int)gp_port_init_localedir((char const *)arg1);
resultobj = SWIG_From_int((int)(result));
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
static PyMethodDef SwigMethods[] = {
{ "gp_port_info_get_name", _wrap_gp_port_info_get_name, METH_VARARGS, "\n"
"gp_port_info_get_name(info) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"info: gphoto2.GPPortInfo\n"
"\n"
"Get name of a specific port entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `info` : \n"
" a #GPPortInfo \n"
"* `name` : \n"
" a pointer to a char* which will receive the name \n"
"\n"
"Retreives the name of the passed in GPPortInfo, by reference. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.PortInfo.get_name\n"
""},
{ "gp_port_info_get_path", _wrap_gp_port_info_get_path, METH_VARARGS, "\n"
"gp_port_info_get_path(info) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"info: gphoto2.GPPortInfo\n"
"\n"
"Get path of a specific port entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `info` : \n"
" a #GPPortInfo \n"
"* `path` : \n"
" a pointer to a char* which will receive the path \n"
"\n"
"Retreives the path of the passed in GPPortInfo, by reference. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.PortInfo.get_path\n"
""},
{ "gp_port_info_get_type", _wrap_gp_port_info_get_type, METH_VARARGS, "\n"
"gp_port_info_get_type(info) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"info: gphoto2.GPPortInfo\n"
"\n"
"Get type of a specific port entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `info` : \n"
" a #GPPortInfo \n"
"* `type` : \n"
" a pointer to a GPPortType variable which will receive the type \n"
"\n"
"Retreives the type of the passed in GPPortInfo \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.PortInfo.get_type\n"
""},
{ "gp_port_info_list_new", _wrap_gp_port_info_list_new, METH_VARARGS, "\n"
"gp_port_info_list_new() -> int\n"
"Create a new GPPortInfoList. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" pointer to a GPPortInfoList* which is allocated \n"
"\n"
"Creates a new list which can later be filled with port infos\n"
"(#GPPortInfo) using gp_port_info_list_load. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.PortInfoList\n"
""},
{ "gp_port_info_list_append", _wrap_gp_port_info_list_append, METH_VARARGS, "\n"
"gp_port_info_list_append(list, info) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.GPPortInfoList\n"
"info: gphoto2.GPPortInfo\n"
"\n"
"This function is deprecated and will be removed in a future release.\n"
""},
{ "gp_port_info_list_load", _wrap_gp_port_info_list_load, METH_VARARGS, "\n"
"gp_port_info_list_load(list) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.GPPortInfoList\n"
"\n"
"Load system ports. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a #GPPortInfoList \n"
"\n"
"Searches the system for io-drivers and appends them to the list. You\n"
"would normally call this function once after gp_port_info_list_new and\n"
"then use this list in order to supply gp_port_set_info with parameters\n"
"or to do autodetection. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.PortInfoList.load\n"
""},
{ "gp_port_info_list_count", _wrap_gp_port_info_list_count, METH_VARARGS, "\n"
"gp_port_info_list_count(list) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.GPPortInfoList\n"
"\n"
"Number of ports in the list. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a #GPPortInfoList \n"
"\n"
"Returns the number of entries in the passed list. \n"
"\n"
"Returns\n"
"-------\n"
"The number of entries or a gphoto2 error code\n"
"\n"
"See also gphoto2.PortInfoList.count\n"
""},
{ "gp_port_info_list_lookup_path", _wrap_gp_port_info_list_lookup_path, METH_VARARGS, "\n"
"gp_port_info_list_lookup_path(list, path) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.GPPortInfoList\n"
"path: str\n"
"\n"
"Lookup a specific path in the list. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a #GPPortInfoList \n"
"* `path` : \n"
" a path \n"
"\n"
"Looks for an entry in the list with the supplied path. If no exact match\n"
"can be found, a regex search will be performed in the hope some driver\n"
"claimed ports like \"serial:*\". \n"
"\n"
"Returns\n"
"-------\n"
"The index of the entry or a gphoto2 error code\n"
"\n"
"See also gphoto2.PortInfoList.lookup_path\n"
""},
{ "gp_port_info_list_lookup_name", _wrap_gp_port_info_list_lookup_name, METH_VARARGS, "\n"
"gp_port_info_list_lookup_name(list, name) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.GPPortInfoList\n"
"name: str\n"
"\n"
"Look up a name in the list. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a #GPPortInfoList \n"
"* `name` : \n"
" a name \n"
"\n"
"Looks for an entry in the list with the exact given name. \n"
"\n"
"Returns\n"
"-------\n"
"The index of the entry or a gphoto2 error code\n"
"\n"
"See also gphoto2.PortInfoList.lookup_name\n"
""},
{ "gp_port_info_list_get_info", _wrap_gp_port_info_list_get_info, METH_VARARGS, "\n"
"gp_port_info_list_get_info(list, n) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"list: gphoto2.GPPortInfoList\n"
"n: int\n"
"\n"
"Get port information of specific entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a #GPPortInfoList \n"
"* `n` : \n"
" the index of the entry \n"
"* `info` : \n"
" the returned information \n"
"\n"
"Returns a pointer to the current port entry. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.PortInfoList.get_info\n"
""},
{ "gp_port_message_codeset", _wrap_gp_port_message_codeset, METH_VARARGS, "\n"
"gp_port_message_codeset(arg1) -> char const *\n"
"\n"
"Parameters\n"
"----------\n"
"arg1: str\n"
"\n"
"Specify codeset for translations. \n"
"\n"
"This function specifies the codeset that is used for the translated\n"
"strings that are passed back by the libgphoto2_port functions. \n"
"\n"
"This function is called by the gp_message_codeset() function, so there\n"
"is no need to call it yourself. \n"
"\n"
"Parameters\n"
"----------\n"
"* `codeset` : \n"
" new codeset to use \n"
"\n"
"Returns\n"
"-------\n"
"the previous codeset\n"
""},
{ "gp_port_init_localedir", _wrap_gp_port_init_localedir, METH_VARARGS, "\n"
"gp_port_init_localedir(localedir) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"localedir: str\n"
"\n"
"Initialize the localedir directory for the libgphoto2_port gettext\n"
"domain. \n"
"\n"
"Override the localedir directory libgphoto2_port uses for its message\n"
"translations. \n"
"\n"
"This function is called by the gp_init_localedir() function, so if you\n"
"are calling that already, there is no need to call\n"
"gp_port_init_localedir() yourself. \n"
"\n"
"You only need to call this if you have a non-standard installation where\n"
"the locale files are at a location which differs from the compiled in\n"
"default location. \n"
"\n"
"If you need to call this function, call it before calling any non-\n"
"initialization function. \n"
"\n"
"Internally, this will make sure bindtextdomain() is called for the\n"
"relevant gettext text domain(s). \n"
"\n"
"Parameters\n"
"----------\n"
"* `localedir` : \n"
" Root directory of libgphoto2_port's localization files. If NULL, use\n"
" the compiled in default value, which will be something like\n"
" \"/usr/share/locale\". \n"
"\n"
"Returns\n"
"-------\n"
"gphoto2 error code.\n"
""},
{ NULL, NULL, 0, NULL }
};
static SwigPyGetSet GPPortInfo___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin___GPPortInfo_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"\n"
"get_name\n"
"Get name of a specific port entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `info` : \n"
" a #GPPortInfo \n"
"* `name` : \n"
" a pointer to a char* which will receive the name \n"
"\n"
"Retreives the name of the passed in GPPortInfo, by reference. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_port_info_get_name\n"
"", &GPPortInfo___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___GPPortInfo_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___GPPortInfo_methods[] = {
{ "get_name", _wrap_GPPortInfo_get_name, METH_VARARGS, "\n"
"get_name(self)\n"
"Get name of a specific port entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `info` : \n"
" a #GPPortInfo \n"
"* `name` : \n"
" a pointer to a char* which will receive the name \n"
"\n"
"Retreives the name of the passed in GPPortInfo, by reference. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_port_info_get_name\n"
"" },
{ "get_path", _wrap_GPPortInfo_get_path, METH_VARARGS, "\n"
"get_path(self)\n"
"Get path of a specific port entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `info` : \n"
" a #GPPortInfo \n"
"* `path` : \n"
" a pointer to a char* which will receive the path \n"
"\n"
"Retreives the path of the passed in GPPortInfo, by reference. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_port_info_get_path\n"
"" },
{ "get_type", _wrap_GPPortInfo_get_type, METH_VARARGS, "\n"
"get_type(self)\n"
"Get type of a specific port entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `info` : \n"
" a #GPPortInfo \n"
"* `type` : \n"
" a pointer to a GPPortType variable which will receive the type \n"
"\n"
"Retreives the type of the passed in GPPortInfo \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_port_info_get_type\n"
"" },
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___GPPortInfo_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.port_info_list.GPPortInfo", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_GPPortInfo_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___GPPortInfo_type.as_number, /* tp_as_number */
&SwigPyBuiltin___GPPortInfo_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___GPPortInfo_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___GPPortInfo_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"::_GPPortInfo", /* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___GPPortInfo_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___GPPortInfo_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___GPPortInfo_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
SwigPyBuiltin_BadInit, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___GPPortInfo_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___GPPortInfo_type};
static SwigPyGetSet GPPortInfoList___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin___GPPortInfoList_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"__len__", &GPPortInfoList___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___GPPortInfoList_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___GPPortInfoList_methods[] = {
{ "__len__", _wrap_GPPortInfoList___len__, METH_VARARGS, "__len__(self) -> int" },
{ "__getitem__", _wrap_GPPortInfoList___getitem__, METH_VARARGS, "\n"
"__getitem__(self, idx)\n"
"\n"
"Parameters\n"
"----------\n"
"idx: int\n"
"\n"
"" },
{ "append", _wrap_GPPortInfoList_append, METH_VARARGS, "\n"
"append(self, info)\n"
"\n"
"Parameters\n"
"----------\n"
"info: gphoto2.GPPortInfo\n"
"\n"
"This function is deprecated and will be removed in a future release.\n"
"" },
{ "load", _wrap_GPPortInfoList_load, METH_VARARGS, "\n"
"load(self)\n"
"Load system ports. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a #GPPortInfoList \n"
"\n"
"Searches the system for io-drivers and appends them to the list. You\n"
"would normally call this function once after gp_port_info_list_new and\n"
"then use this list in order to supply gp_port_set_info with parameters\n"
"or to do autodetection. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_port_info_list_load\n"
"" },
{ "count", _wrap_GPPortInfoList_count, METH_VARARGS, "\n"
"count(self) -> int\n"
"Number of ports in the list. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a #GPPortInfoList \n"
"\n"
"Returns the number of entries in the passed list. \n"
"\n"
"Returns\n"
"-------\n"
"The number of entries or a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_port_info_list_count\n"
"" },
{ "lookup_path", _wrap_GPPortInfoList_lookup_path, METH_VARARGS, "\n"
"lookup_path(self, path) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"path: str\n"
"\n"
"Lookup a specific path in the list. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a #GPPortInfoList \n"
"* `path` : \n"
" a path \n"
"\n"
"Looks for an entry in the list with the supplied path. If no exact match\n"
"can be found, a regex search will be performed in the hope some driver\n"
"claimed ports like \"serial:*\". \n"
"\n"
"Returns\n"
"-------\n"
"The index of the entry or a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_port_info_list_lookup_path\n"
"" },
{ "lookup_name", _wrap_GPPortInfoList_lookup_name, METH_VARARGS, "\n"
"lookup_name(self, name) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"name: str\n"
"\n"
"Look up a name in the list. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a #GPPortInfoList \n"
"* `name` : \n"
" a name \n"
"\n"
"Looks for an entry in the list with the exact given name. \n"
"\n"
"Returns\n"
"-------\n"
"The index of the entry or a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_port_info_list_lookup_name\n"
"" },
{ "get_info", _wrap_GPPortInfoList_get_info, METH_VARARGS, "\n"
"get_info(self, n)\n"
"\n"
"Parameters\n"
"----------\n"
"n: int const\n"
"\n"
"Get port information of specific entry. \n"
"\n"
"Parameters\n"
"----------\n"
"* `list` : \n"
" a #GPPortInfoList \n"
"* `n` : \n"
" the index of the entry \n"
"* `info` : \n"
" the returned information \n"
"\n"
"Returns a pointer to the current port entry. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
"\n"
"See also gphoto2.gp_port_info_list_get_info\n"
"" },
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___GPPortInfoList_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.port_info_list.GPPortInfoList", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_GPPortInfoList_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___GPPortInfoList_type.as_number, /* tp_as_number */
&SwigPyBuiltin___GPPortInfoList_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___GPPortInfoList_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___GPPortInfoList_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"::_GPPortInfoList", /* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___GPPortInfoList_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___GPPortInfoList_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___GPPortInfoList_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
_wrap_new_GPPortInfoList, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
_wrap_GPPortInfoList___len___lenfunc_closure, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
_wrap_GPPortInfoList___getitem___ssizeargfunc_closure, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___GPPortInfoList_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___GPPortInfoList_type};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_GPPortType = {"_p_GPPortType", "GPPortType *|enum GPPortType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwigPyObject = {"_p_SwigPyObject", "SwigPyObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortInfo = {"_p__GPPortInfo", "GPPortInfo|struct _GPPortInfo *|_GPPortInfo *", 0, 0, (void*)&SwigPyBuiltin___GPPortInfo_clientdata, 0};
static swig_type_info _swigt__p__GPPortInfoList = {"_p__GPPortInfoList", "GPPortInfoList *|struct _GPPortInfoList *|_GPPortInfoList *", 0, 0, (void*)&SwigPyBuiltin___GPPortInfoList_clientdata, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__GPPortInfo = {"_p_p__GPPortInfo", "GPPortInfo *|struct _GPPortInfo **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__GPPortInfoList = {"_p_p__GPPortInfoList", "GPPortInfoList **|struct _GPPortInfoList **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_GPPortType,
&_swigt__p_SwigPyObject,
&_swigt__p__GPPortInfo,
&_swigt__p__GPPortInfoList,
&_swigt__p_char,
&_swigt__p_p__GPPortInfo,
&_swigt__p_p__GPPortInfoList,
&_swigt__p_p_char,
};
static swig_cast_info _swigc__p_GPPortType[] = { {&_swigt__p_GPPortType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwigPyObject[] = { {&_swigt__p_SwigPyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortInfo[] = { {&_swigt__p__GPPortInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortInfoList[] = { {&_swigt__p__GPPortInfoList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__GPPortInfo[] = { {&_swigt__p_p__GPPortInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__GPPortInfoList[] = { {&_swigt__p_p__GPPortInfoList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_GPPortType,
_swigc__p_SwigPyObject,
_swigc__p__GPPortInfo,
_swigc__p__GPPortInfoList,
_swigc__p_char,
_swigc__p_p__GPPortInfo,
_swigc__p_p__GPPortInfoList,
_swigc__p_p_char,
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};
#ifdef __cplusplus
}
#endif
static PyTypeObject *builtin_bases[2];
/* -----------------------------------------------------------------------------
* Type initialization:
* This problem is tough by the requirement that no dynamic
* memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
* to swig_type_info structures, we need some lookup code at initialization.
* The idea is that swig generates all the structures that are needed.
* The runtime then collects these partially filled structures.
* The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
* The generated swig_type_info structures are assigned statically to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
* cast linked list. The cast data is initially stored in something like a
* two-dimensional array. Each row corresponds to a type (there are the same
* number of rows as there are in the swig_type_initial array). Each entry in
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
* we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
* First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
* 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
* swig_cast_info to the linked list (because the cast->type) pointer will
* be correct.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif
#if 0
#define SWIGRUNTIME_DEBUG
#endif
#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif
SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
size_t i;
swig_module_info *module_head, *iter;
int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* Initialize the swig_module */
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
init = 1;
} else {
init = 0;
}
/* Try and load any already created modules */
module_head = SWIG_GetModule(clientdata);
if (!module_head) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
iter=module_head;
do {
if (iter==&swig_module) {
/* Our module is already in the list, so there's nothing more to do. */
return;
}
iter=iter->next;
} while (iter!= module_head);
/* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpreters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
if (init == 0) return;
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
if (swig_module.next != &swig_module) {
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
}
if (type) {
/* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
if (swig_module.type_initial[i]->clientdata) {
type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
}
} else {
type = swig_module.type_initial[i];
}
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
if (swig_module.next != &swig_module) {
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
}
if (ret) {
if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
cast->type = ret;
ret = 0;
} else {
/* Check for casting already in the list */
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
if (!ocast) ret = 0;
}
}
if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
if (type->cast) {
type->cast->prev = cast;
cast->next = type->cast;
}
type->cast = cast;
}
cast++;
}
/* Set entry in modules->types array equal to the type */
swig_module.types[i] = type;
}
swig_module.types[i] = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("**** SWIG_InitializeModule: Cast List ******\n");
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
++j;
}
printf("---- Total casts: %d\n",j);
}
printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}
/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types. It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
size_t i;
swig_cast_info *equiv;
static int init_run = 0;
if (init_run) return;
init_run = 1;
for (i = 0; i < swig_module.size; i++) {
if (swig_module.types[i]->clientdata) {
equiv = swig_module.types[i]->cast;
while (equiv) {
if (!equiv->converter) {
if (equiv->type && !equiv->type->clientdata)
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
}
equiv = equiv->next;
}
}
}
}
#ifdef __cplusplus
#if 0
{
/* c-mode */
#endif
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* constants/methods manipulation
* ----------------------------------------------------------------------------- */
/* Install Constants */
SWIGINTERN void
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
PyObject *obj = 0;
size_t i;
for (i = 0; constants[i].type; ++i) {
switch(constants[i].type) {
case SWIG_PY_POINTER:
obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_PY_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
break;
default:
obj = 0;
break;
}
if (obj) {
PyDict_SetItemString(d, constants[i].name, obj);
Py_DECREF(obj);
}
}
}
/* -----------------------------------------------------------------------------
* Patch %callback methods' docstrings to hold the callback ptrs
* -----------------------------------------------------------------------------*/
SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
size_t i;
for (i = 0; methods[i].ml_name; ++i) {
const char *c = methods[i].ml_doc;
if (!c) continue;
c = strstr(c, "swig_ptr: ");
if (c) {
int j;
const swig_const_info *ci = 0;
const char *name = c + 10;
for (j = 0; const_table[j].type; ++j) {
if (strncmp(const_table[j].name, name,
strlen(const_table[j].name)) == 0) {
ci = &(const_table[j]);
break;
}
}
if (ci) {
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
if (ptr) {
size_t shift = (ci->ptype) - types;
swig_type_info *ty = types_initial[shift];
size_t ldoc = (c - methods[i].ml_doc);
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
char *ndoc = (char*)malloc(ldoc + lptr + 10);
if (ndoc) {
char *buff = ndoc;
memcpy(buff, methods[i].ml_doc, ldoc);
buff += ldoc;
memcpy(buff, "swig_ptr: ", 10);
buff += 10;
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
methods[i].ml_doc = ndoc;
}
}
}
}
}
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------*
* Partial Init method
* -----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
PyObject *m, *d, *md, *globals;
#if PY_VERSION_HEX >= 0x03000000
static struct PyModuleDef SWIG_module = {
PyModuleDef_HEAD_INIT,
SWIG_name,
NULL,
-1,
SwigMethods,
NULL,
NULL,
NULL,
NULL
};
#endif
#if defined(SWIGPYTHON_BUILTIN)
static SwigPyClientData SwigPyObject_clientdata = {
0, 0, 0, 0, 0, 0, 0
};
static PyGetSetDef this_getset_def = {
(char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
};
static SwigPyGetSet thisown_getset_closure = {
SwigPyObject_own,
SwigPyObject_own
};
static PyGetSetDef thisown_getset_def = {
(char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
};
PyTypeObject *builtin_pytype;
int builtin_base_count;
swig_type_info *builtin_basetype;
PyObject *tuple;
PyGetSetDescrObject *static_getset;
PyTypeObject *metatype;
PyTypeObject *swigpyobject;
SwigPyClientData *cd;
PyObject *public_interface, *public_symbol;
PyObject *this_descr;
PyObject *thisown_descr;
PyObject *self = 0;
int i;
(void)builtin_pytype;
(void)builtin_base_count;
(void)builtin_basetype;
(void)tuple;
(void)static_getset;
(void)self;
/* Metaclass is used to implement static member variables */
metatype = SwigPyObjectType();
assert(metatype);
#endif
(void)globals;
/* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
SWIG_This();
SWIG_Python_TypeCache();
SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
SwigPyObject_type();
#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
#if PY_VERSION_HEX >= 0x03000000
m = PyModule_Create(&SWIG_module);
#else
m = Py_InitModule(SWIG_name, SwigMethods);
#endif
md = d = PyModule_GetDict(m);
(void)md;
SWIG_InitializeModule(0);
#ifdef SWIGPYTHON_BUILTIN
swigpyobject = SwigPyObject_TypeOnce();
SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
if (!cd) {
SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
SwigPyObject_clientdata.pytype = swigpyobject;
} else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
return NULL;
# else
return;
# endif
}
/* All objects have a 'this' attribute */
this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
(void)this_descr;
/* All objects have a 'thisown' attribute */
thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
(void)thisown_descr;
public_interface = PyList_New(0);
public_symbol = 0;
(void)public_symbol;
PyDict_SetItemString(md, "__all__", public_interface);
Py_DECREF(public_interface);
for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
for (i = 0; swig_const_table[i].name != 0; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
SWIG_InstallConstants(d,swig_const_table);
{
PyObject *module = PyImport_ImportModule("gphoto2");
if (module != NULL) {
PyExc_GPhoto2Error = PyObject_GetAttrString(module, "GPhoto2Error");
Py_DECREF(module);
}
if (PyExc_GPhoto2Error == NULL)
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
/* type '::_GPPortInfo' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___GPPortInfo_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'GPPortInfo'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "GPPortInfo", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "GPPortInfo");
d = md;
/* type '::_GPPortInfoList' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___GPPortInfoList_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'GPPortInfoList'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "GPPortInfoList", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "GPPortInfoList");
d = md;
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_NONE",SWIG_From_int((int)(GP_PORT_NONE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_SERIAL",SWIG_From_int((int)(GP_PORT_SERIAL)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_USB",SWIG_From_int((int)(GP_PORT_USB)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_DISK",SWIG_From_int((int)(GP_PORT_DISK)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_PTPIP",SWIG_From_int((int)(GP_PORT_PTPIP)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_USB_DISK_DIRECT",SWIG_From_int((int)(GP_PORT_USB_DISK_DIRECT)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_USB_SCSI",SWIG_From_int((int)(GP_PORT_USB_SCSI)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_IP",SWIG_From_int((int)(GP_PORT_IP)));
#if PY_VERSION_HEX >= 0x03000000
return m;
#else
return;
#endif
}
python-gphoto2-2.5.1/src/swig-gp2_5_31/port_log.py 0000664 0000000 0000000 00000003453 14703210004 0021570 0 ustar 00root root 0000000 0000000 # This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
# Pull in all the attributes from the low-level C/C++ module
if __package__ or "." in __name__:
from ._port_log import *
else:
from _port_log import *
import logging
def _gphoto2_logger_cb(level, domain, msg, data):
log_func, mapping = data
if level in mapping:
log_func(mapping[level], '(%s) %s', domain, msg)
else:
log_func(logging.ERROR, '%d (%s) %s', level, domain, msg)
def use_python_logging(mapping={}):
"""Install a callback to receive gphoto2 errors and forward them
to Python's logging system.
The return value is a tuple containing an error code and a Python object
containing details of the callback. Deleting this object will uninstall
the callback.
Parameters
----------
* `mapping` :
a dictionary mapping any of the four gphoto2 logging severity
levels to a Python logging level. Note that anything below Python
DEBUG level will not be forwarded.
Returns
-------
a tuple containing an id or error code and a callback reference object.
"""
full_mapping = {
GP_LOG_ERROR : logging.WARNING,
GP_LOG_VERBOSE : logging.INFO,
GP_LOG_DEBUG : logging.DEBUG,
GP_LOG_DATA : logging.DEBUG - 5,
}
full_mapping.update(mapping)
log_func = logging.getLogger('gphoto2').log
for level in (GP_LOG_DATA, GP_LOG_DEBUG, GP_LOG_VERBOSE, GP_LOG_ERROR):
if full_mapping[level] >= logging.DEBUG:
break
return gp_log_add_func(level, _gphoto2_logger_cb, (log_func, full_mapping))
python-gphoto2-2.5.1/src/swig-gp2_5_31/port_log_wrap.c 0000664 0000000 0000000 00000524653 14703210004 0022425 0 ustar 00root root 0000000 0000000 /* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (https://www.swig.org).
* Version 4.1.1
*
* Do not make changes to this file unless you know what you are doing - modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
#define SWIG_VERSION 0x040101
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_BUILTIN
#define SWIGPYTHON_FASTPROXY
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if defined(__GNUC__)
# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
/* Intel's compiler complains if a variable which was never initialised is
* cast to void, which is a common idiom which we use to indicate that we
* are aware a variable isn't used. So we just silence that warning.
* See: https://github.com/swig/swig/issues/192 for more discussion.
*/
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include
#endif
#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
* See https://github.com/swig/swig/issues/2090 */
# include
#endif
# undef _DEBUG
# include
# define _DEBUG 1
#else
# include
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
creating a static or dynamic library from the SWIG runtime code.
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
But only do this if strictly necessary, ie, if you have problems
with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif
#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif
/* Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
#define SWIG_POINTER_NO_NULL 0x4
#define SWIG_POINTER_CLEAR 0x8
#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
if (SWIG_IsOK(res)) {
// success code
if (SWIG_IsNewObj(res) {
...
delete *ptr;
} else {
...
}
} else {
// fail code
}
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if () {
if () {
*ptr = ;
return SWIG_NEWOBJ;
} else {
*ptr = ;
return SWIG_OLDOBJ;
}
} else {
return SWIG_BADOBJ;
}
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows returning the 'cast rank', for example, if you have this
int food(double)
int fooi(int);
and you call
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
*/
#define SWIG_OK (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ (SWIG_ERROR)
#define SWIG_OLDOBJ (SWIG_OK)
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
# define SWIG_TypeRank unsigned long
# endif
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
# define SWIG_MAXCASTRANK (2)
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
# define SWIG_AddCast(r) (r)
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
#include
#ifdef __cplusplus
extern "C" {
#endif
typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
void *clientdata; /* language specific type data */
int owndata; /* flag if the structure owns the clientdata */
} swig_type_info;
/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
swig_type_info *type; /* pointer to type that is equivalent to this type */
swig_converter_func converter; /* function to cast the void pointers */
struct swig_cast_info *next; /* pointer to next cast in linked list */
struct swig_cast_info *prev; /* pointer to the previous cast */
} swig_cast_info;
/* Structure used to store module information
* Each module generates one structure like this, and the runtime collects
* all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
size_t size; /* Number of types in this module */
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
swig_type_info **type_initial; /* Array of initially generated type structures */
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
void *clientdata; /* Language specific module data */
} swig_module_info;
/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class" == "Class", etc.
Return 0 when the two name types are equivalent, as in
strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
const char *f2, const char *l2) {
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
while ((*f1 == ' ') && (f1 != l1)) ++f1;
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
return (int)((l1 - f1) - (l2 - f2));
}
/*
Check type equivalence in a name list like ||...
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
}
/*
Check type equivalence in a name list like ||...
Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (strcmp(iter->type->name, c) == 0) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (iter->type == from) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
swig_type_info *lastty = ty;
if (!ty || !ty->dcast) return ty;
while (ty && (ty->dcast)) {
ty = (*ty->dcast)(ptr);
if (ty) lastty = ty;
}
return lastty;
}
/*
Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
return ty->name;
}
/*
Return the pretty name associated with this type,
that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
/* The "str" field contains the equivalent pretty names of the
type, separated by vertical-bar characters. Choose the last
name. It should be the most specific; a fully resolved name
but not necessarily with default template parameters expanded. */
if (!type) return NULL;
if (type->str != NULL) {
const char *last_name = type->str;
const char *s;
for (s = type->str; *s; s++)
if (*s == '|') last_name = s+1;
return last_name;
}
else
return type->name;
}
/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
}
cast = cast->next;
}
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
size_t l = 0;
size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
r = i - 1;
} else {
break;
}
} else if (compare > 0) {
l = i + 1;
}
} else {
break; /* should never happen */
}
} while (l <= r);
}
iter = iter->next;
} while (iter != end);
return 0;
}
/*
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
if (ret) {
return ret;
} else {
/* STEP 2: If the type hasn't been found, do a complete search
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
}
iter = iter->next;
} while (iter != end);
}
/* neither found a match */
return 0;
}
/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
const unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
char d = *(c++);
unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
uu = (unsigned char)((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
uu |= (unsigned char)(d - ('a'-10));
else
return (char *) 0;
*u = uu;
}
return c;
}
/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
char *r = buff;
if ((2*sizeof(void *) + 2) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,&ptr,sizeof(void *));
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
strcpy(r,name);
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
*ptr = (void *) 0;
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sizeof(void *));
}
SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
char *r = buff;
size_t lname = (name ? strlen(name) : 0);
if ((2*sz + 2 + lname) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
if (lname) {
strncpy(r,name,lname+1);
} else {
*r = 0;
}
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
memset(ptr,0,sz);
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sz);
}
#ifdef __cplusplus
}
#endif
/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
#endif
#ifndef Py_TYPE
# define Py_TYPE(op) ((op)->ob_type)
#endif
/* SWIG APIs for compatibility of both Python 2 & 3 */
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
# define SWIG_Python_str_FromFormat PyString_FromFormat
#endif
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03030000
return (char *)PyUnicode_AsUTF8(str);
#else
return PyString_AsString(str);
#endif
}
/* Was useful for Python 3.0.x-3.2.x - now provided only for compatibility
* with any uses in user interface files. */
#define SWIG_Python_str_DelForPy3(x)
SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromString(c);
#else
return PyString_FromString(c);
#endif
}
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif
/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif
/* -----------------------------------------------------------------------------
* error manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
PyObject* type = 0;
switch(code) {
case SWIG_MemoryError:
type = PyExc_MemoryError;
break;
case SWIG_IOError:
type = PyExc_IOError;
break;
case SWIG_RuntimeError:
type = PyExc_RuntimeError;
break;
case SWIG_IndexError:
type = PyExc_IndexError;
break;
case SWIG_TypeError:
type = PyExc_TypeError;
break;
case SWIG_DivisionByZero:
type = PyExc_ZeroDivisionError;
break;
case SWIG_OverflowError:
type = PyExc_OverflowError;
break;
case SWIG_SyntaxError:
type = PyExc_SyntaxError;
break;
case SWIG_ValueError:
type = PyExc_ValueError;
break;
case SWIG_SystemError:
type = PyExc_SystemError;
break;
case SWIG_AttributeError:
type = PyExc_AttributeError;
break;
default:
type = PyExc_RuntimeError;
}
return type;
}
SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
if (PyErr_Occurred())
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
PyErr_Clear();
Py_XINCREF(type);
if (tmp)
PyErr_Format(type, "%s %s", tmp, mesg);
else
PyErr_Format(type, "%s", mesg);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
PyErr_SetString(PyExc_RuntimeError, mesg);
}
}
SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
PyObject *error;
if (obj)
return 0;
error = PyErr_Occurred();
return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}
SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
if (SWIG_Python_TypeErrorOccurred(NULL)) {
/* Use existing TypeError to preserve stacktrace and enhance with given message */
PyObject *newvalue;
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
if (newvalue) {
Py_XDECREF(value);
PyErr_Restore(type, newvalue, traceback);
} else {
PyErr_Restore(type, value, traceback);
}
} else {
/* Raise TypeError using given message */
PyErr_SetString(PyExc_TypeError, message);
}
}
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
# undef SWIG_PYTHON_THREADS
# endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
# define SWIG_PYTHON_USE_GIL
# endif
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# if PY_VERSION_HEX < 0x03070000
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
# else
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# endif
# ifdef __cplusplus /* C++ code */
class SWIG_Python_Thread_Block {
bool status;
PyGILState_STATE state;
public:
void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block() { end(); }
};
class SWIG_Python_Thread_Allow {
bool status;
PyThreadState *save;
public:
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow() { end(); }
};
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
# else /* C code */
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
# endif
# else /* Old thread way, not implemented, user must provide it */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
# define SWIG_PYTHON_THREAD_END_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# endif
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
# define SWIG_PYTHON_THREAD_END_ALLOW
# endif
# endif
#else /* No thread support */
# define SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# define SWIG_PYTHON_THREAD_END_BLOCK
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# define SWIG_PYTHON_THREAD_END_ALLOW
#endif
/* -----------------------------------------------------------------------------
* Python API portion that goes into the runtime
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* Constant declarations
* ----------------------------------------------------------------------------- */
/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY 5
/* Constant information structure */
typedef struct swig_const_info {
int type;
const char *name;
long lvalue;
double dvalue;
void *pvalue;
swig_type_info **ptype;
} swig_const_info;
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* pyrun.swg
*
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* type checking.
*
* ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif
#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#endif
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif
#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
#define SWIG_fail goto fail
/* Runtime API implementation */
/* Error manipulation */
SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetObject(errtype, obj);
Py_DECREF(obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetString(errtype, msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
/* Set a constant value */
#if defined(SWIGPYTHON_BUILTIN)
SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
PyObject *s = PyString_InternFromString(key);
PyList_Append(seq, s);
Py_DECREF(s);
}
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
if (public_interface)
SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}
#else
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
}
#endif
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyList_Check(result)) {
PyObject *o2 = result;
result = PyList_New(1);
if (result) {
PyList_SET_ITEM(result, 0, o2);
} else {
Py_DECREF(obj);
return o2;
}
}
PyList_Append(result,obj);
Py_DECREF(obj);
}
return result;
}
/* Unpack the argument tuple */
SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
if (!PyTuple_Check(args)) {
if (min <= 1 && max >= 1) {
Py_ssize_t i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
}
return 2;
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
Py_ssize_t i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
for (; l < max; ++l) {
objs[l] = 0;
}
return i + 1;
}
}
}
SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
int no_kwargs = 1;
if (kwargs) {
assert(PyDict_Check(kwargs));
if (PyDict_Size(kwargs) > 0) {
PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
no_kwargs = 0;
}
}
return no_kwargs;
}
/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
/*
Helper for static pointer initialization for both C and C++ code, for example
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var) var
#else
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Python-specific SWIG API */
#define SWIG_newvarlink() SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
/* -----------------------------------------------------------------------------
* global variable support code.
* ----------------------------------------------------------------------------- */
typedef struct swig_globalvar {
char *name; /* Name of global variable */
PyObject *(*get_attr)(void); /* Return the current value */
int (*set_attr)(PyObject *); /* Set the value */
struct swig_globalvar *next;
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar *vars;
} swig_varlinkobject;
SWIGINTERN PyObject *
swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_InternFromString("");
#else
return PyString_FromString("");
#endif
}
SWIGINTERN PyObject *
swig_varlink_str(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
PyObject *str = PyUnicode_InternFromString("(");
PyObject *tail;
PyObject *joined;
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
tail = PyUnicode_FromString(var->name);
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
if (var->next) {
tail = PyUnicode_InternFromString(", ");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
}
}
tail = PyUnicode_InternFromString(")");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
#else
PyObject *str = PyString_FromString("(");
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
return str;
}
SWIGINTERN void
swig_varlink_dealloc(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
swig_globalvar *var = v->vars;
while (var) {
swig_globalvar *n = var->next;
free(var->name);
free(var);
var = n;
}
}
SWIGINTERN PyObject *
swig_varlink_getattr(PyObject *o, char *n) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
PyObject *res = NULL;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->get_attr)();
break;
}
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN int
swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
int res = 1;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->set_attr)(p);
break;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
static char varlink__doc__[] = "Swig var link object";
static PyTypeObject varlink_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"swigvarlink", /* tp_name */
sizeof(swig_varlinkobject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) swig_varlink_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc) swig_varlink_getattr, /* tp_getattr */
(setattrfunc) swig_varlink_setattr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc) swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
varlink__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
varlink_type = tmp;
type_init = 1;
if (PyType_Ready(&varlink_type) < 0)
return NULL;
}
return &varlink_type;
}
/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
if (result) {
result->vars = 0;
}
return ((PyObject*) result);
}
SWIGINTERN void
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
memcpy(gv->name, name, size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
}
}
v->vars = gv;
}
static PyObject *Swig_Globals_global = NULL;
SWIGINTERN PyObject *
SWIG_globals(void) {
if (Swig_Globals_global == NULL) {
Swig_Globals_global = SWIG_newvarlink();
}
return Swig_Globals_global;
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* Pointer declarations
* ----------------------------------------------------------------------------- */
/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
#ifdef __cplusplus
extern "C" {
#endif
/* The python void return value */
SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)
{
PyObject *none = Py_None;
Py_INCREF(none);
return none;
}
/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
PyTypeObject *pytype;
} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
int fail = data ? data->implicitconv : 0;
if (fail)
PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
return fail;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
/* the newraw method and newargs arguments used to create a new raw instance */
if (PyClass_Check(obj)) {
data->newraw = 0;
Py_INCREF(obj);
data->newargs = obj;
} else {
data->newraw = PyObject_GetAttrString(data->klass, "__new__");
if (data->newraw) {
data->newargs = PyTuple_New(1);
if (data->newargs) {
Py_INCREF(obj);
PyTuple_SET_ITEM(data->newargs, 0, obj);
} else {
Py_DECREF(data->newraw);
Py_DECREF(data->klass);
free(data);
return 0;
}
} else {
Py_INCREF(obj);
data->newargs = obj;
}
}
/* the destroy method, aka as the C++ delete method */
data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
}
if (data->destroy) {
data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
} else {
data->delargs = 0;
}
data->implicitconv = 0;
data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData *data)
{
Py_XDECREF(data->klass);
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
free(data);
}
/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
PyObject *dict;
#endif
} SwigPyObject;
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
if (!sobj->dict)
sobj->dict = PyDict_New();
Py_XINCREF(sobj->dict);
return sobj->dict;
}
#endif
SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
PyObject *val = SwigPyObject_long(v);
if (val) {
PyObject *ofmt;
PyTuple_SET_ITEM(args, 0, val);
ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
res = PyUnicode_Format(ofmt,args);
#else
res = PyString_Format(ofmt,args);
#endif
Py_DECREF(ofmt);
}
}
Py_DECREF(args);
}
return res;
}
SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v);
if (repr && v->next) {
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
PyObject *joined = PyUnicode_Concat(repr, nrep);
Py_DecRef(repr);
Py_DecRef(nrep);
repr = joined;
# else
PyString_ConcatAndDel(&repr,nrep);
# endif
} else {
Py_DecRef(repr);
repr = NULL;
}
}
return repr;
}
/* We need a version taking two PyObject* parameters so it's a valid
* PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
return SwigPyObject_repr((SwigPyObject*)v);
}
SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
PyObject* res;
if( op != Py_EQ && op != Py_NE ) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
return res;
}
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
SwigPyClientData *cd;
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
assert(cd);
assert(cd->pytype);
return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
#endif
SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
PyTypeObject *target_tp = SwigPyObject_type();
if (PyType_IsSubtype(op->ob_type, target_tp))
return 1;
return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
return (Py_TYPE(op) == SwigPyObject_type())
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
static PyObject* Swig_Capsule_global = NULL;
SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
/* PyObject_CallFunction() has the potential to silently drop
the active exception. In cases of unnamed temporary
variable or where we just finished iterating over a generator
StopIteration will be active right now, and this needs to
remain true upon return from SwigPyObject_dealloc. So save
and restore. */
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
if (data->delargs) {
/* we need to create a temporary object to carry the destroy operation */
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
if (tmp) {
res = SWIG_Python_CallFunctor(destroy, tmp);
} else {
res = 0;
}
Py_XDECREF(tmp);
} else {
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
PyObject *mself = PyCFunction_GET_SELF(destroy);
res = ((*meth)(mself, v));
}
if (!res)
PyErr_WriteUnraisable(destroy);
PyErr_Restore(type, value, traceback);
Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
else {
const char *name = SWIG_TypePrettyName(ty);
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
#endif
Py_XDECREF(Swig_Capsule_global);
}
Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
Py_XDECREF(sobj->dict);
#endif
PyObject_DEL(v);
}
SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject* v, PyObject* next)
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (!SwigPyObject_Check(next)) {
PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
((SwigPyObject *)next)->next = sobj->next;
sobj->next = next;
Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
return NULL;
} else {
SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
if (PyObject_IsTrue(val)) {
Py_DECREF(SwigPyObject_acquire(v,args));
} else {
Py_DECREF(SwigPyObject_disown(v,args));
}
}
return obj;
}
}
static PyMethodDef
swigobject_methods[] = {
{"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
{"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
{"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
{"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
{"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
{"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
{0, 0, 0, 0}
};
SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
/* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
#endif
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
(unaryfunc)0, /*nb_negative*/
(unaryfunc)0, /*nb_positive*/
(unaryfunc)0, /*nb_absolute*/
(inquiry)0, /*nb_nonzero*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
0, /*nb_coerce*/
#endif
(unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_long, /*nb_long*/
#else
0, /*nb_reserved*/
#endif
(unaryfunc)0, /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
};
static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyObject", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
(cmpfunc)SwigPyObject_compare, /* tp_compare */
#endif
(reprfunc)SwigPyObject_repr, /* tp_repr */
&SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigobject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
(richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
swigobject_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobject_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpyobject_type) != 0)
return NULL;
}
return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
sobj->own = own;
sobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
sobj->dict = 0;
#endif
if (own == SWIG_POINTER_OWN) {
/* Obtain a reference to the Python capsule wrapping the module information, so that the
* module information is correctly destroyed after all SWIG python objects have been freed
* by the GC (and corresponding destructors invoked) */
Py_XINCREF(Swig_Capsule_global);
}
}
return (PyObject *)sobj;
}
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
void *pack;
swig_type_info *ty;
size_t size;
} SwigPyPacked;
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return SWIG_Python_str_FromFormat("", result, v->ty->name);
} else {
return SWIG_Python_str_FromFormat("", v->ty->name);
}
}
SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}
SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
return ((op)->ob_type == SwigPyPacked_TypeOnce())
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
if (SwigPyPacked_Check(v)) {
SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyPacked", /* tp_name */
sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
0, /* tp_reserved in 3.0.1 */
#else
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
#endif
(reprfunc)SwigPyPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigpacked_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpypacked_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpypacked_type) != 0)
return NULL;
}
return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
memcpy(pack, ptr, size);
sobj->pack = pack;
sobj->ty = ty;
sobj->size = size;
} else {
PyObject_DEL((PyObject *) sobj);
sobj = 0;
}
}
return (PyObject *) sobj;
}
SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (SwigPyPacked_Check(obj)) {
SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
} else {
return 0;
}
}
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
static PyObject *Swig_This_global = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
if (Swig_This_global == NULL)
Swig_This_global = SWIG_Python_str_FromChar("this");
return Swig_This_global;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS
#endif
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
PyObject *obj;
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
#ifdef SWIGPYTHON_BUILTIN
(void)obj;
# ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
pyobj = PyWeakref_GET_OBJECT(pyobj);
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
# endif
return NULL;
#else
obj = 0;
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
}
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
#endif
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
return oldown;
}
}
return 0;
}
/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
int res;
SwigPyObject *sobj;
int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
if (!obj)
return SWIG_ERROR;
if (obj == Py_None && !implicit_conv) {
if (ptr)
*ptr = 0;
return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
}
res = SWIG_ERROR;
sobj = SWIG_Python_GetSwigThis(obj);
if (own)
*own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
swig_type_info *to = sobj->ty;
if (to == ty) {
/* no type cast needed */
if (ptr) *ptr = vptr;
break;
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
sobj = (SwigPyObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
if (own)
*own = *own | SWIG_CAST_NEW_MEMORY;
}
}
break;
}
}
} else {
if (ptr) *ptr = vptr;
break;
}
}
if (sobj) {
if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
res = SWIG_ERROR_RELEASE_NOT_OWNED;
} else {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
if (flags & SWIG_POINTER_CLEAR) {
sobj->ptr = 0;
}
res = SWIG_OK;
}
} else {
if (implicit_conv) {
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
PyObject *impconv;
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
impconv = SWIG_Python_CallFunctor(klass, obj);
data->implicitconv = 0;
if (PyErr_Occurred()) {
PyErr_Clear();
impconv = 0;
}
if (impconv) {
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
if (SWIG_IsOK(res)) {
if (ptr) {
*ptr = vptr;
/* transfer the ownership to 'ptr' */
iobj->own = 0;
res = SWIG_AddCast(res);
res = SWIG_AddNewMask(res);
} else {
res = SWIG_AddCast(res);
}
}
}
Py_DECREF(impconv);
}
}
}
if (!SWIG_IsOK(res) && obj == Py_None) {
if (ptr)
*ptr = 0;
if (PyErr_Occurred())
PyErr_Clear();
res = SWIG_OK;
}
}
}
return res;
}
/* Convert a function ptr value */
SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
if (!PyCFunction_Check(obj)) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
swig_cast_info *tc;
/* here we get the method pointer for callbacks */
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
if (!desc)
return SWIG_ERROR;
tc = SWIG_TypeCheck(desc,ty);
if (tc) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
} else {
return SWIG_ERROR;
}
return SWIG_OK;
}
}
/* Convert a packed pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
/* check type cast? */
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* -----------------------------------------------------------------------------
* Create a new pointer object
* ----------------------------------------------------------------------------- */
/*
Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
inst = PyObject_Call(newraw, data->newargs, NULL);
if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
Py_DECREF(inst);
inst = 0;
}
}
#else
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
}
#endif
}
} else {
#if PY_VERSION_HEX >= 0x03000000
PyObject *empty_args = PyTuple_New(0);
if (empty_args) {
PyObject *empty_kwargs = PyDict_New();
if (empty_kwargs) {
inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
Py_DECREF(empty_kwargs);
if (inst) {
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
} else {
PyType_Modified(Py_TYPE(inst));
}
}
}
Py_DECREF(empty_args);
}
#else
PyObject *dict = PyDict_New();
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
}
#endif
}
return inst;
}
SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
return PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
return -1;
}
}
#endif
return PyObject_SetAttr(inst, SWIG_This(), swig_this);
}
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
return NULL;
} else {
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
} else {
if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
return NULL;
}
return SWIG_Py_Void();
}
}
/* Create a new pointer object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
SwigPyClientData *clientdata;
PyObject * robj;
int own;
if (!ptr)
return SWIG_Py_Void();
clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
if (clientdata && clientdata->pytype) {
SwigPyObject *newobj;
if (flags & SWIG_BUILTIN_TP_INIT) {
newobj = (SwigPyObject*) self;
if (newobj->ptr) {
PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
while (newobj->next)
newobj = (SwigPyObject *) newobj->next;
newobj->next = next_self;
newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
newobj->dict = 0;
#endif
}
} else {
newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
if (newobj) {
newobj->dict = 0;
}
#endif
}
if (newobj) {
newobj->ptr = ptr;
newobj->ty = type;
newobj->own = own;
newobj->next = 0;
return (PyObject*) newobj;
}
return SWIG_Py_Void();
}
assert(!(flags & SWIG_BUILTIN_TP_INIT));
robj = SwigPyObject_New(ptr, type, own);
if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
Py_DECREF(robj);
robj = inst;
}
return robj;
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
* Get type list
* -----------------------------------------------------------------------------*/
#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif
static PyObject *Swig_TypeCache_global = NULL;
/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
if (Swig_TypeCache_global == NULL) {
Swig_TypeCache_global = PyDict_New();
}
return Swig_TypeCache_global;
}
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
}
#else
void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
}
#endif
return (swig_module_info *) type_pointer;
}
static int interpreter_counter = 0; // how many (sub-)interpreters are using swig_module's types
SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
swig_type_info **types = swig_module->types;
size_t i;
if (--interpreter_counter != 0) // another sub-interpreter may still be using the swig_module's types
return;
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
ty->clientdata = 0;
if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
Swig_This_global = NULL;
Py_DECREF(SWIG_globals());
Swig_Globals_global = NULL;
Py_DECREF(SWIG_Python_TypeCache());
Swig_TypeCache_global = NULL;
Swig_Capsule_global = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
/* Add a dummy module object into sys.modules */
PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && module) {
if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
++interpreter_counter;
Swig_Capsule_global = pointer;
} else {
Py_DECREF(pointer);
}
} else {
Py_XDECREF(pointer);
}
}
SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
PyObject *key = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
} else {
swig_module_info *swig_module = SWIG_GetModule(0);
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
obj = PyCapsule_New((void*) descriptor, NULL, NULL);
if (obj) {
PyDict_SetItem(cache, key, obj);
Py_DECREF(obj);
}
}
}
Py_DECREF(key);
return descriptor;
}
/*
For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION 0
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
const char *errmesg = tmp ? tmp : "Invalid error message";
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, errmesg);
} else {
PyErr_Format(type, "%s %s", errmesg, mesg);
}
Py_DECREF(old_str);
}
return 1;
} else {
return 0;
}
}
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
if (PyErr_Occurred()) {
/* add information about failing argument */
char mesg[256];
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
} else {
return 0;
}
}
SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : "";
}
SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
if (obj && SwigPyObject_Check(obj)) {
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
type, otype);
return;
}
} else
#endif
{
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
}
Py_XDECREF(str);
return;
}
}
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
} else {
PyErr_Format(PyExc_TypeError, "unexpected type is received");
}
}
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
}
return result;
}
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
PyTypeObject *tp = obj->ob_type;
PyObject *descr;
PyObject *encoded_name;
descrsetfunc f;
int res = -1;
# ifdef Py_USING_UNICODE
if (PyString_Check(name)) {
name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
if (!name)
return -1;
} else if (!PyUnicode_Check(name))
# else
if (!PyString_Check(name))
# endif
{
PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
return -1;
} else {
Py_INCREF(name);
}
if (!tp->tp_dict) {
if (PyType_Ready(tp) != 0)
goto done;
}
descr = _PyType_Lookup(tp, name);
f = NULL;
if (descr != NULL)
f = descr->ob_type->tp_descr_set;
if (!f) {
if (PyString_Check(name)) {
encoded_name = name;
Py_INCREF(name);
} else {
encoded_name = PyUnicode_AsUTF8String(name);
if (!encoded_name)
goto done;
}
PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
Py_DECREF(encoded_name);
} else {
res = f(descr, obj, value);
}
done:
Py_DECREF(name);
return res;
}
#endif
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN Py_hash_t
SwigPyObject_hash(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
void *ptr = sobj->ptr;
#if PY_VERSION_HEX < 0x03020000
return (Py_hash_t)(Py_ssize_t)ptr;
#else
return (Py_hash_t)ptr;
#endif
}
SWIGINTERN Py_hash_t
SWIG_PyNumber_AsPyHash(PyObject *obj) {
Py_hash_t result = -1;
#if PY_VERSION_HEX < 0x03020000
if (PyInt_Check(obj))
result = PyInt_AsLong(obj);
else if (PyLong_Check(obj))
result = PyLong_AsLong(obj);
#else
if (PyNumber_Check(obj))
result = PyNumber_AsSsize_t(obj, NULL);
#endif
else
PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
return PyErr_Occurred() ? -1 : result;
}
SWIGINTERN int
SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
return -1;
}
SWIGINTERN void
SwigPyBuiltin_BadDealloc(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
if (sobj->own) {
PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", obj->ob_type->tp_name);
}
}
typedef struct {
PyCFunction get;
PyCFunction set;
} SwigPyGetSet;
SWIGINTERN PyObject *
SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
tuple = PyTuple_New(0);
assert(tuple);
result = (*getset->get)(obj, tuple);
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyObject *
SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
result = (*getset->get)(obj, NULL);
return result;
}
SWIGINTERN int
SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(val);
PyTuple_SET_ITEM(tuple, 0, val);
result = (*getset->set)(obj, tuple);
Py_DECREF(tuple);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN int
SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
result = (*getset->set)(obj, val);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN void
SwigPyStaticVar_dealloc(PyDescrObject *descr) {
PyObject_GC_UnTrack(descr);
Py_XDECREF(PyDescr_TYPE(descr));
Py_XDECREF(PyDescr_NAME(descr));
PyObject_GC_Del(descr);
}
SWIGINTERN PyObject *
SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromFormat("", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
return PyString_FromFormat("", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
}
SWIGINTERN int
SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
PyDescrObject *descr;
descr = (PyDescrObject *)self;
Py_VISIT((PyObject*) PyDescr_TYPE(descr));
return 0;
}
SWIGINTERN PyObject *
SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
if (descr->d_getset->get != NULL)
return descr->d_getset->get(obj, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return NULL;
}
SWIGINTERN int
SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
if (descr->d_getset->set != NULL)
return descr->d_getset->set(obj, value, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return -1;
}
SWIGINTERN int
SwigPyObjectType_setattro(PyObject *typeobject, PyObject *name, PyObject *value) {
PyObject *attribute;
PyTypeObject *type;
descrsetfunc local_set;
assert(PyType_Check(typeobject));
type = (PyTypeObject *)typeobject;
attribute = _PyType_Lookup(type, name);
if (attribute != NULL) {
/* Implement descriptor functionality, if any */
local_set = attribute->ob_type->tp_descr_set;
if (local_set != NULL)
return local_set(attribute, (PyObject *)type, value);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
} else {
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
}
return -1;
}
SWIGINTERN PyTypeObject*
SwigPyStaticVar_Type(void) {
static PyTypeObject staticvar_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"swig_static_var_getset_descriptor", /* tp_name */
sizeof(PyGetSetDescrObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyStaticVar_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
(reprfunc)SwigPyStaticVar_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
0, /* tp_doc */
SwigPyStaticVar_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc)SwigPyStaticVar_get, /* tp_descr_get */
(descrsetfunc)SwigPyStaticVar_set, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
staticvar_type = tmp;
type_init = 1;
if (PyType_Ready(&staticvar_type) < 0)
return NULL;
}
return &staticvar_type;
}
SWIGINTERN PyTypeObject*
SwigPyObjectType(void) {
static char swigpyobjecttype_doc[] = "Metaclass for SWIG wrapped types";
static PyTypeObject swigpyobjecttype_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"SwigPyObjectType", /* tp_name */
PyType_Type.tp_basicsize, /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
SwigPyObjectType_setattro, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
swigpyobjecttype_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobjecttype_type = tmp;
type_init = 1;
swigpyobjecttype_type.tp_base = &PyType_Type;
if (PyType_Ready(&swigpyobjecttype_type) < 0)
return NULL;
}
return &swigpyobjecttype_type;
}
SWIGINTERN PyGetSetDescrObject *
SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
PyGetSetDescrObject *descr;
descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
assert(descr);
Py_XINCREF(type);
PyDescr_TYPE(descr) = type;
PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
descr->d_getset = getset;
if (PyDescr_NAME(descr) == NULL) {
Py_DECREF(descr);
descr = NULL;
}
return descr;
}
SWIGINTERN void
SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
Py_ssize_t base_count = 0;
PyTypeObject **b;
PyObject *tuple;
Py_ssize_t i;
if (!bases[0]) {
bases[0] = SwigPyObject_type();
bases[1] = NULL;
}
type->tp_base = bases[0];
Py_INCREF((PyObject *)bases[0]);
for (b = bases; *b != NULL; ++b)
++base_count;
tuple = PyTuple_New(base_count);
for (i = 0; i < base_count; ++i) {
Py_INCREF((PyObject *)bases[i]);
PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
}
type->tp_bases = tuple;
}
SWIGINTERN PyObject *
SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
PyObject *result;
result = (PyObject *)SWIG_Python_GetSwigThis(self);
Py_XINCREF(result);
return result;
}
SWIGINTERN void
SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
{
#if PY_VERSION_HEX >= 0x030900a4
Py_SET_TYPE(type, metatype);
#else
Py_TYPE(type) = metatype;
#endif
}
/* Start of callback function macros for use in PyTypeObject */
typedef PyObject *(*SwigPyWrapperFunction)(PyObject *, PyObject *);
#define SWIGPY_UNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_unaryfunc_closure(PyObject *a) { \
return SwigPyBuiltin_unaryfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_unaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper) \
SWIGINTERN void \
wrapper##_destructor_closure(PyObject *a) { \
SwigPyBuiltin_destructor_closure(wrapper, #wrapper, a); \
}
SWIGINTERN void
SwigPyBuiltin_destructor_closure(SwigPyWrapperFunction wrapper, const char *wrappername, PyObject *a) {
SwigPyObject *sobj;
sobj = (SwigPyObject *)a;
Py_XDECREF(sobj->dict);
if (sobj->own) {
PyObject *o;
PyObject *type = 0, *value = 0, *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
o = wrapper(a, NULL);
if (!o) {
PyObject *deallocname = PyString_FromString(wrappername);
PyErr_WriteUnraisable(deallocname);
Py_DECREF(deallocname);
}
PyErr_Restore(type, value, traceback);
Py_XDECREF(o);
}
if (PyType_IS_GC(a->ob_type)) {
PyObject_GC_Del(a);
} else {
PyObject_Del(a);
}
}
#define SWIGPY_INQUIRY_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_inquiry_closure(PyObject *a) { \
return SwigPyBuiltin_inquiry_closure(wrapper, a); \
}
SWIGINTERN int
SwigPyBuiltin_inquiry_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
int result;
pyresult = wrapper(a, NULL);
result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_GETITERFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_getiterfunc_closure(PyObject *a) { \
return SwigPyBuiltin_getiterfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_getiterfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_BINARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_binaryfunc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_binaryfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_binaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
typedef ternaryfunc ternarycallfunc;
#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternaryfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternaryfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternarycallfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternarycallfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternarycallfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
(void) c;
return wrapper(a, b);
}
#define SWIGPY_LENFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_ssize_t \
wrapper##_lenfunc_closure(PyObject *a) { \
return SwigPyBuiltin_lenfunc_closure(wrapper, a); \
}
SWIGINTERN Py_ssize_t
SwigPyBuiltin_lenfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *resultobj;
Py_ssize_t result;
resultobj = wrapper(a, NULL);
result = PyNumber_AsSsize_t(resultobj, NULL);
Py_DECREF(resultobj);
return result;
}
#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizessizeargfunc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) { \
return SwigPyBuiltin_ssizessizeargfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizessizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizessizeobjargproc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
return SwigPyBuiltin_ssizessizeobjargproc_closure(wrapper, a, b, c, d); \
}
SWIGINTERN int
SwigPyBuiltin_ssizessizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(d ? 3 : 2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
if (d) {
Py_INCREF(d);
PyTuple_SET_ITEM(tuple, 2, d);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_DECREF(tuple);
Py_XDECREF(resultobj);
return result;
}
#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_funpack_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_funpack_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *arg, *result;
arg = _PyLong_FromSsize_t(b);
result = wrapper(a, arg);
Py_DECREF(arg);
return result;
}
#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizeobjargproc_closure(PyObject *a, Py_ssize_t b, PyObject *c) { \
return SwigPyBuiltin_ssizeobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_ssizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
PyObject *tuple;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
pyresult = wrapper(a, tuple);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_funpack_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_funpack_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
pyresult = wrapper(a, b);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjargproc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_objobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_objobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(c ? 2 : 1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
if (c) {
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_REPRFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_reprfunc_closure(PyObject *a) { \
return SwigPyBuiltin_reprfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_reprfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_HASHFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_hash_t \
wrapper##_hashfunc_closure(PyObject *a) { \
return SwigPyBuiltin_hashfunc_closure(wrapper, a); \
}
SWIGINTERN Py_hash_t
SwigPyBuiltin_hashfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
Py_hash_t result;
pyresult = wrapper(a, NULL);
if (!pyresult)
return -1;
result = SWIG_PyNumber_AsPyHash(pyresult);
Py_DECREF(pyresult);
return result;
}
#define SWIGPY_ITERNEXTFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_iternextfunc_closure(PyObject *a) { \
return SwigPyBuiltin_iternextfunc_closure(wrapper, a);\
}
SWIGINTERN PyObject *
SwigPyBuiltin_iternextfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
/* End of callback function macros for use in PyTypeObject */
#ifdef __cplusplus
}
#endif
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_GPLogLevel swig_types[0]
#define SWIGTYPE_p_Log swig_types[1]
#define SWIGTYPE_p_LogFuncItem swig_types[2]
#define SWIGTYPE_p_SwigPyObject swig_types[3]
#define SWIGTYPE_p_char swig_types[4]
#define SWIGTYPE_p_f_enum_GPLogLevel_p_q_const__char_p_q_const__char_p_void__void swig_types[5]
static swig_type_info *swig_types[7];
static swig_module_info swig_module = {swig_types, 6, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery
/*-----------------------------------------------
@(target):= _port_log.so
------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_init PyInit__port_log
#else
# define SWIG_init init_port_log
#endif
#define SWIG_name "_port_log"
#define SWIG_as_voidptr(a) (void *)((const void *)(a))
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
#include
#include "gphoto2/gphoto2.h"
PyObject *PyExc_GPhoto2Error = NULL;
typedef struct LogFuncItem {
int id;
PyObject *func;
PyObject *data;
} LogFuncItem;
// call gp_log_remove_func when LogFuncItem object is deleted
static int del_LogFuncItem(struct LogFuncItem *this) {
int error = GP_OK;
if (this->id >= 0)
error = gp_log_remove_func(this->id);
Py_XDECREF(this->func);
Py_XDECREF(this->data);
free(this);
return error;
};
SWIGINTERN void delete_LogFuncItem(struct LogFuncItem *self){
int error = del_LogFuncItem(self);
if (error < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
}
static void gp_log_call_python(GPLogLevel level, const char *domain,
const char *str, void *data) {
if (!Py_IsInitialized()) {
return;
}
PyGILState_STATE gstate = PyGILState_Ensure();
LogFuncItem *this = data;
PyObject *result = NULL;
PyObject *arglist = NULL;
if (this->data) {
arglist = Py_BuildValue("(iNNO)", level,
PyUnicode_DecodeUTF8(domain, strlen(domain), "replace"),
PyUnicode_DecodeUTF8(str, strlen(str), "replace"), this->data);
} else {
arglist = Py_BuildValue("(iNN)", level,
PyUnicode_DecodeUTF8(domain, strlen(domain), "replace"),
PyUnicode_DecodeUTF8(str, strlen(str), "replace"));
}
if (arglist == NULL) {
PyErr_Print();
} else {
result = PyObject_CallObject(this->func, arglist);
Py_DECREF(arglist);
if (result == NULL) {
PyErr_Print();
} else {
Py_DECREF(result);
}
}
PyGILState_Release(gstate);
};
#include
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
# define LLONG_MAX __LONG_LONG_MAX__
# define LLONG_MIN (-LLONG_MAX - 1LL)
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif
SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
int res = SWIG_TypeError;
if (PyFloat_Check(obj)) {
if (val) *val = PyFloat_AsDouble(obj);
return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
} else if (PyInt_Check(obj)) {
if (val) *val = (double) PyInt_AsLong(obj);
return SWIG_OK;
#endif
} else if (PyLong_Check(obj)) {
double v = PyLong_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
double d = PyFloat_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = d;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
} else {
PyErr_Clear();
}
}
}
#endif
return res;
}
#include
#include
SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
double x = *d;
if ((min <= x && x <= max)) {
double fx = floor(x);
double cx = ceil(x);
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
if ((errno == EDOM) || (errno == ERANGE)) {
errno = 0;
} else {
double summ, reps, diff;
if (rd < x) {
diff = x - rd;
} else if (rd > x) {
diff = rd - x;
} else {
return 1;
}
summ = rd + x;
reps = diff/summ;
if (reps < 8*DBL_EPSILON) {
*d = rd;
return 1;
}
}
}
return 0;
}
SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
} else
#endif
if (PyLong_Check(obj)) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
return SWIG_OverflowError;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
long v = PyInt_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
if (val) *val = (long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
long v;
int res = SWIG_AsVal_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v < INT_MIN || v > INT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = (int)(v);
}
}
return res;
}
SWIGINTERN int Log_add_func(GPLogLevel level,GPLogFunc func,void *data){
int result = gp_log_add_func (level, func, data);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
return result;
}
SWIGINTERNINLINE PyObject*
SWIG_From_int (int value)
{
return PyInt_FromLong((long) value);
}
SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
static int init = 0;
static swig_type_info* info = 0;
if (!init) {
info = SWIG_TypeQuery("_p_char");
init = 1;
}
return info;
}
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (PyBytes_Check(obj))
#else
if (PyUnicode_Check(obj))
#endif
#else
if (PyString_Check(obj))
#endif
{
char *cstr; Py_ssize_t len;
int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
if (!alloc && cptr) {
/* We can't allow converting without allocation, since the internal
representation of string in Python 3 is UCS-2/UCS-4 but we require
a UTF-8 representation.
TODO(bhy) More detailed explanation */
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (alloc)
*alloc = SWIG_NEWOBJ;
#endif
if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#else
if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
return SWIG_TypeError;
#endif
if (cptr) {
if (alloc) {
if (*alloc == SWIG_NEWOBJ) {
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
*alloc = SWIG_NEWOBJ;
} else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
}
} else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
*cptr = PyBytes_AsString(obj);
#else
assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
*cptr = SWIG_Python_str_AsChar(obj);
if (!*cptr)
ret = SWIG_TypeError;
#endif
}
}
if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
Py_XDECREF(obj);
#endif
return ret;
} else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
if (PyUnicode_Check(obj)) {
char *cstr; Py_ssize_t len;
if (!alloc && cptr) {
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
if (!obj)
return SWIG_TypeError;
if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
if (cptr) {
if (alloc) *alloc = SWIG_NEWOBJ;
*cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
}
if (psize) *psize = len + 1;
Py_XDECREF(obj);
return SWIG_OK;
} else {
Py_XDECREF(obj);
}
}
#endif
#endif
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
if (pchar_descriptor) {
void* vptr = 0;
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
if (cptr) *cptr = (char *) vptr;
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
if (alloc) *alloc = SWIG_OLDOBJ;
return SWIG_OK;
}
}
}
return SWIG_TypeError;
}
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_delete_LogFuncItem(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct LogFuncItem *arg1 = (struct LogFuncItem *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_LogFuncItem takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LogFuncItem, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogFuncItem" "', argument " "1"" of type '" "struct LogFuncItem *""'");
}
arg1 = (struct LogFuncItem *)(argp1);
{
delete_LogFuncItem(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_LogFuncItem) /* defines _wrap_delete_LogFuncItem_destructor_closure */
SWIGINTERN PyObject *_wrap_Log_add_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPLogLevel arg1 ;
GPLogFunc arg2 = (GPLogFunc) 0 ;
void *arg3 = (void *) 0 ;
LogFuncItem *_global_callback ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
{
_global_callback = malloc(sizeof(LogFuncItem));
if (!_global_callback) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callback->id = GP_ERROR;
_global_callback->func = NULL;
_global_callback->data = NULL;
}
{
arg3 = _global_callback;
}
(void)self;
if (!PyArg_UnpackTuple(args, "Log_add_func", 2, 3, &obj0, &obj1, &obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_add_func" "', argument " "1"" of type '" "GPLogLevel""'");
}
arg1 = (GPLogLevel)(val1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Log_add_func" "', argument " "2"" of type '" "callable""'");
}
_global_callback->func = obj1;
Py_INCREF(_global_callback->func);
arg2 = gp_log_call_python;
}
if (obj2) {
{
_global_callback->data = obj2;
Py_INCREF(_global_callback->data);
}
}
{
result = (int)Log_add_func(arg1,arg2,arg3);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int((int)(result));
{
_global_callback->id = result;
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callback, SWIGTYPE_p_LogFuncItem, SWIG_POINTER_OWN));
_global_callback = NULL;
}
{
if (_global_callback)
del_LogFuncItem(_global_callback);
}
return resultobj;
fail:
{
if (_global_callback)
del_LogFuncItem(_global_callback);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_log_add_func(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPLogLevel arg1 ;
GPLogFunc arg2 = (GPLogFunc) 0 ;
void *arg3 = (void *) 0 ;
LogFuncItem *_global_callback ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
{
_global_callback = malloc(sizeof(LogFuncItem));
if (!_global_callback) {
PyErr_SetNone(PyExc_MemoryError);
SWIG_fail;
}
_global_callback->id = GP_ERROR;
_global_callback->func = NULL;
_global_callback->data = NULL;
}
{
arg3 = _global_callback;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_log_add_func", 2, 3, &obj0, &obj1, &obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gp_log_add_func" "', argument " "1"" of type '" "GPLogLevel""'");
}
arg1 = (GPLogLevel)(val1);
{
if (!PyCallable_Check(obj1)) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "gp_log_add_func" "', argument " "2"" of type '" "callable""'");
}
_global_callback->func = obj1;
Py_INCREF(_global_callback->func);
arg2 = gp_log_call_python;
}
if (obj2) {
{
_global_callback->data = obj2;
Py_INCREF(_global_callback->data);
}
}
result = (int)gp_log_add_func(arg1,arg2,arg3);
resultobj = SWIG_From_int((int)(result));
{
_global_callback->id = result;
resultobj = SWIG_Python_AppendOutput(resultobj,
SWIG_NewPointerObj(_global_callback, SWIGTYPE_p_LogFuncItem, SWIG_POINTER_OWN));
_global_callback = NULL;
}
{
if (_global_callback)
del_LogFuncItem(_global_callback);
}
return resultobj;
fail:
{
if (_global_callback)
del_LogFuncItem(_global_callback);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_log__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
PyObject *resultobj = 0;
GPLogLevel arg1 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
void *arg4 = 0 ;
int val1 ;
int ecode1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_log", 3, 4, &obj0, &obj1, &obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gp_log" "', argument " "1"" of type '" "GPLogLevel""'");
}
arg1 = (GPLogLevel)(val1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_log" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gp_log" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
if (PyTuple_Size(varargs) > 0) {
PyErr_SetString(PyExc_ValueError,
"Too many arguments in function 'gp_log'.");
SWIG_fail;
}
gp_log(arg1,(char const *)arg2,(char const *)arg3,arg4);
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_log(PyObject *self, PyObject *args) {
PyObject *resultobj;
PyObject *varargs;
PyObject *newargs;
newargs = PyTuple_GetSlice(args, 0, 3);
varargs = PyTuple_GetSlice(args, 3, PyTuple_Size(args));
resultobj = _wrap_gp_log__varargs__(self, newargs, varargs);
Py_XDECREF(newargs);
Py_XDECREF(varargs);
return resultobj;
}
static PyMethodDef SwigMethods[] = {
{ "gp_log_add_func", _wrap_gp_log_add_func, METH_VARARGS, "\n"
"gp_log_add_func(level, func, data) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"level: GPLogLevel (gphoto2.GP_LOG_ERROR etc.)\n"
"func: callable function\n"
"data: object (default=None)\n"
"\n"
"Add a function to get logging information. \n"
"\n"
"Parameters\n"
"----------\n"
"* `level` : \n"
" the maximum level of logging it will get, up to and including the\n"
" passed value \n"
"* `func` : \n"
" a GPLogFunc \n"
"* `data` : \n"
" data \n"
"\n"
"Adds a log function that will be called for each log message that is\n"
"flagged with a log level that appears in given log level. This function\n"
"returns an id that you can use for removing the log function again\n"
"(using gp_log_remove_func). \n"
"\n"
"Returns\n"
"-------\n"
"an id or a gphoto2 error code\n"
""},
{ "gp_log", _wrap_gp_log, METH_VARARGS, "\n"
"gp_log(level, domain, format)\n"
"\n"
"Parameters\n"
"----------\n"
"level: GPLogLevel (gphoto2.GP_LOG_ERROR etc.)\n"
"domain: str\n"
"format: str\n"
"\n"
"Log a debug or error message. \n"
"\n"
"Parameters\n"
"----------\n"
"* `level` : \n"
" gphoto2 log level \n"
"* `domain` : \n"
" the log domain \n"
"* `format` : \n"
" a printf style format string \n"
"* `...` : \n"
" the variable argumentlist for above format string \n"
"\n"
"Logs a message at the given log level. You would normally use this\n"
"function to log general debug output in a printf way.\n"
""},
{ NULL, NULL, 0, NULL }
};
static SwigPyGetSet LogFuncItem___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__LogFuncItem_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"~LogFuncItem", &LogFuncItem___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin__LogFuncItem_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin__LogFuncItem_methods[] = {
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin__LogFuncItem_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.port_log.LogFuncItem", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_LogFuncItem_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin__LogFuncItem_type.as_number, /* tp_as_number */
&SwigPyBuiltin__LogFuncItem_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin__LogFuncItem_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin__LogFuncItem_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"::LogFuncItem", /* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin__LogFuncItem_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin__LogFuncItem_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin__LogFuncItem_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
SwigPyBuiltin_BadInit, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin__LogFuncItem_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__LogFuncItem_type};
static SwigPyGetSet Log___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__Log_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"Log_add_func", &Log___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin__Log_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin__Log_methods[] = {
{ "add_func", (PyCFunction)(void(*)(void))_wrap_Log_add_func, METH_STATIC|METH_VARARGS, "\n"
"Log_add_func(level, func, data) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"level: GPLogLevel (gphoto2.GP_LOG_ERROR etc.)\n"
"func: callable function\n"
"data: object (default=None)\n"
"\n"
"" },
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin__Log_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.port_log.Log", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
SwigPyBuiltin_BadDealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin__Log_type.as_number, /* tp_as_number */
&SwigPyBuiltin__Log_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin__Log_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin__Log_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"::Log", /* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin__Log_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin__Log_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin__Log_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
SwigPyBuiltin_BadInit, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin__Log_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__Log_type};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_GPLogLevel = {"_p_GPLogLevel", "GPLogLevel *|enum GPLogLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Log = {"_p_Log", "Log *", 0, 0, (void*)&SwigPyBuiltin__Log_clientdata, 0};
static swig_type_info _swigt__p_LogFuncItem = {"_p_LogFuncItem", "LogFuncItem *|struct LogFuncItem *", 0, 0, (void*)&SwigPyBuiltin__LogFuncItem_clientdata, 0};
static swig_type_info _swigt__p_SwigPyObject = {"_p_SwigPyObject", "SwigPyObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_enum_GPLogLevel_p_q_const__char_p_q_const__char_p_void__void = {"_p_f_enum_GPLogLevel_p_q_const__char_p_q_const__char_p_void__void", "GPLogFunc|void (*)(enum GPLogLevel,char const *,char const *,void *)", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_GPLogLevel,
&_swigt__p_Log,
&_swigt__p_LogFuncItem,
&_swigt__p_SwigPyObject,
&_swigt__p_char,
&_swigt__p_f_enum_GPLogLevel_p_q_const__char_p_q_const__char_p_void__void,
};
static swig_cast_info _swigc__p_GPLogLevel[] = { {&_swigt__p_GPLogLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Log[] = { {&_swigt__p_Log, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LogFuncItem[] = { {&_swigt__p_LogFuncItem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwigPyObject[] = { {&_swigt__p_SwigPyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_enum_GPLogLevel_p_q_const__char_p_q_const__char_p_void__void[] = { {&_swigt__p_f_enum_GPLogLevel_p_q_const__char_p_q_const__char_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_GPLogLevel,
_swigc__p_Log,
_swigc__p_LogFuncItem,
_swigc__p_SwigPyObject,
_swigc__p_char,
_swigc__p_f_enum_GPLogLevel_p_q_const__char_p_q_const__char_p_void__void,
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};
#ifdef __cplusplus
}
#endif
static PyTypeObject *builtin_bases[2];
/* -----------------------------------------------------------------------------
* Type initialization:
* This problem is tough by the requirement that no dynamic
* memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
* to swig_type_info structures, we need some lookup code at initialization.
* The idea is that swig generates all the structures that are needed.
* The runtime then collects these partially filled structures.
* The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
* The generated swig_type_info structures are assigned statically to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
* cast linked list. The cast data is initially stored in something like a
* two-dimensional array. Each row corresponds to a type (there are the same
* number of rows as there are in the swig_type_initial array). Each entry in
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
* we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
* First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
* 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
* swig_cast_info to the linked list (because the cast->type) pointer will
* be correct.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif
#if 0
#define SWIGRUNTIME_DEBUG
#endif
#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif
SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
size_t i;
swig_module_info *module_head, *iter;
int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* Initialize the swig_module */
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
init = 1;
} else {
init = 0;
}
/* Try and load any already created modules */
module_head = SWIG_GetModule(clientdata);
if (!module_head) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
iter=module_head;
do {
if (iter==&swig_module) {
/* Our module is already in the list, so there's nothing more to do. */
return;
}
iter=iter->next;
} while (iter!= module_head);
/* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpreters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
if (init == 0) return;
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
if (swig_module.next != &swig_module) {
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
}
if (type) {
/* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
if (swig_module.type_initial[i]->clientdata) {
type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
}
} else {
type = swig_module.type_initial[i];
}
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
if (swig_module.next != &swig_module) {
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
}
if (ret) {
if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
cast->type = ret;
ret = 0;
} else {
/* Check for casting already in the list */
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
if (!ocast) ret = 0;
}
}
if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
if (type->cast) {
type->cast->prev = cast;
cast->next = type->cast;
}
type->cast = cast;
}
cast++;
}
/* Set entry in modules->types array equal to the type */
swig_module.types[i] = type;
}
swig_module.types[i] = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("**** SWIG_InitializeModule: Cast List ******\n");
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
++j;
}
printf("---- Total casts: %d\n",j);
}
printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}
/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types. It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
size_t i;
swig_cast_info *equiv;
static int init_run = 0;
if (init_run) return;
init_run = 1;
for (i = 0; i < swig_module.size; i++) {
if (swig_module.types[i]->clientdata) {
equiv = swig_module.types[i]->cast;
while (equiv) {
if (!equiv->converter) {
if (equiv->type && !equiv->type->clientdata)
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
}
equiv = equiv->next;
}
}
}
}
#ifdef __cplusplus
#if 0
{
/* c-mode */
#endif
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* constants/methods manipulation
* ----------------------------------------------------------------------------- */
/* Install Constants */
SWIGINTERN void
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
PyObject *obj = 0;
size_t i;
for (i = 0; constants[i].type; ++i) {
switch(constants[i].type) {
case SWIG_PY_POINTER:
obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_PY_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
break;
default:
obj = 0;
break;
}
if (obj) {
PyDict_SetItemString(d, constants[i].name, obj);
Py_DECREF(obj);
}
}
}
/* -----------------------------------------------------------------------------
* Patch %callback methods' docstrings to hold the callback ptrs
* -----------------------------------------------------------------------------*/
SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
size_t i;
for (i = 0; methods[i].ml_name; ++i) {
const char *c = methods[i].ml_doc;
if (!c) continue;
c = strstr(c, "swig_ptr: ");
if (c) {
int j;
const swig_const_info *ci = 0;
const char *name = c + 10;
for (j = 0; const_table[j].type; ++j) {
if (strncmp(const_table[j].name, name,
strlen(const_table[j].name)) == 0) {
ci = &(const_table[j]);
break;
}
}
if (ci) {
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
if (ptr) {
size_t shift = (ci->ptype) - types;
swig_type_info *ty = types_initial[shift];
size_t ldoc = (c - methods[i].ml_doc);
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
char *ndoc = (char*)malloc(ldoc + lptr + 10);
if (ndoc) {
char *buff = ndoc;
memcpy(buff, methods[i].ml_doc, ldoc);
buff += ldoc;
memcpy(buff, "swig_ptr: ", 10);
buff += 10;
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
methods[i].ml_doc = ndoc;
}
}
}
}
}
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------*
* Partial Init method
* -----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
PyObject *m, *d, *md, *globals;
#if PY_VERSION_HEX >= 0x03000000
static struct PyModuleDef SWIG_module = {
PyModuleDef_HEAD_INIT,
SWIG_name,
NULL,
-1,
SwigMethods,
NULL,
NULL,
NULL,
NULL
};
#endif
#if defined(SWIGPYTHON_BUILTIN)
static SwigPyClientData SwigPyObject_clientdata = {
0, 0, 0, 0, 0, 0, 0
};
static PyGetSetDef this_getset_def = {
(char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
};
static SwigPyGetSet thisown_getset_closure = {
SwigPyObject_own,
SwigPyObject_own
};
static PyGetSetDef thisown_getset_def = {
(char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
};
PyTypeObject *builtin_pytype;
int builtin_base_count;
swig_type_info *builtin_basetype;
PyObject *tuple;
PyGetSetDescrObject *static_getset;
PyTypeObject *metatype;
PyTypeObject *swigpyobject;
SwigPyClientData *cd;
PyObject *public_interface, *public_symbol;
PyObject *this_descr;
PyObject *thisown_descr;
PyObject *self = 0;
int i;
(void)builtin_pytype;
(void)builtin_base_count;
(void)builtin_basetype;
(void)tuple;
(void)static_getset;
(void)self;
/* Metaclass is used to implement static member variables */
metatype = SwigPyObjectType();
assert(metatype);
#endif
(void)globals;
/* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
SWIG_This();
SWIG_Python_TypeCache();
SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
SwigPyObject_type();
#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
#if PY_VERSION_HEX >= 0x03000000
m = PyModule_Create(&SWIG_module);
#else
m = Py_InitModule(SWIG_name, SwigMethods);
#endif
md = d = PyModule_GetDict(m);
(void)md;
SWIG_InitializeModule(0);
#ifdef SWIGPYTHON_BUILTIN
swigpyobject = SwigPyObject_TypeOnce();
SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
if (!cd) {
SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
SwigPyObject_clientdata.pytype = swigpyobject;
} else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
return NULL;
# else
return;
# endif
}
/* All objects have a 'this' attribute */
this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
(void)this_descr;
/* All objects have a 'thisown' attribute */
thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
(void)thisown_descr;
public_interface = PyList_New(0);
public_symbol = 0;
(void)public_symbol;
PyDict_SetItemString(md, "__all__", public_interface);
Py_DECREF(public_interface);
for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
for (i = 0; swig_const_table[i].name != 0; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
SWIG_InstallConstants(d,swig_const_table);
{
PyObject *module = PyImport_ImportModule("gphoto2");
if (module != NULL) {
PyExc_GPhoto2Error = PyObject_GetAttrString(module, "GPhoto2Error");
Py_DECREF(module);
}
if (PyExc_GPhoto2Error == NULL)
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
/* type '::LogFuncItem' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__LogFuncItem_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'LogFuncItem'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "LogFuncItem", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "LogFuncItem");
d = md;
/* type '::Log' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__Log_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'Log'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "Log", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "Log");
d = md;
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_LOG_ERROR",SWIG_From_int((int)(GP_LOG_ERROR)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_LOG_VERBOSE",SWIG_From_int((int)(GP_LOG_VERBOSE)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_LOG_DEBUG",SWIG_From_int((int)(GP_LOG_DEBUG)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_LOG_DATA",SWIG_From_int((int)(GP_LOG_DATA)));
#if PY_VERSION_HEX >= 0x03000000
return m;
#else
return;
#endif
}
python-gphoto2-2.5.1/src/swig-gp2_5_31/port_wrap.c 0000664 0000000 0000000 00000510666 14703210004 0021563 0 ustar 00root root 0000000 0000000 /* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (https://www.swig.org).
* Version 4.1.1
*
* Do not make changes to this file unless you know what you are doing - modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
#define SWIG_VERSION 0x040101
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_BUILTIN
#define SWIGPYTHON_FASTPROXY
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if defined(__GNUC__)
# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
/* Intel's compiler complains if a variable which was never initialised is
* cast to void, which is a common idiom which we use to indicate that we
* are aware a variable isn't used. So we just silence that warning.
* See: https://github.com/swig/swig/issues/192 for more discussion.
*/
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include
#endif
#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
* See https://github.com/swig/swig/issues/2090 */
# include
#endif
# undef _DEBUG
# include
# define _DEBUG 1
#else
# include
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
creating a static or dynamic library from the SWIG runtime code.
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
But only do this if strictly necessary, ie, if you have problems
with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif
#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif
/* Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
#define SWIG_POINTER_NO_NULL 0x4
#define SWIG_POINTER_CLEAR 0x8
#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
if (SWIG_IsOK(res)) {
// success code
if (SWIG_IsNewObj(res) {
...
delete *ptr;
} else {
...
}
} else {
// fail code
}
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if () {
if () {
*ptr = ;
return SWIG_NEWOBJ;
} else {
*ptr = ;
return SWIG_OLDOBJ;
}
} else {
return SWIG_BADOBJ;
}
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows returning the 'cast rank', for example, if you have this
int food(double)
int fooi(int);
and you call
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
*/
#define SWIG_OK (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ (SWIG_ERROR)
#define SWIG_OLDOBJ (SWIG_OK)
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
# define SWIG_TypeRank unsigned long
# endif
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
# define SWIG_MAXCASTRANK (2)
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
# define SWIG_AddCast(r) (r)
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
#include
#ifdef __cplusplus
extern "C" {
#endif
typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
void *clientdata; /* language specific type data */
int owndata; /* flag if the structure owns the clientdata */
} swig_type_info;
/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
swig_type_info *type; /* pointer to type that is equivalent to this type */
swig_converter_func converter; /* function to cast the void pointers */
struct swig_cast_info *next; /* pointer to next cast in linked list */
struct swig_cast_info *prev; /* pointer to the previous cast */
} swig_cast_info;
/* Structure used to store module information
* Each module generates one structure like this, and the runtime collects
* all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
size_t size; /* Number of types in this module */
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
swig_type_info **type_initial; /* Array of initially generated type structures */
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
void *clientdata; /* Language specific module data */
} swig_module_info;
/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class" == "Class", etc.
Return 0 when the two name types are equivalent, as in
strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
const char *f2, const char *l2) {
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
while ((*f1 == ' ') && (f1 != l1)) ++f1;
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
return (int)((l1 - f1) - (l2 - f2));
}
/*
Check type equivalence in a name list like ||...
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
}
/*
Check type equivalence in a name list like ||...
Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (strcmp(iter->type->name, c) == 0) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
if (ty) {
swig_cast_info *iter = ty->cast;
while (iter) {
if (iter->type == from) {
if (iter == ty->cast)
return iter;
/* Move iter to the top of the linked list */
iter->prev->next = iter->next;
if (iter->next)
iter->next->prev = iter->prev;
iter->next = ty->cast;
iter->prev = 0;
if (ty->cast) ty->cast->prev = iter;
ty->cast = iter;
return iter;
}
iter = iter->next;
}
}
return 0;
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
swig_type_info *lastty = ty;
if (!ty || !ty->dcast) return ty;
while (ty && (ty->dcast)) {
ty = (*ty->dcast)(ptr);
if (ty) lastty = ty;
}
return lastty;
}
/*
Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
return ty->name;
}
/*
Return the pretty name associated with this type,
that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
/* The "str" field contains the equivalent pretty names of the
type, separated by vertical-bar characters. Choose the last
name. It should be the most specific; a fully resolved name
but not necessarily with default template parameters expanded. */
if (!type) return NULL;
if (type->str != NULL) {
const char *last_name = type->str;
const char *s;
for (s = type->str; *s; s++)
if (*s == '|') last_name = s+1;
return last_name;
}
else
return type->name;
}
/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
}
cast = cast->next;
}
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
size_t l = 0;
size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
r = i - 1;
} else {
break;
}
} else if (compare > 0) {
l = i + 1;
}
} else {
break; /* should never happen */
}
} while (l <= r);
}
iter = iter->next;
} while (iter != end);
return 0;
}
/*
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
if (ret) {
return ret;
} else {
/* STEP 2: If the type hasn't been found, do a complete search
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
}
iter = iter->next;
} while (iter != end);
}
/* neither found a match */
return 0;
}
/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
const unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
unsigned char *u = (unsigned char *) ptr;
const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
char d = *(c++);
unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
uu = (unsigned char)((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
uu |= (unsigned char)(d - ('a'-10));
else
return (char *) 0;
*u = uu;
}
return c;
}
/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
char *r = buff;
if ((2*sizeof(void *) + 2) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,&ptr,sizeof(void *));
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
strcpy(r,name);
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
*ptr = (void *) 0;
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sizeof(void *));
}
SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
char *r = buff;
size_t lname = (name ? strlen(name) : 0);
if ((2*sz + 2 + lname) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
if (lname) {
strncpy(r,name,lname+1);
} else {
*r = 0;
}
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
memset(ptr,0,sz);
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sz);
}
#ifdef __cplusplus
}
#endif
/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
#endif
#ifndef Py_TYPE
# define Py_TYPE(op) ((op)->ob_type)
#endif
/* SWIG APIs for compatibility of both Python 2 & 3 */
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
# define SWIG_Python_str_FromFormat PyString_FromFormat
#endif
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03030000
return (char *)PyUnicode_AsUTF8(str);
#else
return PyString_AsString(str);
#endif
}
/* Was useful for Python 3.0.x-3.2.x - now provided only for compatibility
* with any uses in user interface files. */
#define SWIG_Python_str_DelForPy3(x)
SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromString(c);
#else
return PyString_FromString(c);
#endif
}
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif
/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif
/* -----------------------------------------------------------------------------
* error manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
PyObject* type = 0;
switch(code) {
case SWIG_MemoryError:
type = PyExc_MemoryError;
break;
case SWIG_IOError:
type = PyExc_IOError;
break;
case SWIG_RuntimeError:
type = PyExc_RuntimeError;
break;
case SWIG_IndexError:
type = PyExc_IndexError;
break;
case SWIG_TypeError:
type = PyExc_TypeError;
break;
case SWIG_DivisionByZero:
type = PyExc_ZeroDivisionError;
break;
case SWIG_OverflowError:
type = PyExc_OverflowError;
break;
case SWIG_SyntaxError:
type = PyExc_SyntaxError;
break;
case SWIG_ValueError:
type = PyExc_ValueError;
break;
case SWIG_SystemError:
type = PyExc_SystemError;
break;
case SWIG_AttributeError:
type = PyExc_AttributeError;
break;
default:
type = PyExc_RuntimeError;
}
return type;
}
SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
if (PyErr_Occurred())
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
PyErr_Clear();
Py_XINCREF(type);
if (tmp)
PyErr_Format(type, "%s %s", tmp, mesg);
else
PyErr_Format(type, "%s", mesg);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
PyErr_SetString(PyExc_RuntimeError, mesg);
}
}
SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
PyObject *error;
if (obj)
return 0;
error = PyErr_Occurred();
return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}
SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
if (SWIG_Python_TypeErrorOccurred(NULL)) {
/* Use existing TypeError to preserve stacktrace and enhance with given message */
PyObject *newvalue;
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
if (newvalue) {
Py_XDECREF(value);
PyErr_Restore(type, newvalue, traceback);
} else {
PyErr_Restore(type, value, traceback);
}
} else {
/* Raise TypeError using given message */
PyErr_SetString(PyExc_TypeError, message);
}
}
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
# undef SWIG_PYTHON_THREADS
# endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
# define SWIG_PYTHON_USE_GIL
# endif
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# if PY_VERSION_HEX < 0x03070000
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
# else
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# endif
# ifdef __cplusplus /* C++ code */
class SWIG_Python_Thread_Block {
bool status;
PyGILState_STATE state;
public:
void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block() { end(); }
};
class SWIG_Python_Thread_Allow {
bool status;
PyThreadState *save;
public:
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow() { end(); }
};
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
# else /* C code */
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
# endif
# else /* Old thread way, not implemented, user must provide it */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
# define SWIG_PYTHON_THREAD_END_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# endif
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
# define SWIG_PYTHON_THREAD_END_ALLOW
# endif
# endif
#else /* No thread support */
# define SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# define SWIG_PYTHON_THREAD_END_BLOCK
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# define SWIG_PYTHON_THREAD_END_ALLOW
#endif
/* -----------------------------------------------------------------------------
* Python API portion that goes into the runtime
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* Constant declarations
* ----------------------------------------------------------------------------- */
/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY 5
/* Constant information structure */
typedef struct swig_const_info {
int type;
const char *name;
long lvalue;
double dvalue;
void *pvalue;
swig_type_info **ptype;
} swig_const_info;
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* pyrun.swg
*
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* type checking.
*
* ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif
#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#endif
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif
#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
#define SWIG_fail goto fail
/* Runtime API implementation */
/* Error manipulation */
SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetObject(errtype, obj);
Py_DECREF(obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetString(errtype, msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
/* Set a constant value */
#if defined(SWIGPYTHON_BUILTIN)
SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
PyObject *s = PyString_InternFromString(key);
PyList_Append(seq, s);
Py_DECREF(s);
}
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
if (public_interface)
SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}
#else
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
}
#endif
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyList_Check(result)) {
PyObject *o2 = result;
result = PyList_New(1);
if (result) {
PyList_SET_ITEM(result, 0, o2);
} else {
Py_DECREF(obj);
return o2;
}
}
PyList_Append(result,obj);
Py_DECREF(obj);
}
return result;
}
/* Unpack the argument tuple */
SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
if (!PyTuple_Check(args)) {
if (min <= 1 && max >= 1) {
Py_ssize_t i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
}
return 2;
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
Py_ssize_t i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
for (; l < max; ++l) {
objs[l] = 0;
}
return i + 1;
}
}
}
SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
int no_kwargs = 1;
if (kwargs) {
assert(PyDict_Check(kwargs));
if (PyDict_Size(kwargs) > 0) {
PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
no_kwargs = 0;
}
}
return no_kwargs;
}
/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
/*
Helper for static pointer initialization for both C and C++ code, for example
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var) var
#else
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Python-specific SWIG API */
#define SWIG_newvarlink() SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
/* -----------------------------------------------------------------------------
* global variable support code.
* ----------------------------------------------------------------------------- */
typedef struct swig_globalvar {
char *name; /* Name of global variable */
PyObject *(*get_attr)(void); /* Return the current value */
int (*set_attr)(PyObject *); /* Set the value */
struct swig_globalvar *next;
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar *vars;
} swig_varlinkobject;
SWIGINTERN PyObject *
swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_InternFromString("");
#else
return PyString_FromString("");
#endif
}
SWIGINTERN PyObject *
swig_varlink_str(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
PyObject *str = PyUnicode_InternFromString("(");
PyObject *tail;
PyObject *joined;
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
tail = PyUnicode_FromString(var->name);
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
if (var->next) {
tail = PyUnicode_InternFromString(", ");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
}
}
tail = PyUnicode_InternFromString(")");
joined = PyUnicode_Concat(str, tail);
Py_DecRef(str);
Py_DecRef(tail);
str = joined;
#else
PyObject *str = PyString_FromString("(");
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
return str;
}
SWIGINTERN void
swig_varlink_dealloc(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
swig_globalvar *var = v->vars;
while (var) {
swig_globalvar *n = var->next;
free(var->name);
free(var);
var = n;
}
}
SWIGINTERN PyObject *
swig_varlink_getattr(PyObject *o, char *n) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
PyObject *res = NULL;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->get_attr)();
break;
}
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN int
swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
int res = 1;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->set_attr)(p);
break;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
static char varlink__doc__[] = "Swig var link object";
static PyTypeObject varlink_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"swigvarlink", /* tp_name */
sizeof(swig_varlinkobject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) swig_varlink_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc) swig_varlink_getattr, /* tp_getattr */
(setattrfunc) swig_varlink_setattr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc) swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
varlink__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
varlink_type = tmp;
type_init = 1;
if (PyType_Ready(&varlink_type) < 0)
return NULL;
}
return &varlink_type;
}
/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
if (result) {
result->vars = 0;
}
return ((PyObject*) result);
}
SWIGINTERN void
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
memcpy(gv->name, name, size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
}
}
v->vars = gv;
}
static PyObject *Swig_Globals_global = NULL;
SWIGINTERN PyObject *
SWIG_globals(void) {
if (Swig_Globals_global == NULL) {
Swig_Globals_global = SWIG_newvarlink();
}
return Swig_Globals_global;
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* Pointer declarations
* ----------------------------------------------------------------------------- */
/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
#ifdef __cplusplus
extern "C" {
#endif
/* The python void return value */
SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)
{
PyObject *none = Py_None;
Py_INCREF(none);
return none;
}
/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
PyTypeObject *pytype;
} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
int fail = data ? data->implicitconv : 0;
if (fail)
PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
return fail;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
/* the newraw method and newargs arguments used to create a new raw instance */
if (PyClass_Check(obj)) {
data->newraw = 0;
Py_INCREF(obj);
data->newargs = obj;
} else {
data->newraw = PyObject_GetAttrString(data->klass, "__new__");
if (data->newraw) {
data->newargs = PyTuple_New(1);
if (data->newargs) {
Py_INCREF(obj);
PyTuple_SET_ITEM(data->newargs, 0, obj);
} else {
Py_DECREF(data->newraw);
Py_DECREF(data->klass);
free(data);
return 0;
}
} else {
Py_INCREF(obj);
data->newargs = obj;
}
}
/* the destroy method, aka as the C++ delete method */
data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
}
if (data->destroy) {
data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
} else {
data->delargs = 0;
}
data->implicitconv = 0;
data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData *data)
{
Py_XDECREF(data->klass);
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
free(data);
}
/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
PyObject *dict;
#endif
} SwigPyObject;
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
if (!sobj->dict)
sobj->dict = PyDict_New();
Py_XINCREF(sobj->dict);
return sobj->dict;
}
#endif
SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
PyObject *val = SwigPyObject_long(v);
if (val) {
PyObject *ofmt;
PyTuple_SET_ITEM(args, 0, val);
ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
res = PyUnicode_Format(ofmt,args);
#else
res = PyString_Format(ofmt,args);
#endif
Py_DECREF(ofmt);
}
}
Py_DECREF(args);
}
return res;
}
SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v);
if (repr && v->next) {
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
PyObject *joined = PyUnicode_Concat(repr, nrep);
Py_DecRef(repr);
Py_DecRef(nrep);
repr = joined;
# else
PyString_ConcatAndDel(&repr,nrep);
# endif
} else {
Py_DecRef(repr);
repr = NULL;
}
}
return repr;
}
/* We need a version taking two PyObject* parameters so it's a valid
* PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
return SwigPyObject_repr((SwigPyObject*)v);
}
SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
PyObject* res;
if( op != Py_EQ && op != Py_NE ) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
return res;
}
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
SwigPyClientData *cd;
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
assert(cd);
assert(cd->pytype);
return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
#endif
SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
PyTypeObject *target_tp = SwigPyObject_type();
if (PyType_IsSubtype(op->ob_type, target_tp))
return 1;
return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
return (Py_TYPE(op) == SwigPyObject_type())
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
static PyObject* Swig_Capsule_global = NULL;
SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
/* PyObject_CallFunction() has the potential to silently drop
the active exception. In cases of unnamed temporary
variable or where we just finished iterating over a generator
StopIteration will be active right now, and this needs to
remain true upon return from SwigPyObject_dealloc. So save
and restore. */
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
if (data->delargs) {
/* we need to create a temporary object to carry the destroy operation */
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
if (tmp) {
res = SWIG_Python_CallFunctor(destroy, tmp);
} else {
res = 0;
}
Py_XDECREF(tmp);
} else {
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
PyObject *mself = PyCFunction_GET_SELF(destroy);
res = ((*meth)(mself, v));
}
if (!res)
PyErr_WriteUnraisable(destroy);
PyErr_Restore(type, value, traceback);
Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
else {
const char *name = SWIG_TypePrettyName(ty);
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
#endif
Py_XDECREF(Swig_Capsule_global);
}
Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
Py_XDECREF(sobj->dict);
#endif
PyObject_DEL(v);
}
SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject* v, PyObject* next)
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (!SwigPyObject_Check(next)) {
PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
((SwigPyObject *)next)->next = sobj->next;
sobj->next = next;
Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
return NULL;
} else {
SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
if (PyObject_IsTrue(val)) {
Py_DECREF(SwigPyObject_acquire(v,args));
} else {
Py_DECREF(SwigPyObject_disown(v,args));
}
}
return obj;
}
}
static PyMethodDef
swigobject_methods[] = {
{"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
{"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
{"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
{"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
{"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
{"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
{0, 0, 0, 0}
};
SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
/* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
#endif
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
(unaryfunc)0, /*nb_negative*/
(unaryfunc)0, /*nb_positive*/
(unaryfunc)0, /*nb_absolute*/
(inquiry)0, /*nb_nonzero*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
0, /*nb_coerce*/
#endif
(unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_long, /*nb_long*/
#else
0, /*nb_reserved*/
#endif
(unaryfunc)0, /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
};
static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyObject", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
(cmpfunc)SwigPyObject_compare, /* tp_compare */
#endif
(reprfunc)SwigPyObject_repr, /* tp_repr */
&SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigobject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
(richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
swigobject_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobject_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpyobject_type) != 0)
return NULL;
}
return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
sobj->own = own;
sobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
sobj->dict = 0;
#endif
if (own == SWIG_POINTER_OWN) {
/* Obtain a reference to the Python capsule wrapping the module information, so that the
* module information is correctly destroyed after all SWIG python objects have been freed
* by the GC (and corresponding destructors invoked) */
Py_XINCREF(Swig_Capsule_global);
}
}
return (PyObject *)sobj;
}
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
void *pack;
swig_type_info *ty;
size_t size;
} SwigPyPacked;
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return SWIG_Python_str_FromFormat("", result, v->ty->name);
} else {
return SWIG_Python_str_FromFormat("", v->ty->name);
}
}
SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}
SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
return ((op)->ob_type == SwigPyPacked_TypeOnce())
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
if (SwigPyPacked_Check(v)) {
SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"SwigPyPacked", /* tp_name */
sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /*tp_print*/
#else
(Py_ssize_t)0, /*tp_vectorcall_offset*/
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
0, /* tp_reserved in 3.0.1 */
#else
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
#endif
(reprfunc)SwigPyPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigpacked_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpypacked_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpypacked_type) != 0)
return NULL;
}
return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
memcpy(pack, ptr, size);
sobj->pack = pack;
sobj->ty = ty;
sobj->size = size;
} else {
PyObject_DEL((PyObject *) sobj);
sobj = 0;
}
}
return (PyObject *) sobj;
}
SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (SwigPyPacked_Check(obj)) {
SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
} else {
return 0;
}
}
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
static PyObject *Swig_This_global = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
if (Swig_This_global == NULL)
Swig_This_global = SWIG_Python_str_FromChar("this");
return Swig_This_global;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS
#endif
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
PyObject *obj;
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
#ifdef SWIGPYTHON_BUILTIN
(void)obj;
# ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
pyobj = PyWeakref_GET_OBJECT(pyobj);
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
# endif
return NULL;
#else
obj = 0;
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
}
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
#endif
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
return oldown;
}
}
return 0;
}
/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
int res;
SwigPyObject *sobj;
int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
if (!obj)
return SWIG_ERROR;
if (obj == Py_None && !implicit_conv) {
if (ptr)
*ptr = 0;
return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
}
res = SWIG_ERROR;
sobj = SWIG_Python_GetSwigThis(obj);
if (own)
*own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
swig_type_info *to = sobj->ty;
if (to == ty) {
/* no type cast needed */
if (ptr) *ptr = vptr;
break;
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
sobj = (SwigPyObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
if (own)
*own = *own | SWIG_CAST_NEW_MEMORY;
}
}
break;
}
}
} else {
if (ptr) *ptr = vptr;
break;
}
}
if (sobj) {
if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
res = SWIG_ERROR_RELEASE_NOT_OWNED;
} else {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
if (flags & SWIG_POINTER_CLEAR) {
sobj->ptr = 0;
}
res = SWIG_OK;
}
} else {
if (implicit_conv) {
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
PyObject *impconv;
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
impconv = SWIG_Python_CallFunctor(klass, obj);
data->implicitconv = 0;
if (PyErr_Occurred()) {
PyErr_Clear();
impconv = 0;
}
if (impconv) {
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
if (SWIG_IsOK(res)) {
if (ptr) {
*ptr = vptr;
/* transfer the ownership to 'ptr' */
iobj->own = 0;
res = SWIG_AddCast(res);
res = SWIG_AddNewMask(res);
} else {
res = SWIG_AddCast(res);
}
}
}
Py_DECREF(impconv);
}
}
}
if (!SWIG_IsOK(res) && obj == Py_None) {
if (ptr)
*ptr = 0;
if (PyErr_Occurred())
PyErr_Clear();
res = SWIG_OK;
}
}
}
return res;
}
/* Convert a function ptr value */
SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
if (!PyCFunction_Check(obj)) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
swig_cast_info *tc;
/* here we get the method pointer for callbacks */
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
if (!desc)
return SWIG_ERROR;
tc = SWIG_TypeCheck(desc,ty);
if (tc) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
} else {
return SWIG_ERROR;
}
return SWIG_OK;
}
}
/* Convert a packed pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
/* check type cast? */
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* -----------------------------------------------------------------------------
* Create a new pointer object
* ----------------------------------------------------------------------------- */
/*
Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
inst = PyObject_Call(newraw, data->newargs, NULL);
if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
Py_DECREF(inst);
inst = 0;
}
}
#else
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
}
#endif
}
} else {
#if PY_VERSION_HEX >= 0x03000000
PyObject *empty_args = PyTuple_New(0);
if (empty_args) {
PyObject *empty_kwargs = PyDict_New();
if (empty_kwargs) {
inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
Py_DECREF(empty_kwargs);
if (inst) {
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
Py_DECREF(inst);
inst = 0;
} else {
PyType_Modified(Py_TYPE(inst));
}
}
}
Py_DECREF(empty_args);
}
#else
PyObject *dict = PyDict_New();
if (dict) {
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
}
#endif
}
return inst;
}
SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
if (dict) {
return PyDict_SetItem(dict, SWIG_This(), swig_this);
} else{
return -1;
}
}
#endif
return PyObject_SetAttr(inst, SWIG_This(), swig_this);
}
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
return NULL;
} else {
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
} else {
if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
return NULL;
}
return SWIG_Py_Void();
}
}
/* Create a new pointer object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
SwigPyClientData *clientdata;
PyObject * robj;
int own;
if (!ptr)
return SWIG_Py_Void();
clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
if (clientdata && clientdata->pytype) {
SwigPyObject *newobj;
if (flags & SWIG_BUILTIN_TP_INIT) {
newobj = (SwigPyObject*) self;
if (newobj->ptr) {
PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
while (newobj->next)
newobj = (SwigPyObject *) newobj->next;
newobj->next = next_self;
newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
newobj->dict = 0;
#endif
}
} else {
newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
if (newobj) {
newobj->dict = 0;
}
#endif
}
if (newobj) {
newobj->ptr = ptr;
newobj->ty = type;
newobj->own = own;
newobj->next = 0;
return (PyObject*) newobj;
}
return SWIG_Py_Void();
}
assert(!(flags & SWIG_BUILTIN_TP_INIT));
robj = SwigPyObject_New(ptr, type, own);
if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
Py_DECREF(robj);
robj = inst;
}
return robj;
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
* Get type list
* -----------------------------------------------------------------------------*/
#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif
static PyObject *Swig_TypeCache_global = NULL;
/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
if (Swig_TypeCache_global == NULL) {
Swig_TypeCache_global = PyDict_New();
}
return Swig_TypeCache_global;
}
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
}
#else
void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
}
#endif
return (swig_module_info *) type_pointer;
}
static int interpreter_counter = 0; // how many (sub-)interpreters are using swig_module's types
SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
swig_type_info **types = swig_module->types;
size_t i;
if (--interpreter_counter != 0) // another sub-interpreter may still be using the swig_module's types
return;
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
ty->clientdata = 0;
if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
Swig_This_global = NULL;
Py_DECREF(SWIG_globals());
Swig_Globals_global = NULL;
Py_DECREF(SWIG_Python_TypeCache());
Swig_TypeCache_global = NULL;
Swig_Capsule_global = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
/* Add a dummy module object into sys.modules */
PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && module) {
if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
++interpreter_counter;
Swig_Capsule_global = pointer;
} else {
Py_DECREF(pointer);
}
} else {
Py_XDECREF(pointer);
}
}
SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
PyObject *key = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
} else {
swig_module_info *swig_module = SWIG_GetModule(0);
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
obj = PyCapsule_New((void*) descriptor, NULL, NULL);
if (obj) {
PyDict_SetItem(cache, key, obj);
Py_DECREF(obj);
}
}
}
Py_DECREF(key);
return descriptor;
}
/*
For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION 0
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
const char *tmp = SWIG_Python_str_AsChar(old_str);
const char *errmesg = tmp ? tmp : "Invalid error message";
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, errmesg);
} else {
PyErr_Format(type, "%s %s", errmesg, mesg);
}
Py_DECREF(old_str);
}
return 1;
} else {
return 0;
}
}
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
if (PyErr_Occurred()) {
/* add information about failing argument */
char mesg[256];
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
} else {
return 0;
}
}
SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : "";
}
SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
if (obj && SwigPyObject_Check(obj)) {
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
type, otype);
return;
}
} else
#endif
{
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
}
Py_XDECREF(str);
return;
}
}
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
} else {
PyErr_Format(PyExc_TypeError, "unexpected type is received");
}
}
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
}
return result;
}
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
PyTypeObject *tp = obj->ob_type;
PyObject *descr;
PyObject *encoded_name;
descrsetfunc f;
int res = -1;
# ifdef Py_USING_UNICODE
if (PyString_Check(name)) {
name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
if (!name)
return -1;
} else if (!PyUnicode_Check(name))
# else
if (!PyString_Check(name))
# endif
{
PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
return -1;
} else {
Py_INCREF(name);
}
if (!tp->tp_dict) {
if (PyType_Ready(tp) != 0)
goto done;
}
descr = _PyType_Lookup(tp, name);
f = NULL;
if (descr != NULL)
f = descr->ob_type->tp_descr_set;
if (!f) {
if (PyString_Check(name)) {
encoded_name = name;
Py_INCREF(name);
} else {
encoded_name = PyUnicode_AsUTF8String(name);
if (!encoded_name)
goto done;
}
PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
Py_DECREF(encoded_name);
} else {
res = f(descr, obj, value);
}
done:
Py_DECREF(name);
return res;
}
#endif
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN Py_hash_t
SwigPyObject_hash(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
void *ptr = sobj->ptr;
#if PY_VERSION_HEX < 0x03020000
return (Py_hash_t)(Py_ssize_t)ptr;
#else
return (Py_hash_t)ptr;
#endif
}
SWIGINTERN Py_hash_t
SWIG_PyNumber_AsPyHash(PyObject *obj) {
Py_hash_t result = -1;
#if PY_VERSION_HEX < 0x03020000
if (PyInt_Check(obj))
result = PyInt_AsLong(obj);
else if (PyLong_Check(obj))
result = PyLong_AsLong(obj);
#else
if (PyNumber_Check(obj))
result = PyNumber_AsSsize_t(obj, NULL);
#endif
else
PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
return PyErr_Occurred() ? -1 : result;
}
SWIGINTERN int
SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
return -1;
}
SWIGINTERN void
SwigPyBuiltin_BadDealloc(PyObject *obj) {
SwigPyObject *sobj = (SwigPyObject *)obj;
if (sobj->own) {
PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", obj->ob_type->tp_name);
}
}
typedef struct {
PyCFunction get;
PyCFunction set;
} SwigPyGetSet;
SWIGINTERN PyObject *
SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
tuple = PyTuple_New(0);
assert(tuple);
result = (*getset->get)(obj, tuple);
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyObject *
SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure)
return SWIG_Py_Void();
getset = (SwigPyGetSet *)closure;
if (!getset->get)
return SWIG_Py_Void();
result = (*getset->get)(obj, NULL);
return result;
}
SWIGINTERN int
SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *tuple, *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(val);
PyTuple_SET_ITEM(tuple, 0, val);
result = (*getset->set)(obj, tuple);
Py_DECREF(tuple);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN int
SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
SwigPyGetSet *getset;
PyObject *result;
if (!closure) {
PyErr_Format(PyExc_TypeError, "Missing getset closure");
return -1;
}
getset = (SwigPyGetSet *)closure;
if (!getset->set) {
PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
return -1;
}
result = (*getset->set)(obj, val);
Py_XDECREF(result);
return result ? 0 : -1;
}
SWIGINTERN void
SwigPyStaticVar_dealloc(PyDescrObject *descr) {
PyObject_GC_UnTrack(descr);
Py_XDECREF(PyDescr_TYPE(descr));
Py_XDECREF(PyDescr_NAME(descr));
PyObject_GC_Del(descr);
}
SWIGINTERN PyObject *
SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
#if PY_VERSION_HEX >= 0x03000000
return PyUnicode_FromFormat("", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
return PyString_FromFormat("", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
}
SWIGINTERN int
SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
PyDescrObject *descr;
descr = (PyDescrObject *)self;
Py_VISIT((PyObject*) PyDescr_TYPE(descr));
return 0;
}
SWIGINTERN PyObject *
SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
if (descr->d_getset->get != NULL)
return descr->d_getset->get(obj, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return NULL;
}
SWIGINTERN int
SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
if (descr->d_getset->set != NULL)
return descr->d_getset->set(obj, value, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
return -1;
}
SWIGINTERN int
SwigPyObjectType_setattro(PyObject *typeobject, PyObject *name, PyObject *value) {
PyObject *attribute;
PyTypeObject *type;
descrsetfunc local_set;
assert(PyType_Check(typeobject));
type = (PyTypeObject *)typeobject;
attribute = _PyType_Lookup(type, name);
if (attribute != NULL) {
/* Implement descriptor functionality, if any */
local_set = attribute->ob_type->tp_descr_set;
if (local_set != NULL)
return local_set(attribute, (PyObject *)type, value);
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
} else {
#if PY_VERSION_HEX >= 0x03000000
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
#else
PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
}
return -1;
}
SWIGINTERN PyTypeObject*
SwigPyStaticVar_Type(void) {
static PyTypeObject staticvar_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"swig_static_var_getset_descriptor", /* tp_name */
sizeof(PyGetSetDescrObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyStaticVar_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
(reprfunc)SwigPyStaticVar_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
0, /* tp_doc */
SwigPyStaticVar_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc)SwigPyStaticVar_get, /* tp_descr_get */
(descrsetfunc)SwigPyStaticVar_set, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
staticvar_type = tmp;
type_init = 1;
if (PyType_Ready(&staticvar_type) < 0)
return NULL;
}
return &staticvar_type;
}
SWIGINTERN PyTypeObject*
SwigPyObjectType(void) {
static char swigpyobjecttype_doc[] = "Metaclass for SWIG wrapped types";
static PyTypeObject swigpyobjecttype_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
#endif
"SwigPyObjectType", /* tp_name */
PyType_Type.tp_basicsize, /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
SwigPyObjectType_setattro, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
swigpyobjecttype_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
swigpyobjecttype_type = tmp;
type_init = 1;
swigpyobjecttype_type.tp_base = &PyType_Type;
if (PyType_Ready(&swigpyobjecttype_type) < 0)
return NULL;
}
return &swigpyobjecttype_type;
}
SWIGINTERN PyGetSetDescrObject *
SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
PyGetSetDescrObject *descr;
descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
assert(descr);
Py_XINCREF(type);
PyDescr_TYPE(descr) = type;
PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
descr->d_getset = getset;
if (PyDescr_NAME(descr) == NULL) {
Py_DECREF(descr);
descr = NULL;
}
return descr;
}
SWIGINTERN void
SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
Py_ssize_t base_count = 0;
PyTypeObject **b;
PyObject *tuple;
Py_ssize_t i;
if (!bases[0]) {
bases[0] = SwigPyObject_type();
bases[1] = NULL;
}
type->tp_base = bases[0];
Py_INCREF((PyObject *)bases[0]);
for (b = bases; *b != NULL; ++b)
++base_count;
tuple = PyTuple_New(base_count);
for (i = 0; i < base_count; ++i) {
Py_INCREF((PyObject *)bases[i]);
PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
}
type->tp_bases = tuple;
}
SWIGINTERN PyObject *
SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
PyObject *result;
result = (PyObject *)SWIG_Python_GetSwigThis(self);
Py_XINCREF(result);
return result;
}
SWIGINTERN void
SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
{
#if PY_VERSION_HEX >= 0x030900a4
Py_SET_TYPE(type, metatype);
#else
Py_TYPE(type) = metatype;
#endif
}
/* Start of callback function macros for use in PyTypeObject */
typedef PyObject *(*SwigPyWrapperFunction)(PyObject *, PyObject *);
#define SWIGPY_UNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_unaryfunc_closure(PyObject *a) { \
return SwigPyBuiltin_unaryfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_unaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper) \
SWIGINTERN void \
wrapper##_destructor_closure(PyObject *a) { \
SwigPyBuiltin_destructor_closure(wrapper, #wrapper, a); \
}
SWIGINTERN void
SwigPyBuiltin_destructor_closure(SwigPyWrapperFunction wrapper, const char *wrappername, PyObject *a) {
SwigPyObject *sobj;
sobj = (SwigPyObject *)a;
Py_XDECREF(sobj->dict);
if (sobj->own) {
PyObject *o;
PyObject *type = 0, *value = 0, *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
o = wrapper(a, NULL);
if (!o) {
PyObject *deallocname = PyString_FromString(wrappername);
PyErr_WriteUnraisable(deallocname);
Py_DECREF(deallocname);
}
PyErr_Restore(type, value, traceback);
Py_XDECREF(o);
}
if (PyType_IS_GC(a->ob_type)) {
PyObject_GC_Del(a);
} else {
PyObject_Del(a);
}
}
#define SWIGPY_INQUIRY_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_inquiry_closure(PyObject *a) { \
return SwigPyBuiltin_inquiry_closure(wrapper, a); \
}
SWIGINTERN int
SwigPyBuiltin_inquiry_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
int result;
pyresult = wrapper(a, NULL);
result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_GETITERFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_getiterfunc_closure(PyObject *a) { \
return SwigPyBuiltin_getiterfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_getiterfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_BINARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_binaryfunc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_binaryfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_binaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
typedef ternaryfunc ternarycallfunc;
#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternaryfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternaryfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ternarycallfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_ternarycallfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternarycallfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
(void) c;
return wrapper(a, b);
}
#define SWIGPY_LENFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_ssize_t \
wrapper##_lenfunc_closure(PyObject *a) { \
return SwigPyBuiltin_lenfunc_closure(wrapper, a); \
}
SWIGINTERN Py_ssize_t
SwigPyBuiltin_lenfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *resultobj;
Py_ssize_t result;
resultobj = wrapper(a, NULL);
result = PyNumber_AsSsize_t(resultobj, NULL);
Py_DECREF(resultobj);
return result;
}
#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizessizeargfunc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) { \
return SwigPyBuiltin_ssizessizeargfunc_closure(wrapper, a, b, c); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizessizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c) {
PyObject *tuple, *result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizessizeobjargproc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
return SwigPyBuiltin_ssizessizeobjargproc_closure(wrapper, a, b, c, d); \
}
SWIGINTERN int
SwigPyBuiltin_ssizessizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(d ? 3 : 2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
if (d) {
Py_INCREF(d);
PyTuple_SET_ITEM(tuple, 2, d);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_DECREF(tuple);
Py_XDECREF(resultobj);
return result;
}
#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_funpack_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_funpack_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *tuple, *result;
tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
result = wrapper(a, tuple);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
return SwigPyBuiltin_ssizeargfunc_closure(wrapper, a, b); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
PyObject *arg, *result;
arg = _PyLong_FromSsize_t(b);
result = wrapper(a, arg);
Py_DECREF(arg);
return result;
}
#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_ssizeobjargproc_closure(PyObject *a, Py_ssize_t b, PyObject *c) { \
return SwigPyBuiltin_ssizeobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_ssizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(2);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
PyObject *tuple;
tuple = PyTuple_New(1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
pyresult = wrapper(a, tuple);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_FUNPACK_OBJOBJPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjproc_closure(PyObject *a, PyObject *b) { \
return SwigPyBuiltin_funpack_objobjproc_closure(wrapper, a, b); \
}
SWIGINTERN int
SwigPyBuiltin_funpack_objobjproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
int result;
PyObject *pyresult;
pyresult = wrapper(a, b);
result = pyresult ? (PyObject_IsTrue(pyresult) ? 1 : 0) : -1;
Py_XDECREF(pyresult);
return result;
}
#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_objobjargproc_closure(PyObject *a, PyObject *b, PyObject *c) { \
return SwigPyBuiltin_objobjargproc_closure(wrapper, a, b, c); \
}
SWIGINTERN int
SwigPyBuiltin_objobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
PyObject *tuple, *resultobj;
int result;
tuple = PyTuple_New(c ? 2 : 1);
assert(tuple);
Py_INCREF(b);
PyTuple_SET_ITEM(tuple, 0, b);
if (c) {
Py_INCREF(c);
PyTuple_SET_ITEM(tuple, 1, c);
}
resultobj = wrapper(a, tuple);
result = resultobj ? 0 : -1;
Py_XDECREF(resultobj);
Py_DECREF(tuple);
return result;
}
#define SWIGPY_REPRFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_reprfunc_closure(PyObject *a) { \
return SwigPyBuiltin_reprfunc_closure(wrapper, a); \
}
SWIGINTERN PyObject *
SwigPyBuiltin_reprfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
#define SWIGPY_HASHFUNC_CLOSURE(wrapper) \
SWIGINTERN Py_hash_t \
wrapper##_hashfunc_closure(PyObject *a) { \
return SwigPyBuiltin_hashfunc_closure(wrapper, a); \
}
SWIGINTERN Py_hash_t
SwigPyBuiltin_hashfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
PyObject *pyresult;
Py_hash_t result;
pyresult = wrapper(a, NULL);
if (!pyresult)
return -1;
result = SWIG_PyNumber_AsPyHash(pyresult);
Py_DECREF(pyresult);
return result;
}
#define SWIGPY_ITERNEXTFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_iternextfunc_closure(PyObject *a) { \
return SwigPyBuiltin_iternextfunc_closure(wrapper, a);\
}
SWIGINTERN PyObject *
SwigPyBuiltin_iternextfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
return wrapper(a, NULL);
}
/* End of callback function macros for use in PyTypeObject */
#ifdef __cplusplus
}
#endif
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_GPPortType swig_types[0]
#define SWIGTYPE_p_SwigPyObject swig_types[1]
#define SWIGTYPE_p__GPLevel swig_types[2]
#define SWIGTYPE_p__GPPin swig_types[3]
#define SWIGTYPE_p__GPPort swig_types[4]
#define SWIGTYPE_p__GPPortInfo swig_types[5]
#define SWIGTYPE_p__GPPortInfoList swig_types[6]
#define SWIGTYPE_p__GPPortPrivateCore swig_types[7]
#define SWIGTYPE_p__GPPortPrivateLibrary swig_types[8]
#define SWIGTYPE_p__GPPortSerialParity swig_types[9]
#define SWIGTYPE_p__GPPortSettings swig_types[10]
#define SWIGTYPE_p__GPPortSettingsSerial swig_types[11]
#define SWIGTYPE_p__GPPortSettingsUSB swig_types[12]
#define SWIGTYPE_p__GPPortSettingsUsbDiskDirect swig_types[13]
#define SWIGTYPE_p__GPPortSettingsUsbScsi swig_types[14]
#define SWIGTYPE_p_char swig_types[15]
#define SWIGTYPE_p_p__GPPort swig_types[16]
#define SWIGTYPE_p_p__GPPortInfo swig_types[17]
static swig_type_info *swig_types[19];
static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery
/*-----------------------------------------------
@(target):= _port.so
------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
# define SWIG_init PyInit__port
#else
# define SWIG_init init_port
#endif
#define SWIG_name "_port"
#define SWIG_as_voidptr(a) (void *)((const void *)(a))
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
#include
#include "gphoto2/gphoto2.h"
PyObject *PyExc_GPhoto2Error = NULL;
SWIGINTERNINLINE PyObject*
SWIG_From_int (int value)
{
return PyInt_FromLong((long) value);
}
SWIGINTERN struct _GPPort *new__GPPort(void){
struct _GPPort *result;
int error = gp_port_new(&result);
if (error < GP_OK)
/*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
return result;
}
SWIGINTERN void delete__GPPort(struct _GPPort *self){
int error = gp_port_free(self);
if (error < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(error));
/*@SWIG@*/
}
SWIGINTERN void _GPPort_close(struct _GPPort *self){
int result = gp_port_close (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _GPPort_get_info(struct _GPPort *self,GPPortInfo *info){
int result = gp_port_get_info (self, info);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _GPPort_open(struct _GPPort *self){
int result = gp_port_open (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _GPPort_reset(struct _GPPort *self){
int result = gp_port_reset (self);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
SWIGINTERN void _GPPort_set_info(struct _GPPort *self,GPPortInfo info){
int result = gp_port_set_info (self, info);
if (result < GP_OK) /*@SWIG:src/gphoto2/common/macros.i,40,GPHOTO2_ERROR@*/
PyErr_SetObject(PyExc_GPhoto2Error, PyInt_FromLong(result));
/*@SWIG@*/
}
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN int _wrap_new_GPPort(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
struct _GPPort *result = 0 ;
(void)self;
if (!SWIG_Python_CheckNoKeywords(kwargs, "new_GPPort")) SWIG_fail;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "new_GPPort takes no arguments");
{
result = (struct _GPPort *)new__GPPort();
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__GPPort, SWIG_BUILTIN_INIT | 0 );
return resultobj == Py_None ? -1 : 0;
fail:
return -1;
}
SWIGINTERN PyObject *_wrap_delete_GPPort(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPort *arg1 = (struct _GPPort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "delete_GPPort takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPort, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GPPort" "', argument " "1"" of type '" "struct _GPPort *""'");
}
arg1 = (struct _GPPort *)(argp1);
{
delete__GPPort(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPort_close(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPort *arg1 = (struct _GPPort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "GPPort_close takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPort_close" "', argument " "1"" of type '" "struct _GPPort *""'");
}
arg1 = (struct _GPPort *)(argp1);
{
_GPPort_close(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPort_get_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPort *arg1 = (struct _GPPort *) 0 ;
GPPortInfo *arg2 = (GPPortInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
GPPortInfo temp2 ;
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "GPPort_get_info takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPort_get_info" "', argument " "1"" of type '" "struct _GPPort *""'");
}
arg1 = (struct _GPPort *)(argp1);
{
_GPPort_get_info(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p__GPPortInfo, 0));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPort_open(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPort *arg1 = (struct _GPPort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "GPPort_open takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPort_open" "', argument " "1"" of type '" "struct _GPPort *""'");
}
arg1 = (struct _GPPort *)(argp1);
{
_GPPort_open(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPort_reset(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPort *arg1 = (struct _GPPort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
(void)self;
if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, "GPPort_reset takes no arguments");
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPort_reset" "', argument " "1"" of type '" "struct _GPPort *""'");
}
arg1 = (struct _GPPort *)(argp1);
{
_GPPort_reset(arg1);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_GPPort_set_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
struct _GPPort *arg1 = (struct _GPPort *) 0 ;
GPPortInfo arg2 = (GPPortInfo) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj1 = 0 ;
(void)self;
if (!PyArg_UnpackTuple(args, "GPPort_set_info", 1, 1, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__GPPort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPPort_set_info" "', argument " "1"" of type '" "struct _GPPort *""'");
}
arg1 = (struct _GPPort *)(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPPortInfo, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GPPort_set_info" "', argument " "2"" of type '" "GPPortInfo""'");
}
arg2 = (GPPortInfo)(argp2);
{
_GPPort_set_info(arg1,arg2);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GPPort) /* defines _wrap_delete_GPPort_destructor_closure */
SWIGINTERN PyObject *_wrap_gp_port_new(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPort **arg1 = (GPPort **) 0 ;
GPPort *temp1 ;
int result;
{
temp1 = NULL;
arg1 = &temp1;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_new", 0, 0)) SWIG_fail;
result = (int)gp_port_new(arg1);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg1, SWIGTYPE_p__GPPort, SWIG_POINTER_OWN));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_set_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPort *arg1 = (GPPort *) 0 ;
GPPortInfo arg2 = (GPPortInfo) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_set_info", 2, 2, &obj0, &obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_set_info" "', argument " "1"" of type '" "GPPort *""'");
}
arg1 = (GPPort *)(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__GPPortInfo, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gp_port_set_info" "', argument " "2"" of type '" "GPPortInfo""'");
}
arg2 = (GPPortInfo)(argp2);
result = (int)gp_port_set_info(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_get_info(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPort *arg1 = (GPPort *) 0 ;
GPPortInfo *arg2 = (GPPortInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
GPPortInfo temp2 ;
PyObject * obj0 = 0 ;
int result;
{
temp2 = NULL;
arg2 = &temp2;
}
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_get_info", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_get_info" "', argument " "1"" of type '" "GPPort *""'");
}
arg1 = (GPPort *)(argp1);
result = (int)gp_port_get_info(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
{
resultobj = SWIG_Python_AppendOutput(
resultobj, SWIG_NewPointerObj(*arg2, SWIGTYPE_p__GPPortInfo, 0));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_open(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPort *arg1 = (GPPort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_open", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_open" "', argument " "1"" of type '" "GPPort *""'");
}
arg1 = (GPPort *)(argp1);
result = (int)gp_port_open(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_close(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPort *arg1 = (GPPort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_close", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_close" "', argument " "1"" of type '" "GPPort *""'");
}
arg1 = (GPPort *)(argp1);
result = (int)gp_port_close(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_gp_port_reset(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
GPPort *arg1 = (GPPort *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
(void)self;
if (!PyArg_UnpackTuple(args, "gp_port_reset", 1, 1, &obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__GPPort, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gp_port_reset" "', argument " "1"" of type '" "GPPort *""'");
}
arg1 = (GPPort *)(argp1);
result = (int)gp_port_reset(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
static PyMethodDef SwigMethods[] = {
{ "gp_port_new", _wrap_gp_port_new, METH_VARARGS, "\n"
"gp_port_new() -> int\n"
"Create new GPPort. \n"
"\n"
"Allocate and initialize the memory for a new GPPort. \n"
"\n"
"After you called this function, you probably want to call\n"
"gp_port_set_info in order to make the newly created port functional. \n"
"\n"
"Parameters\n"
"----------\n"
"* `port` : \n"
" Pointer the GPPort* pointer \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
""},
{ "gp_port_set_info", _wrap_gp_port_set_info, METH_VARARGS, "\n"
"gp_port_set_info(port, info) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"port: GPPort *\n"
"info: gphoto2.GPPortInfo\n"
"\n"
"Configure a port. \n"
"\n"
"Makes a port functional by passing in the necessary path information\n"
"(from the serial:/dev/ttyS0 or similar variables). After calling this\n"
"function, you can access the port using for example gp_port_open(). \n"
"\n"
"Parameters\n"
"----------\n"
"* `port` : \n"
" a GPPort \n"
"* `info` : \n"
" the GPPortInfo to set \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
""},
{ "gp_port_get_info", _wrap_gp_port_get_info, METH_VARARGS, "\n"
"gp_port_get_info(port) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"port: GPPort *\n"
"\n"
"Retreives information about the port. \n"
"\n"
"Retrieves the informations set by gp_port_set_info(). \n"
"\n"
"Parameters\n"
"----------\n"
"* `port` : \n"
" a GPPort \n"
"* `info` : \n"
" GPPortInfo \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
""},
{ "gp_port_open", _wrap_gp_port_open, METH_VARARGS, "\n"
"gp_port_open(port) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"port: GPPort *\n"
"\n"
"Open a port. \n"
"\n"
"Parameters\n"
"----------\n"
"* `port` : \n"
" a GPPort \n"
"\n"
"Opens a port which should have been created with gp_port_new and\n"
"configured with gp_port_set_info and gp_port_set_settings \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
""},
{ "gp_port_close", _wrap_gp_port_close, METH_VARARGS, "\n"
"gp_port_close(port) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"port: GPPort *\n"
"\n"
"Close a port. \n"
"\n"
"Parameters\n"
"----------\n"
"* `port` : \n"
" a GPPort \n"
"\n"
"Closes a port temporarily. It can afterwards be reopened using\n"
"gp_port_open. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
""},
{ "gp_port_reset", _wrap_gp_port_reset, METH_VARARGS, "\n"
"gp_port_reset(port) -> int\n"
"\n"
"Parameters\n"
"----------\n"
"port: GPPort *\n"
"\n"
"Reset a port. \n"
"\n"
"Parameters\n"
"----------\n"
"* `port` : \n"
" a GPPort \n"
"\n"
"Resets a port. Device will likely reconnect and appear under a new id. \n"
"\n"
"Returns\n"
"-------\n"
"a gphoto2 error code\n"
""},
{ NULL, NULL, 0, NULL }
};
static SwigPyGetSet GPPort___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin___GPPort_getset[] = {
{ (char *)"__dict__", SwigPyBuiltin_GetterClosure, 0, (char *)"\n"
"_GPPort\n"
"The GPhoto port structure. \n"
"\n"
"This structure tracks the physical connection of the device. It can\n"
"correspond the various methods of lowlevel access, serial usb and others\n"
"and abstracts them as much as possible. \n"
"\n"
"Frontends should consider this structure opaque and only use accessor\n"
"functions. \n"
"\n"
"Camera drivers should only access the type and pl members directly, and\n"
"use accessor functions for the rest. \n"
"\n"
"C++ includes: gphoto2-port.h\n"
"", &GPPort___dict___getset },
{ NULL, NULL, NULL, NULL, NULL } /* Sentinel */
};
SWIGINTERN PyObject *
SwigPyBuiltin___GPPort_richcompare(PyObject *self, PyObject *other, int op) {
PyObject *result = NULL;
PyObject *tuple = PyTuple_New(1);
assert(tuple);
PyTuple_SET_ITEM(tuple, 0, other);
Py_XINCREF(other);
if (!result) {
if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
} else {
result = Py_NotImplemented;
Py_INCREF(result);
}
}
Py_DECREF(tuple);
return result;
}
SWIGINTERN PyMethodDef SwigPyBuiltin___GPPort_methods[] = {
{ "close", _wrap_GPPort_close, METH_VARARGS, "close(self)" },
{ "get_info", _wrap_GPPort_get_info, METH_VARARGS, "get_info(self)" },
{ "open", _wrap_GPPort_open, METH_VARARGS, "open(self)" },
{ "reset", _wrap_GPPort_reset, METH_VARARGS, "reset(self)" },
{ "set_info", _wrap_GPPort_set_info, METH_VARARGS, "\n"
"set_info(self, info)\n"
"\n"
"Parameters\n"
"----------\n"
"info: gphoto2.GPPortInfo\n"
"\n"
"" },
{ NULL, NULL, 0, NULL } /* Sentinel */
};
static PyHeapTypeObject SwigPyBuiltin___GPPort_type = {
{
#if PY_VERSION_HEX >= 0x03000000
PyVarObject_HEAD_INIT(NULL, 0)
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"gphoto2.port.GPPort", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
_wrap_delete_GPPort_destructor_closure, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc) 0, /* tp_print */
#else
(Py_ssize_t) 0, /* tp_vectorcall_offset */
#endif
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
0, /* tp_compare */
#else
(cmpfunc) 0, /* tp_compare */
#endif
(reprfunc) 0, /* tp_repr */
&SwigPyBuiltin___GPPort_type.as_number, /* tp_as_number */
&SwigPyBuiltin___GPPort_type.as_sequence, /* tp_as_sequence */
&SwigPyBuiltin___GPPort_type.as_mapping, /* tp_as_mapping */
SwigPyObject_hash, /* tp_hash */
(ternaryfunc) 0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) 0, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
&SwigPyBuiltin___GPPort_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
#else
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
"\n"
"The GPhoto port structure. \n"
"\n"
"This structure tracks the physical connection of the device. It can\n"
"correspond the various methods of lowlevel access, serial usb and others\n"
"and abstracts them as much as possible. \n"
"\n"
"Frontends should consider this structure opaque and only use accessor\n"
"functions. \n"
"\n"
"Camera drivers should only access the type and pl members directly, and\n"
"use accessor functions for the rest. \n"
"\n"
"C++ includes: gphoto2-port.h\n"
"",/* tp_doc */
(traverseproc) 0, /* tp_traverse */
(inquiry) 0, /* tp_clear */
SwigPyBuiltin___GPPort_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc) 0, /* tp_iter */
(iternextfunc) 0, /* tp_iternext */
SwigPyBuiltin___GPPort_methods, /* tp_methods */
0, /* tp_members */
SwigPyBuiltin___GPPort_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc) 0, /* tp_descr_get */
(descrsetfunc) 0, /* tp_descr_set */
offsetof(SwigPyObject, dict), /* tp_dictoffset */
_wrap_new_GPPort, /* tp_init */
(allocfunc) 0, /* tp_alloc */
(newfunc) 0, /* tp_new */
(freefunc) 0, /* tp_free */
(inquiry) 0, /* tp_is_gc */
(PyObject *) 0, /* tp_bases */
(PyObject *) 0, /* tp_mro */
(PyObject *) 0, /* tp_cache */
(PyObject *) 0, /* tp_subclasses */
(PyObject *) 0, /* tp_weaklist */
(destructor) 0, /* tp_del */
(int) 0, /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
(destructor) 0, /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
(vectorcallfunc) 0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#ifdef COUNT_ALLOCS
(Py_ssize_t) 0, /* tp_allocs */
(Py_ssize_t) 0, /* tp_frees */
(Py_ssize_t) 0, /* tp_maxalloc */
0, /* tp_prev */
0, /* tp_next */
#endif
},
#if PY_VERSION_HEX >= 0x03050000
{
(unaryfunc) 0, /* am_await */
(unaryfunc) 0, /* am_aiter */
(unaryfunc) 0, /* am_anext */
# if PY_VERSION_HEX >= 0x030a0000
(sendfunc) 0, /* am_send */
# endif
},
#endif
{
(binaryfunc) 0, /* nb_add */
(binaryfunc) 0, /* nb_subtract */
(binaryfunc) 0, /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_divide */
#endif
(binaryfunc) 0, /* nb_remainder */
(binaryfunc) 0, /* nb_divmod */
(ternaryfunc) 0, /* nb_power */
(unaryfunc) 0, /* nb_negative */
(unaryfunc) 0, /* nb_positive */
(unaryfunc) 0, /* nb_absolute */
(inquiry) 0, /* nb_nonzero */
(unaryfunc) 0, /* nb_invert */
(binaryfunc) 0, /* nb_lshift */
(binaryfunc) 0, /* nb_rshift */
(binaryfunc) 0, /* nb_and */
(binaryfunc) 0, /* nb_xor */
(binaryfunc) 0, /* nb_or */
#if PY_VERSION_HEX < 0x03000000
(coercion) 0, /* nb_coerce */
#endif
(unaryfunc) 0, /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* nb_reserved */
#else
(unaryfunc) 0, /* nb_long */
#endif
(unaryfunc) 0, /* nb_float */
#if PY_VERSION_HEX < 0x03000000
(unaryfunc) 0, /* nb_oct */
(unaryfunc) 0, /* nb_hex */
#endif
(binaryfunc) 0, /* nb_inplace_add */
(binaryfunc) 0, /* nb_inplace_subtract */
(binaryfunc) 0, /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
(binaryfunc) 0, /* nb_inplace_divide */
#endif
(binaryfunc) 0, /* nb_inplace_remainder */
(ternaryfunc) 0, /* nb_inplace_power */
(binaryfunc) 0, /* nb_inplace_lshift */
(binaryfunc) 0, /* nb_inplace_rshift */
(binaryfunc) 0, /* nb_inplace_and */
(binaryfunc) 0, /* nb_inplace_xor */
(binaryfunc) 0, /* nb_inplace_or */
(binaryfunc) 0, /* nb_floor_divide */
(binaryfunc) 0, /* nb_true_divide */
(binaryfunc) 0, /* nb_inplace_floor_divide */
(binaryfunc) 0, /* nb_inplace_true_divide */
(unaryfunc) 0, /* nb_index */
#if PY_VERSION_HEX >= 0x03050000
(binaryfunc) 0, /* nb_matrix_multiply */
(binaryfunc) 0, /* nb_inplace_matrix_multiply */
#endif
},
{
(lenfunc) 0, /* mp_length */
(binaryfunc) 0, /* mp_subscript */
(objobjargproc) 0, /* mp_ass_subscript */
},
{
(lenfunc) 0, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(ssizeargfunc) 0, /* sq_repeat */
(ssizeargfunc) 0, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_slice */
#else
(ssizessizeargfunc) 0, /* sq_slice */
#endif
(ssizeobjargproc) 0, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
(void *) 0, /* was_sq_ass_slice */
#else
(ssizessizeobjargproc) 0, /* sq_ass_slice */
#endif
(objobjproc) 0, /* sq_contains */
(binaryfunc) 0, /* sq_inplace_concat */
(ssizeargfunc) 0, /* sq_inplace_repeat */
},
{
#if PY_VERSION_HEX < 0x03000000
(readbufferproc) 0, /* bf_getreadbuffer */
(writebufferproc) 0, /* bf_getwritebuffer */
(segcountproc) 0, /* bf_getsegcount */
(charbufferproc) 0, /* bf_getcharbuffer */
#endif
(getbufferproc) 0, /* bf_getbuffer */
(releasebufferproc) 0, /* bf_releasebuffer */
},
(PyObject *) 0, /* ht_name */
(PyObject *) 0, /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
(PyObject *) 0, /* ht_qualname */
0, /* ht_cached_keys */
#endif
#if PY_VERSION_HEX >= 0x03090000
(PyObject *) 0, /* ht_module */
#endif
#if PY_VERSION_HEX >= 0x030b0000
(char *) 0, /* _ht_tpname */
{
(PyObject *) 0, /* getitem */
}
#endif
};
SWIGINTERN SwigPyClientData SwigPyBuiltin___GPPort_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___GPPort_type};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static swig_type_info _swigt__p_GPPortType = {"_p_GPPortType", "GPPortType *|enum GPPortType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwigPyObject = {"_p_SwigPyObject", "SwigPyObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPLevel = {"_p__GPLevel", "GPLevel *|enum _GPLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPin = {"_p__GPPin", "GPPin *|enum _GPPin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPort = {"_p__GPPort", "GPPort *|gp_port *|struct _GPPort *|_GPPort *", 0, 0, (void*)&SwigPyBuiltin___GPPort_clientdata, 0};
static swig_type_info _swigt__p__GPPortInfo = {"_p__GPPortInfo", "GPPortInfo|struct _GPPortInfo *|_GPPortInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortInfoList = {"_p__GPPortInfoList", "GPPortInfoList *|struct _GPPortInfoList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortPrivateCore = {"_p__GPPortPrivateCore", "GPPortPrivateCore *|struct _GPPortPrivateCore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortPrivateLibrary = {"_p__GPPortPrivateLibrary", "GPPortPrivateLibrary *|struct _GPPortPrivateLibrary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortSerialParity = {"_p__GPPortSerialParity", "GPPortSerialParity *|enum _GPPortSerialParity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortSettings = {"_p__GPPortSettings", "GPPortSettings *|gp_port_settings *|union _GPPortSettings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortSettingsSerial = {"_p__GPPortSettingsSerial", "GPPortSettingsSerial *|struct _GPPortSettingsSerial *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortSettingsUSB = {"_p__GPPortSettingsUSB", "GPPortSettingsUSB *|struct _GPPortSettingsUSB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortSettingsUsbDiskDirect = {"_p__GPPortSettingsUsbDiskDirect", "GPPortSettingsUsbDiskDirect *|struct _GPPortSettingsUsbDiskDirect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GPPortSettingsUsbScsi = {"_p__GPPortSettingsUsbScsi", "GPPortSettingsUsbScsi *|struct _GPPortSettingsUsbScsi *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__GPPort = {"_p_p__GPPort", "GPPort **|struct _GPPort **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__GPPortInfo = {"_p_p__GPPortInfo", "GPPortInfo *|struct _GPPortInfo **", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_GPPortType,
&_swigt__p_SwigPyObject,
&_swigt__p__GPLevel,
&_swigt__p__GPPin,
&_swigt__p__GPPort,
&_swigt__p__GPPortInfo,
&_swigt__p__GPPortInfoList,
&_swigt__p__GPPortPrivateCore,
&_swigt__p__GPPortPrivateLibrary,
&_swigt__p__GPPortSerialParity,
&_swigt__p__GPPortSettings,
&_swigt__p__GPPortSettingsSerial,
&_swigt__p__GPPortSettingsUSB,
&_swigt__p__GPPortSettingsUsbDiskDirect,
&_swigt__p__GPPortSettingsUsbScsi,
&_swigt__p_char,
&_swigt__p_p__GPPort,
&_swigt__p_p__GPPortInfo,
};
static swig_cast_info _swigc__p_GPPortType[] = { {&_swigt__p_GPPortType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwigPyObject[] = { {&_swigt__p_SwigPyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPLevel[] = { {&_swigt__p__GPLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPin[] = { {&_swigt__p__GPPin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPort[] = { {&_swigt__p__GPPort, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortInfo[] = { {&_swigt__p__GPPortInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortInfoList[] = { {&_swigt__p__GPPortInfoList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortPrivateCore[] = { {&_swigt__p__GPPortPrivateCore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortPrivateLibrary[] = { {&_swigt__p__GPPortPrivateLibrary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortSerialParity[] = { {&_swigt__p__GPPortSerialParity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortSettings[] = { {&_swigt__p__GPPortSettings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortSettingsSerial[] = { {&_swigt__p__GPPortSettingsSerial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortSettingsUSB[] = { {&_swigt__p__GPPortSettingsUSB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortSettingsUsbDiskDirect[] = { {&_swigt__p__GPPortSettingsUsbDiskDirect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GPPortSettingsUsbScsi[] = { {&_swigt__p__GPPortSettingsUsbScsi, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__GPPort[] = { {&_swigt__p_p__GPPort, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__GPPortInfo[] = { {&_swigt__p_p__GPPortInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_GPPortType,
_swigc__p_SwigPyObject,
_swigc__p__GPLevel,
_swigc__p__GPPin,
_swigc__p__GPPort,
_swigc__p__GPPortInfo,
_swigc__p__GPPortInfoList,
_swigc__p__GPPortPrivateCore,
_swigc__p__GPPortPrivateLibrary,
_swigc__p__GPPortSerialParity,
_swigc__p__GPPortSettings,
_swigc__p__GPPortSettingsSerial,
_swigc__p__GPPortSettingsUSB,
_swigc__p__GPPortSettingsUsbDiskDirect,
_swigc__p__GPPortSettingsUsbScsi,
_swigc__p_char,
_swigc__p_p__GPPort,
_swigc__p_p__GPPortInfo,
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};
#ifdef __cplusplus
}
#endif
static PyTypeObject *builtin_bases[2];
/* -----------------------------------------------------------------------------
* Type initialization:
* This problem is tough by the requirement that no dynamic
* memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
* to swig_type_info structures, we need some lookup code at initialization.
* The idea is that swig generates all the structures that are needed.
* The runtime then collects these partially filled structures.
* The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
* The generated swig_type_info structures are assigned statically to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
* cast linked list. The cast data is initially stored in something like a
* two-dimensional array. Each row corresponds to a type (there are the same
* number of rows as there are in the swig_type_initial array). Each entry in
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
* we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
* First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
* 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
* swig_cast_info to the linked list (because the cast->type) pointer will
* be correct.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif
#if 0
#define SWIGRUNTIME_DEBUG
#endif
#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif
SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
size_t i;
swig_module_info *module_head, *iter;
int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* Initialize the swig_module */
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
init = 1;
} else {
init = 0;
}
/* Try and load any already created modules */
module_head = SWIG_GetModule(clientdata);
if (!module_head) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
iter=module_head;
do {
if (iter==&swig_module) {
/* Our module is already in the list, so there's nothing more to do. */
return;
}
iter=iter->next;
} while (iter!= module_head);
/* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpreters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
if (init == 0) return;
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
if (swig_module.next != &swig_module) {
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
}
if (type) {
/* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
if (swig_module.type_initial[i]->clientdata) {
type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
}
} else {
type = swig_module.type_initial[i];
}
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
if (swig_module.next != &swig_module) {
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
}
if (ret) {
if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
cast->type = ret;
ret = 0;
} else {
/* Check for casting already in the list */
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
if (!ocast) ret = 0;
}
}
if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
if (type->cast) {
type->cast->prev = cast;
cast->next = type->cast;
}
type->cast = cast;
}
cast++;
}
/* Set entry in modules->types array equal to the type */
swig_module.types[i] = type;
}
swig_module.types[i] = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("**** SWIG_InitializeModule: Cast List ******\n");
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
++j;
}
printf("---- Total casts: %d\n",j);
}
printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}
/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types. It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
size_t i;
swig_cast_info *equiv;
static int init_run = 0;
if (init_run) return;
init_run = 1;
for (i = 0; i < swig_module.size; i++) {
if (swig_module.types[i]->clientdata) {
equiv = swig_module.types[i]->cast;
while (equiv) {
if (!equiv->converter) {
if (equiv->type && !equiv->type->clientdata)
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
}
equiv = equiv->next;
}
}
}
}
#ifdef __cplusplus
#if 0
{
/* c-mode */
#endif
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------------
* constants/methods manipulation
* ----------------------------------------------------------------------------- */
/* Install Constants */
SWIGINTERN void
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
PyObject *obj = 0;
size_t i;
for (i = 0; constants[i].type; ++i) {
switch(constants[i].type) {
case SWIG_PY_POINTER:
obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_PY_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
break;
default:
obj = 0;
break;
}
if (obj) {
PyDict_SetItemString(d, constants[i].name, obj);
Py_DECREF(obj);
}
}
}
/* -----------------------------------------------------------------------------
* Patch %callback methods' docstrings to hold the callback ptrs
* -----------------------------------------------------------------------------*/
SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
size_t i;
for (i = 0; methods[i].ml_name; ++i) {
const char *c = methods[i].ml_doc;
if (!c) continue;
c = strstr(c, "swig_ptr: ");
if (c) {
int j;
const swig_const_info *ci = 0;
const char *name = c + 10;
for (j = 0; const_table[j].type; ++j) {
if (strncmp(const_table[j].name, name,
strlen(const_table[j].name)) == 0) {
ci = &(const_table[j]);
break;
}
}
if (ci) {
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
if (ptr) {
size_t shift = (ci->ptype) - types;
swig_type_info *ty = types_initial[shift];
size_t ldoc = (c - methods[i].ml_doc);
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
char *ndoc = (char*)malloc(ldoc + lptr + 10);
if (ndoc) {
char *buff = ndoc;
memcpy(buff, methods[i].ml_doc, ldoc);
buff += ldoc;
memcpy(buff, "swig_ptr: ", 10);
buff += 10;
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
methods[i].ml_doc = ndoc;
}
}
}
}
}
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------*
* Partial Init method
* -----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
PyObject *m, *d, *md, *globals;
#if PY_VERSION_HEX >= 0x03000000
static struct PyModuleDef SWIG_module = {
PyModuleDef_HEAD_INIT,
SWIG_name,
NULL,
-1,
SwigMethods,
NULL,
NULL,
NULL,
NULL
};
#endif
#if defined(SWIGPYTHON_BUILTIN)
static SwigPyClientData SwigPyObject_clientdata = {
0, 0, 0, 0, 0, 0, 0
};
static PyGetSetDef this_getset_def = {
(char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
};
static SwigPyGetSet thisown_getset_closure = {
SwigPyObject_own,
SwigPyObject_own
};
static PyGetSetDef thisown_getset_def = {
(char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
};
PyTypeObject *builtin_pytype;
int builtin_base_count;
swig_type_info *builtin_basetype;
PyObject *tuple;
PyGetSetDescrObject *static_getset;
PyTypeObject *metatype;
PyTypeObject *swigpyobject;
SwigPyClientData *cd;
PyObject *public_interface, *public_symbol;
PyObject *this_descr;
PyObject *thisown_descr;
PyObject *self = 0;
int i;
(void)builtin_pytype;
(void)builtin_base_count;
(void)builtin_basetype;
(void)tuple;
(void)static_getset;
(void)self;
/* Metaclass is used to implement static member variables */
metatype = SwigPyObjectType();
assert(metatype);
#endif
(void)globals;
/* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
SWIG_This();
SWIG_Python_TypeCache();
SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
SwigPyObject_type();
#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
#if PY_VERSION_HEX >= 0x03000000
m = PyModule_Create(&SWIG_module);
#else
m = Py_InitModule(SWIG_name, SwigMethods);
#endif
md = d = PyModule_GetDict(m);
(void)md;
SWIG_InitializeModule(0);
#ifdef SWIGPYTHON_BUILTIN
swigpyobject = SwigPyObject_TypeOnce();
SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
if (!cd) {
SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
SwigPyObject_clientdata.pytype = swigpyobject;
} else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
return NULL;
# else
return;
# endif
}
/* All objects have a 'this' attribute */
this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
(void)this_descr;
/* All objects have a 'thisown' attribute */
thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
(void)thisown_descr;
public_interface = PyList_New(0);
public_symbol = 0;
(void)public_symbol;
PyDict_SetItemString(md, "__all__", public_interface);
Py_DECREF(public_interface);
for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
for (i = 0; swig_const_table[i].name != 0; ++i)
SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
SWIG_InstallConstants(d,swig_const_table);
{
PyObject *module = PyImport_ImportModule("gphoto2");
if (module != NULL) {
PyExc_GPhoto2Error = PyObject_GetAttrString(module, "GPhoto2Error");
Py_DECREF(module);
}
if (PyExc_GPhoto2Error == NULL)
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TRUE",SWIG_From_int((int)((0==0))));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FALSE",SWIG_From_int((int)((1==0))));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_SERIAL_PARITY_OFF",SWIG_From_int((int)(GP_PORT_SERIAL_PARITY_OFF)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_SERIAL_PARITY_EVEN",SWIG_From_int((int)(GP_PORT_SERIAL_PARITY_EVEN)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_SERIAL_PARITY_ODD",SWIG_From_int((int)(GP_PORT_SERIAL_PARITY_ODD)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_MAX_BUF_LEN",SWIG_From_int((int)(4096)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_USB_ENDPOINT_IN",SWIG_From_int((int)(GP_PORT_USB_ENDPOINT_IN)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_USB_ENDPOINT_OUT",SWIG_From_int((int)(GP_PORT_USB_ENDPOINT_OUT)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PORT_USB_ENDPOINT_INT",SWIG_From_int((int)(GP_PORT_USB_ENDPOINT_INT)));
/* type '::_GPPort' */
builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___GPPort_type;
builtin_pytype->tp_dict = d = PyDict_New();
SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
builtin_pytype->tp_new = PyType_GenericNew;
builtin_base_count = 0;
builtin_bases[builtin_base_count] = NULL;
SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
PyDict_SetItemString(d, "this", this_descr);
PyDict_SetItemString(d, "thisown", thisown_descr);
if (PyType_Ready(builtin_pytype) < 0) {
PyErr_SetString(PyExc_TypeError, "Could not create type 'GPPort'.");
#if PY_VERSION_HEX >= 0x03000000
return NULL;
#else
return;
#endif
}
Py_INCREF(builtin_pytype);
PyModule_AddObject(m, "GPPort", (PyObject *)builtin_pytype);
SwigPyBuiltin_AddPublicSymbol(public_interface, "GPPort");
d = md;
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PIN_RTS",SWIG_From_int((int)(GP_PIN_RTS)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PIN_DTR",SWIG_From_int((int)(GP_PIN_DTR)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PIN_CTS",SWIG_From_int((int)(GP_PIN_CTS)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PIN_DSR",SWIG_From_int((int)(GP_PIN_DSR)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PIN_CD",SWIG_From_int((int)(GP_PIN_CD)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_PIN_RING",SWIG_From_int((int)(GP_PIN_RING)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_LEVEL_LOW",SWIG_From_int((int)(GP_LEVEL_LOW)));
SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GP_LEVEL_HIGH",SWIG_From_int((int)(GP_LEVEL_HIGH)));
#if PY_VERSION_HEX >= 0x03000000
return m;
#else
return;
#endif
}
python-gphoto2-2.5.1/src/swig-gp2_5_31/result.py 0000664 0000000 0000000 00000003217 14703210004 0021257 0 ustar 00root root 0000000 0000000 # This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
# Pull in all the attributes from the low-level C/C++ module
if __package__ or "." in __name__:
from ._result import *
else:
from _result import *
import logging
from gphoto2 import GPhoto2Error
# user adjustable check_result lookup table
error_severity = {
GP_ERROR_CANCEL : logging.INFO,
GP_ERROR_DIRECTORY_EXISTS : logging.WARNING,
}
error_exception = logging.ERROR
_return_logger = logging.getLogger('gphoto2.returnvalue')
def check_result(result):
"""Pops gphoto2 'error' value from 'result' list and checks it.
If there is no error the remaining result is returned. For other
errors a severity level is taken from the error_severity dict, or
set to logging.CRITICAL if the error is not in error_severity.
If the severity >= error_exception an exception is raised.
Otherwise a message is logged at the appropriate severity level.
"""
if not isinstance(result, (tuple, list)):
error = result
elif len(result) == 2:
error, result = result
else:
error = result[0]
result = result[1:]
if error >= GP_OK:
return result
severity = logging.CRITICAL
if error in error_severity:
severity = error_severity[error]
if severity >= error_exception:
raise GPhoto2Error(error)
_return_logger.log(severity, '[%d] %s', error, gp_result_as_string(error))
return result
python-gphoto2-2.5.1/src/swig-gp2_5_31/result_wrap.c 0000664 0000000 0000000 00000427217 14703210004 0022114 0 ustar 00root root 0000000 0000000 /* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (https://www.swig.org).
* Version 4.1.1
*
* Do not make changes to this file unless you know what you are doing - modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
#define SWIG_VERSION 0x040101
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_BUILTIN
#define SWIGPYTHON_FASTPROXY
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if defined(__GNUC__)
# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
/* Intel's compiler complains if a variable which was never initialised is
* cast to void, which is a common idiom which we use to indicate that we
* are aware a variable isn't used. So we just silence that warning.
* See: https://github.com/swig/swig/issues/192 for more discussion.
*/
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include
#endif
#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif
#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif
#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
* See https://github.com/swig/swig/issues/2090 */
# include