From ad0a0f52b3ea2b354d49ae27dbeba38f60edf3d4 Mon Sep 17 00:00:00 2001 From: taynpg Date: Sun, 14 Apr 2024 20:02:01 +0800 Subject: [PATCH] =?UTF-8?q?=E5=88=9D=E5=A7=8B=E6=8F=90=E4=BA=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 17 + .travis.yml | 74 + CMakeLists.txt | 195 + LICENSE | 29 + README.md | 25 + appveyor.yml | 25 + c/CMakeLists.txt | 27 + c/sxtwl_c.cpp | 241 + c/sxtwl_c.h | 109 + cmake/FindPHP.cmake | 199 + cmake/android.cmake | 1715 ++++ cmake/ios.cmake | 436 + cmake/platform.cmake | 57 + example/CMakeLists.txt | 18 + example/golang/go.mod | 3 + example/golang/main.go | 217 + example/golang/sxtwl/init.go | 8 + example/golang/sxtwl/sxtwl.go | 790 ++ example/main.cpp | 203 + example/main.py | 189 + export.sh | 26 + export/C#/Day.cs | 189 + export/C#/GZ.cs | 85 + export/C#/JDList.cs | 355 + export/C#/JQList.cs | 336 + export/C#/JieQiInfo.cs | 82 + export/C#/Time.cs | 179 + export/C#/sxtwl.cs | 79 + export/C#/sxtwlPINVOKE.cs | 575 ++ export/C#/sxtwl_wrap.cxx | 2313 ++++++ export/golang/sxtwl.go | 1179 +++ export/golang/sxtwl_wrap.cxx | 1685 ++++ export/java/Day.java | 156 + export/java/GZ.java | 75 + export/java/JDList.java | 156 + export/java/JQList.java | 156 + export/java/JieQiInfo.java | 71 + export/java/Time.java | 155 + export/java/sxtwl.java | 63 + export/java/sxtwlConstants.java | 13 + export/java/sxtwlJNI.java | 121 + export/java/sxtwl_wrap.cxx | 2156 +++++ export/lua/sxtwl_wrap.cxx | 7122 ++++++++++++++++ export/php7/php_sxtwl.h | 126 + export/php7/sxtwl.php | 436 + export/php7/sxtwl_wrap.cxx | 5672 +++++++++++++ export/python/README.md | 1 + ndk_build.py | 290 + python/.gitignore | 106 + python/MANIFEST.in | 1 + python/README.md | 244 + python/setup.py | 99 + python/sxtwl.py | 510 ++ python/sxtwl_wrap.cxx | 13109 ++++++++++++++++++++++++++++++ src/CMakeLists.txt | 34 + src/JD.cpp | 89 + src/JD.h | 84 + src/SSQ.cpp | 374 + src/SSQ.h | 38 + src/XL.cpp | 75 + src/XL.h | 22 + src/const.h | 46 + src/day.cpp | 330 + src/day.h | 216 + src/eph.cpp | 1170 +++ src/eph.h | 172 + src/sxtwl.cpp | 746 ++ src/sxtwl.h | 33 + swig/sxtwl.i | 121 + 69 files changed, 46048 insertions(+) create mode 100644 .gitignore create mode 100644 .travis.yml create mode 100644 CMakeLists.txt create mode 100644 LICENSE create mode 100644 README.md create mode 100644 appveyor.yml create mode 100644 c/CMakeLists.txt create mode 100644 c/sxtwl_c.cpp create mode 100644 c/sxtwl_c.h create mode 100644 cmake/FindPHP.cmake create mode 100644 cmake/android.cmake create mode 100644 cmake/ios.cmake create mode 100644 cmake/platform.cmake create mode 100644 example/CMakeLists.txt create mode 100644 example/golang/go.mod create mode 100644 example/golang/main.go create mode 100644 example/golang/sxtwl/init.go create mode 100644 example/golang/sxtwl/sxtwl.go create mode 100644 example/main.cpp create mode 100644 example/main.py create mode 100644 export.sh create mode 100644 export/C#/Day.cs create mode 100644 export/C#/GZ.cs create mode 100644 export/C#/JDList.cs create mode 100644 export/C#/JQList.cs create mode 100644 export/C#/JieQiInfo.cs create mode 100644 export/C#/Time.cs create mode 100644 export/C#/sxtwl.cs create mode 100644 export/C#/sxtwlPINVOKE.cs create mode 100644 export/C#/sxtwl_wrap.cxx create mode 100644 export/golang/sxtwl.go create mode 100644 export/golang/sxtwl_wrap.cxx create mode 100644 export/java/Day.java create mode 100644 export/java/GZ.java create mode 100644 export/java/JDList.java create mode 100644 export/java/JQList.java create mode 100644 export/java/JieQiInfo.java create mode 100644 export/java/Time.java create mode 100644 export/java/sxtwl.java create mode 100644 export/java/sxtwlConstants.java create mode 100644 export/java/sxtwlJNI.java create mode 100644 export/java/sxtwl_wrap.cxx create mode 100644 export/lua/sxtwl_wrap.cxx create mode 100644 export/php7/php_sxtwl.h create mode 100644 export/php7/sxtwl.php create mode 100644 export/php7/sxtwl_wrap.cxx create mode 100644 export/python/README.md create mode 100644 ndk_build.py create mode 100644 python/.gitignore create mode 100644 python/MANIFEST.in create mode 100644 python/README.md create mode 100644 python/setup.py create mode 100644 python/sxtwl.py create mode 100644 python/sxtwl_wrap.cxx create mode 100644 src/CMakeLists.txt create mode 100644 src/JD.cpp create mode 100644 src/JD.h create mode 100644 src/SSQ.cpp create mode 100644 src/SSQ.h create mode 100644 src/XL.cpp create mode 100644 src/XL.h create mode 100644 src/const.h create mode 100644 src/day.cpp create mode 100644 src/day.h create mode 100644 src/eph.cpp create mode 100644 src/eph.h create mode 100644 src/sxtwl.cpp create mode 100644 src/sxtwl.h create mode 100644 swig/sxtwl.i diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..bf0a256 --- /dev/null +++ b/.gitignore @@ -0,0 +1,17 @@ +# Compiled Object files +*.slo +*.lo +*.o + +# Compiled Dynamic libraries +*.so +*.dylib + +# Compiled Static libraries +*.lai +*.la +*.a + +*.vs +*Debug +*build diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..01c0f0d --- /dev/null +++ b/.travis.yml @@ -0,0 +1,74 @@ +matrix: + include: + #IOS + - os: osx + language: cpp + env: BUILD_TARGET=Ios + sudo: true + script: + - mkdir build + - cd build + - cmake .. -DCMAKE_TOOLCHAIN_FILE=../cmake/ios.cmake + -DIOS_PLATFORM=OS + -DCMAKE_BUILD_TYPE=Release + - cmake --build . + + #Android + - os: linux + language: cpp + env: BUILD_TARGET=Android + sudo: true + script: + - wget https://dl.google.com/android/repository/android-ndk-r14b-linux-x86_64.zip + - unzip -q ./android-ndk-r14b-linux-x86_64.zip + - export ANDROID_NDK_ROOT=`pwd`/android-ndk-r14b + - export ANDROID_NDK=`pwd`/android-ndk-r14b + - wget https://cmake.org/files/v3.12/cmake-3.12.0-Linux-x86_64.tar.gz + - tar -xf ./cmake-3.12.0-Linux-x86_64.tar.gz + - export PATH=`pwd`/cmake-3.12.0-Linux-x86_64/bin:$PATH + - echo $ANDROID_NDK + - which cmake + - mkdir build + - cd build + - cmake .. -DCMAKE_TOOLCHAIN_FILE=../cmake/android.cmake + -DCMAKE_BUILD_TYPE=Release + -DANDROID_ABI=armeabi-v7a + -DANDROID_STL=gnustl_static + -DANDROID_TOOLCHAIN_NAME=arm-linux-androideabi-4.9 + -DCMAKE_MAKE_PROGRAM=$ANDROID_NDK/prebuilt/linux-x86_64/bin/make + -DANDROID_NATIVE_API_LEVEL=21 + -DSXTWL_BUILD_EXAMPLES=1 + -G "Unix Makefiles" + - cmake --build . + + # linux + - os: linux + language: cpp + env: BUILD_TARGET=Linux + compiler: + - clang + - gcc + script: + - mkdir build + - cd build + - cmake .. -DSXTWL_BUILD_EXAMPLES=1 + - cmake --build . + - ./example/example + + #mac + - os: osx + language: cpp + env: BUILD_TARGET=Mac + compiler: + - clang + - gcc + script: + - mkdir build + - cd build + - cmake .. -DSXTWL_BUILD_EXAMPLES=1 + - cmake --build . + - ./example/example + + + + diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..bffbc2d --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,195 @@ +cmake_minimum_required(VERSION 3.6) +project(sxtwl_cpp) + +IF(MSVC) +ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS) +add_compile_options(/wd26495) # 初始化警告 +add_compile_options(/wd6011) #可能为null指针警告 +add_compile_options(/wd4244) #隐式转换可能丢失数据警告 +add_compile_options(/wd4101) #未引用的局部变量警告 +add_compile_options(/wd4267) #隐式转换可能丢失数据警告 size_t -> int +add_compile_options(/wd4018) #有符号与无符号的比较 +ENDIF() + +#编译库的例子 +add_subdirectory(src) + +#编译例子 +if(SXTWL_BUILD_EXAMPLES) + add_subdirectory(example) +endif(SXTWL_BUILD_EXAMPLES) + +#python的接口导出 +# if(SXTWL_WRAPPER_PYTHON) +# find_package(SWIG REQUIRED) +# include(${SWIG_USE_FILE}) + +# find_package(PythonLibs) +# include_directories(${PYTHON_INCLUDE_DIR} "./src") +# set(CMAKE_SWIG_FLAGS) +# set_property(SOURCE swig/sxtwl.i PROPERTY CPLUSPLUS ON) + +# SWIG_ADD_MODULE(sxtwl_python python swig/sxtwl.i) +# #SWIG_ADD_LIBRARY(sxtwl_python MODULE LANGUAGE python SOURCES swig/sxtwl.i) +# SWIG_LINK_LIBRARIES(sxtwl_python ${PYTHON_LIBRARY} sxtwl) +# endif(SXTWL_WRAPPER_PYTHON) + +#java的接口导出(适作于android, 在externalNativeBuild 下的cmake加上 arguments "-DSXTWL_WRAPPER_JAVA=1") +if(SXTWL_WRAPPER_JAVA) + # find_package(SWIG REQUIRED) + + + IF(ANDROID) + message(STATUS "Android Jni") + ELSE(ANDROID) + find_package(JNI) + if(${JNI_FOUND}) + message(STATUS "Jni Found") + else(${JNI_FOUND}) + message(FATAL_ERROR "not found Jni") + endif() + endif(ANDROID) + + include_directories(${JNI_INCLUDE_DIRS} "./src") + # #增加包名 + # IF(ANDROID) + # #参考:https://github.com/sureshjoshi/android-ndk-swig-example/blob/master/AS3/app/CMakeLists.txt + # set(JAVA_GEN_PACKAGE "com.seantone.sxtwl") + # string(REPLACE "." "/" JAVA_GEN_SUBDIR ${JAVA_GEN_PACKAGE}) + # set(JAVA_GEN_DIR ${Project_SOURCE_DIR}/src/main/java/${JAVA_GEN_SUBDIR}) + + # # -s选项为strip，不strip生成的库文件会很大 + # set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -s") + + # set(CMAKE_SWIG_FLAGS -c++ -package ${JAVA_GEN_PACKAGE}) + # if(CONSOLE) + # else(CONSOLE) + # set(CMAKE_SWIG_OUTDIR ${JAVA_GEN_DIR}) + # set(SWIG_OUTFILE_DIR ${Project_SOURCE_DIR}/src/main/sxtwl_jni_cpp/sxtwlJAVA_wrap.cxx) + # endif(CONSOLE) + # ELSE(ANDROID) + # set(CMAKE_SWIG_FLAGS -c++ -package com.huoyaojing.sxtwl) + # ENDIF(ANDROID) + + # set_property(SOURCE swig/sxtwl.i PROPERTY CPLUSPLUS ON) + # SWIG_ADD_MODULE(sxtwl_java java com.seantone.sxtwl) + # #SWIG_ADD_LIBRARY(sxtwl_java MODULE LANGUAGE java SOURCES swig/sxtwl.i) + # SWIG_LINK_LIBRARIES(sxtwl_java ${JNI_LIBRARIES} sxtwl) + + add_library(sxtwl_java SHARED "./export/java/sxtwl_wrap.cxx") + target_link_libraries(sxtwl_java sxtwl ${JNI_LIBRARIES}) + + +endif(SXTWL_WRAPPER_JAVA) + +#lua接口的导出 +if(SXTWL_WRAPPER_LUA) + # find_package(SWIG REQUIRED) + # include(${SWIG_USE_FILE}) + + find_package(Lua) + if(${LUA_FOUND}) + message(STATUS "lua Found") + else(${LUA_FOUND}) + message(FATAL_ERROR "not found lua") + endif() + + include_directories(${LUA_INCLUDE_DIR} "./src") + + + add_library(sxtwl_lua SHARED "./export/lua/sxtwl_wrap.cxx") + target_link_libraries(sxtwl_lua sxtwl ${LUA_LIBRARIES}) + + # set_property(SOURCE swig/sxtwl.i PROPERTY CPLUSPLUS ON) + # set(CMAKE_SWIG_FLAGS) + + # SWIG_ADD_MODULE(sxtwl_lua lua swig/sxtwl.i) + # #SWIG_ADD_LIBRARY(sxtwl_lua MODULE LANGUAGE lua SOURCES swig/sxtwl.i) + # SWIG_LINK_LIBRARIES(sxtwl_lua ${LUA_LIBRARIES} sxtwl) +endif(SXTWL_WRAPPER_LUA) + + +#C#接口导出 +if(SXTWL_WRAPPER_CSHARP) + # find_package(SWIG REQUIRED) + # include(${SWIG_USE_FILE}) + + include_directories( "./src") + + add_library(sxtwl_csharp SHARED "./export/C#/sxtwl_wrap.cxx") + target_link_libraries(sxtwl_csharp sxtwl) + + + # set_property(SOURCE swig/sxtwl.i PROPERTY CPLUSPLUS ON) + # set(CMAKE_SWIG_FLAGS) + + # SWIG_ADD_MODULE(sxtwl_csharp csharp swig/sxtwl.i) + # #SWIG_ADD_LIBRARY(sxtwl_csharp MODULE LANGUAGE csharp SOURCES swig/sxtwl.i) + # SWIG_LINK_LIBRARIES(sxtwl_csharp sxtwl) +endif(SXTWL_WRAPPER_CSHARP) + + +#php接口导出(仅支持php5和php7) +if(SXTWL_WRAPPER_PHP5) + + include(${CMAKE_SOURCE_DIR}/cmake/FindPHP.cmake) + + include_directories(${PHP_INCLUDE_DIRS} ${PHP_EXTENSIONS_INCLUDE_DIR} "./src") + + + add_library(sxtwl_php5 SHARED "./export/php5/sxtwl_wrap.cxx") + target_link_libraries(sxtwl_php5 sxtwl) + + + + # find_package(SWIG REQUIRED) + # include(${SWIG_USE_FILE}) + # set_property(SOURCE swig/sxtwl.i PROPERTY CPLUSPLUS ON) + # set(CMAKE_SWIG_FLAGS) + + # if(${PHP_VERSION_MAJOR} MATCHES 7) + # SWIG_ADD_MODULE(sxtwl_php php7 swig/sxtwl.i) + # else(${PHP_VERSION_MAJOR} MATCHES 7) + # SWIG_ADD_MODULE(sxtwl_php php swig/sxtwl.i) + # endif(${PHP_VERSION_MAJOR} MATCHES 7) + # SWIG_LINK_LIBRARIES(sxtwl_php sxtwl ) + +endif(SXTWL_WRAPPER_PHP5) + + +if(SXTWL_WRAPPER_PHP7) + include(${CMAKE_SOURCE_DIR}/cmake/FindPHP.cmake) + + include_directories(${PHP_INCLUDE_DIRS} ${PHP_EXTENSIONS_INCLUDE_DIR} "./src") + + + add_library(sxtwl_php7 SHARED "./export/php5/sxtwl_wrap.cxx") + target_link_libraries(sxtwl_php7 sxtwl) + + + + # find_package(SWIG REQUIRED) + # include(${SWIG_USE_FILE}) + # set_property(SOURCE swig/sxtwl.i PROPERTY CPLUSPLUS ON) + # set(CMAKE_SWIG_FLAGS) + + # if(${PHP_VERSION_MAJOR} MATCHES 7) + # SWIG_ADD_MODULE(sxtwl_php php7 swig/sxtwl.i) + # else(${PHP_VERSION_MAJOR} MATCHES 7) + # SWIG_ADD_MODULE(sxtwl_php php swig/sxtwl.i) + # endif(${PHP_VERSION_MAJOR} MATCHES 7) + # SWIG_LINK_LIBRARIES(sxtwl_php sxtwl ) + +endif(SXTWL_WRAPPER_PHP7) + +# for golang +if(SXTWL_WRAPPER_GO) + include_directories("./src") + add_library(sxtwl_go STATIC "./export/golang/sxtwl_wrap.cxx") + target_link_libraries(sxtwl_go sxtwl) +endif(SXTWL_WRAPPER_GO) + +# for c +if(SXTWL_WRAPPER_C) + add_subdirectory(c) +endif(SXTWL_WRAPPER_C) diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..7b826d7 --- /dev/null +++ b/LICENSE @@ -0,0 +1,29 @@ +BSD 3-Clause License + +Copyright (c) 2017-2022, 元谷 +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..b5c99ef --- /dev/null +++ b/README.md @@ -0,0 +1,25 @@ + ## 介绍 + +sxtwl_cpp是作者`yuangu`参考[寿星天文历](http://www.nongli.net/sxwnl/)并使用C++实现日历库。 + +以下链接是原作者`yuangu`项目链接，我这里仅做备份。 + +[GitHub](https://github.com/yuangu/sxtwl_cpp) / [Gitee（码云）](https://gitee.com/yuangu/sxtwl)。 + +## 特性 + +* 易于使用：使用cmake管理工程 +* 多平台支持 +* 查询范围广 +* 免除附带表数据 + +## 用途 + +* 做为航海历使用。（注：虽然叫做农历，其实和农业生产一点关系都没有。但和航海有关） +* 命理研究 +* 考古工作 +* 与农历相关的数据提供 +* 天文研究 + + + diff --git a/appveyor.yml b/appveyor.yml new file mode 100644 index 0000000..d44a495 --- /dev/null +++ b/appveyor.yml @@ -0,0 +1,25 @@ +version: 1.0.{build} +skip_tags: true +skip_branch_with_pr: true +image: + - Visual Studio 2015 + - Visual Studio 2017 + - Ubuntu + - macOS + +platform: Any CPU + +configuration: + - Debug + - Release + +before_build: + - mkdir build + - cd build + - cmake .. -DSXTWL_BUILD_EXAMPLES=1 -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE=C:/projects/sxtwl-cpp/build/out -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG=C:/projects/sxtwl-cpp/build/out + +build_script: + - cmake --build . + +# after_build: +# - C:/projects/sxtwl-cpp/build/out/example.exe \ No newline at end of file diff --git a/c/CMakeLists.txt b/c/CMakeLists.txt new file mode 100644 index 0000000..1a1d026 --- /dev/null +++ b/c/CMakeLists.txt @@ -0,0 +1,27 @@ +cmake_minimum_required(VERSION 3.6) +project(sxtwl_c) + +include_directories("../src") + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_C_STANDARD 11) + +IF(${CMAKE_SYSTEM_NAME} STREQUAL "Windows") +ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS) +add_compile_options("$<$:/utf-8>") +add_compile_options("$<$:/utf-8>") +ENDIF() + +file(GLOB SRC_FILES *.cpp *.c ) + +IF (EMSCRIPTEN) +add_executable(sxtwl_c ${SRC_FILES}) +target_link_libraries(sxtwl_c +sxtwl) +ELSE(EMSCRIPTEN) +add_library(sxtwl_c STATIC ${SRC_FILES}) +target_link_libraries(sxtwl_c +sxtwl) +ENDIF(EMSCRIPTEN) + + diff --git a/c/sxtwl_c.cpp b/c/sxtwl_c.cpp new file mode 100644 index 0000000..332c06a --- /dev/null +++ b/c/sxtwl_c.cpp @@ -0,0 +1,241 @@ +#include "sxtwl_export.h" + +#include "sxtwl.h" + +EXTERN_C_BEGIN + +sxtwl_Day *sxtwl_after(sxtwl_Day *day, sxtwl_Day *ret, int day_num) +{ + ret->ptr = (Day *)((Day *)day->ptr)->after(day_num); + return ret; +} + +sxtwl_Day *sxtwl_before(sxtwl_Day *day, sxtwl_Day *ret, int day_num) +{ + ret->ptr = (Day *)((Day *)day->ptr)->before(day_num); + return ret; +} + +int sxtwl_getLunarMonth(sxtwl_Day *day) +{ + return ((Day *)day->ptr)->getLunarMonth(); +} + +int sxtwl_getLunarDay(sxtwl_Day *day) +{ + return ((Day *)day->ptr)->getLunarDay(); +} + +int sxtwl_getLunarYear(sxtwl_Day *day, bool chineseNewYearBoundary) +{ + return ((Day *)day->ptr)->getLunarYear(chineseNewYearBoundary); +} + +void *sxtwl_getYearGZ(void *GZPtr, sxtwl_Day *day, bool chineseNewYearBoundary) +{ + auto ret = (GZ *)GZPtr; + *ret = ((Day *)day->ptr)->getYearGZ(chineseNewYearBoundary); + return ret; +} + +void *sxtwl_getMonthGZ(void *GZPtr, sxtwl_Day *day) +{ + auto ret = (GZ *)GZPtr; + *ret = ((Day *)day->ptr)->getMonthGZ(); + return ret; +} + +void *sxtwl_getDayGZ(void *GZPtr, sxtwl_Day *day) +{ + auto ret = (GZ *)GZPtr; + *ret = ((Day *)day->ptr)->getDayGZ(); + + return ret; +} + +void *sxtwl_getHourGZ(void *GZPtr, sxtwl_Day *day, uint8_t hour, bool isZaoWanZiShi) +{ + auto ret = (GZ *)GZPtr; + *ret = ((Day *)day->ptr)->getHourGZ(hour, isZaoWanZiShi); + + return ret; +} + +bool sxtwl_isLunarLeap(sxtwl_Day *day) +{ + return ((Day *)day->ptr)->isLunarLeap(); +} + +int sxtwl_getSolarYear(sxtwl_Day *day) +{ + return ((Day *)day->ptr)->getSolarYear(); +} + +uint8_t sxtwl_getSolarMonth(sxtwl_Day *day) +{ + return ((Day *)day->ptr)->getSolarMonth(); +} + +int sxtwl_getSolarDay(sxtwl_Day *day) +{ + return ((Day *)day->ptr)->getSolarDay(); +} + +uint8_t sxtwl_getWeek(sxtwl_Day *day) +{ + return ((Day *)day->ptr)->getWeek(); +} + +// 处于该月的第几周 +uint8_t sxtwl_getWeekIndex(sxtwl_Day *day) +{ + return ((Day *)day->ptr)->getWeekIndex(); +} + +// 是否有节气 +bool sxtwl_hasJieQi(sxtwl_Day *day) +{ + return ((Day *)day->ptr)->hasJieQi(); +} + +// 获取节气 +uint8_t sxtwl_getJieQi(sxtwl_Day *day) +{ + return ((Day *)day->ptr)->getJieQi(); +} + +double sxtwl_getJieQiJD(sxtwl_Day *day) +{ + return ((Day *)day->ptr)->getJieQiJD(); +} + +// 获取星座 +uint8_t sxtwl_getConstellation(sxtwl_Day *day) +{ + return ((Day *)day->ptr)->getConstellation(); +} + +sxtwl_Day *sxtwl_newDay() +{ + sxtwl_Day *day = new sxtwl_Day(); + day->ptr = NULL; + return day; +} + +void sxtwl_freeDay(sxtwl_Day *day) +{ + if (day->ptr != NULL) + { + delete ((Day *)day->ptr); + } + delete day; +} + +void *sxtwl_getShiGz(void *GZPtr, uint8_t dayTg, uint8_t hour, bool isZaoWanZiShi) +{ + auto ret = (GZ *)GZPtr; + *ret = sxtwl::getShiGz(dayTg, hour, isZaoWanZiShi); + return ret; +} + +uint8_t sxtwl_getRunMonth(int By) +{ + return sxtwl::getRunMonth(By); +} + +uint8_t sxtwl_getLunarMonthNum(int By, uint8_t month, bool isRun) +{ + return sxtwl::getLunarMonthNum(By, month, isRun); +} + +sxtwl_Time sxtwl_JD2DD(double jd) +{ + Time t = sxtwl::JD2DD(jd); + sxtwl_Time time; + time.year = t.Y; + time.month = t.M; + time.day = t.D; + + time.hour = t.h; + time.min = t.m; + time.sec = t.s; + return time; +} + +double sxtwl_toJD(sxtwl_Time *time) +{ + Time t(time->year, time->month, time->day, time->hour, time->min, time->sec); + return sxtwl::toJD(t); +} + +sxtwl_Day *sxtwl_fromSolar(sxtwl_Day *ret, int year, uint8_t month, int day) +{ + ret->ptr = (void *)sxtwl::fromSolar(year, month, day); + return ret; +} + +sxtwl_Day *sxtwl_fromLunar(sxtwl_Day *ret, int year, uint8_t month, int day, bool isRun) +{ + ret->ptr = (void *)sxtwl::fromLunar(year, month, day, isRun); + return ret; +} + +void *sxtwl_siZhu2Year(void *JdListPtr, void *yearGZ, void *yueGZ, void *riGZ, void *shiGZ, int fromYear, int toYear) +{ + auto ret = (std::vector *)JdListPtr; + *ret = sxtwl::siZhu2Year(*((GZ *)yearGZ), *((GZ *)yueGZ), *((GZ *)riGZ), *((GZ *)shiGZ), fromYear, toYear); + return ret; +} + +void *JdList_new() +{ + auto ret = new std::vector(); + return ret; +} +void JdList_free(void *ptr) +{ + auto ret = (std::vector *)ptr; + delete ret; +} +int JdList_getNum(void *ptr) +{ + auto ret = (std::vector *)ptr; + return ret->size(); +} + +double JdList_indexOf(void *ptr, int index) +{ + auto ret = (std::vector *)ptr; + return ret->at(index); +} + +void *GZ_new(int tg, int dz) +{ + return new GZ(tg, dz); +} +void GZ_free(void *ptr) +{ + auto ret = (GZ *)ptr; + delete ret; +} +int GZ_getTg(void *ptr) +{ + auto ret = (GZ *)ptr; + return ret->tg; +} +void GZ_setTg(void *ptr, int tg) +{ + auto ret = (GZ *)ptr; + ret->tg = tg; +} +int GZ_getDz(void *ptr) +{ + auto ret = (GZ *)ptr; + return ret->dz; +} +void GZ_setDz(void *ptr, int dz) +{ + auto ret = (GZ *)ptr; + ret->dz = dz; +} +EXTERN_C_END \ No newline at end of file diff --git a/c/sxtwl_c.h b/c/sxtwl_c.h new file mode 100644 index 0000000..4b27db0 --- /dev/null +++ b/c/sxtwl_c.h @@ -0,0 +1,109 @@ +#pragma once + +#include + +#include + +#if _WIN32 +#define FFI_PLUGIN_EXPORT __declspec(dllexport) +#else +#ifdef __EMSCRIPTEN__ +#include +#define FFI_PLUGIN_EXPORT EMSCRIPTEN_KEEPALIVE +#else +#define FFI_PLUGIN_EXPORT +#endif +#endif + +#ifdef __cplusplus +#define EXTERN_C_BEGIN \ + extern "C" \ + { +#else +#define EXTERN_C_BEGIN +#endif + +#ifdef __cplusplus +#define EXTERN_C_END } +#else +#define EXTERN_C_END +#endif + +EXTERN_C_BEGIN + +typedef struct sxtwl_Time +{ + int year, month, day; + double hour, min, sec; +} sxtwl_Time; + +typedef struct sxtwl_Day +{ + void *ptr; +} sxtwl_Day; + +// 内存管理 +FFI_PLUGIN_EXPORT sxtwl_Day *sxtwl_newDay(); +FFI_PLUGIN_EXPORT void sxtwl_freeDay(sxtwl_Day *day); + +// 注意返回的sxtwl_Day指针，需要使用sxtwl_freeDay释放 +FFI_PLUGIN_EXPORT sxtwl_Day *sxtwl_after(sxtwl_Day *day, sxtwl_Day *ret, int day_num); +FFI_PLUGIN_EXPORT sxtwl_Day *sxtwl_before(sxtwl_Day *day, sxtwl_Day *ret, int day_num); + +FFI_PLUGIN_EXPORT int sxtwl_getLunarMonth(sxtwl_Day *day); +FFI_PLUGIN_EXPORT int sxtwl_getLunarDay(sxtwl_Day *day); +FFI_PLUGIN_EXPORT int sxtwl_getLunarYear(sxtwl_Day *day, bool chineseNewYearBoundary); + +FFI_PLUGIN_EXPORT void *sxtwl_getYearGZ(void *GZPtr, sxtwl_Day *day, bool chineseNewYearBoundary); +FFI_PLUGIN_EXPORT void *sxtwl_getMonthGZ(void *GZPtr, sxtwl_Day *day); +FFI_PLUGIN_EXPORT void *sxtwl_getDayGZ(void *GZPtr, sxtwl_Day *day); +// 注意非早晚子时的时候，day要算第二天 +FFI_PLUGIN_EXPORT void *sxtwl_getHourGZ(void *GZPtr, sxtwl_Day *day, uint8_t hour, bool isZaoWanZiShi); +FFI_PLUGIN_EXPORT bool sxtwl_isLunarLeap(sxtwl_Day *day); + +FFI_PLUGIN_EXPORT int sxtwl_getSolarYear(sxtwl_Day *day); +FFI_PLUGIN_EXPORT uint8_t sxtwl_getSolarMonth(sxtwl_Day *day); +FFI_PLUGIN_EXPORT int sxtwl_getSolarDay(sxtwl_Day *day); +FFI_PLUGIN_EXPORT uint8_t sxtwl_getWeek(sxtwl_Day *day); +// 处于该月的第几周 +FFI_PLUGIN_EXPORT uint8_t sxtwl_getWeekIndex(sxtwl_Day *day); +// 是否有节气 +FFI_PLUGIN_EXPORT bool sxtwl_hasJieQi(sxtwl_Day *day); +// 获取节气 +FFI_PLUGIN_EXPORT uint8_t sxtwl_getJieQi(sxtwl_Day *day); +FFI_PLUGIN_EXPORT double sxtwl_getJieQiJD(sxtwl_Day *day); +// 获取星座 +FFI_PLUGIN_EXPORT uint8_t sxtwl_getConstellation(sxtwl_Day *day); + +FFI_PLUGIN_EXPORT sxtwl_Day *sxtwl_fromSolar(sxtwl_Day *ret, int year, uint8_t month, int day); + +FFI_PLUGIN_EXPORT sxtwl_Day *sxtwl_fromLunar(sxtwl_Day *ret, int year, uint8_t month, int day, bool isRun); + +// 通过四柱获取年月日, 返回的是儒略日列表 +FFI_PLUGIN_EXPORT void *sxtwl_siZhu2Year(void *JdListPtr, void *yearGZ, void *yueGZ, void *riGZ, void *shiGZ, int fromYear, int toYear); +////获取时辰上的那个天干 +FFI_PLUGIN_EXPORT void *sxtwl_getShiGz(void *gzPtr, uint8_t dayTg, uint8_t hour, bool isZaoWanZiShi); + +// 获取一年中的润月(不存，则返回0) +FFI_PLUGIN_EXPORT uint8_t sxtwl_getRunMonth(int By); +// 获取一月中的阴日数量 +FFI_PLUGIN_EXPORT uint8_t sxtwl_getLunarMonthNum(int By, uint8_t month, bool isRun); +// 儒略日数转公历 +FFI_PLUGIN_EXPORT sxtwl_Time sxtwl_JD2DD(double jd); +// 公历转儒略日 +FFI_PLUGIN_EXPORT double sxtwl_toJD(sxtwl_Time *time); + +// 反推的jd列表使用 +FFI_PLUGIN_EXPORT void *JdList_new(); +FFI_PLUGIN_EXPORT void JdList_free(void *ptr); +FFI_PLUGIN_EXPORT int JdList_getNum(void *ptr); +FFI_PLUGIN_EXPORT double JdList_indexOf(void *ptr, int index); + +FFI_PLUGIN_EXPORT void *GZ_new(int tg, int dz); +FFI_PLUGIN_EXPORT void GZ_free(void *ptr); +FFI_PLUGIN_EXPORT int GZ_getTg(void *ptr); +FFI_PLUGIN_EXPORT void GZ_setTg(void *ptr, int tg); +FFI_PLUGIN_EXPORT int GZ_getDz(void *ptr); +FFI_PLUGIN_EXPORT void GZ_setDz(void *ptr, int dz); + +EXTERN_C_END \ No newline at end of file diff --git a/cmake/FindPHP.cmake b/cmake/FindPHP.cmake new file mode 100644 index 0000000..e57e7c5 --- /dev/null +++ b/cmake/FindPHP.cmake @@ -0,0 +1,199 @@ +# - Find PHP +# This module finds if PHP is installed and determines where the include files +# and libraries are. +# +# Note, unlike the FindPHP4 module, this module uses the php-config script to +# determine information about the installed PHP configuration. For Linux +# distributions, this script is normally installed as part of some php-dev or +# php-devel package. See http://php.net/manual/en/install.pecl.php-config.php +# for php-config documentation. +# +# This code sets the following variables: +# PHP_CONFIG_DIR = directory containing PHP configuration files +# PHP_CONFIG_EXECUTABLE = full path to the php-config binary +# PHP_EXECUTABLE = full path to the php binary +# PHP_EXTENSIONS_DIR = directory containing PHP extensions +# PHP_EXTENSIONS_INCLUDE_DIR = directory containing PHP extension headers +# PHP_INCLUDE_DIRS = include directives for PHP development +# PHP_LIBS = libraries necessary +# PHP_VERSION_NUMBER = PHP version number in PHP's "vernum" format eg 50303 +# PHP_VERSION_MAJOR = PHP major version number eg 5 +# PHP_VERSION_MINOR = PHP minor version number eg 3 +# PHP_VERSION_PATCH = PHP patch version number eg 3 +# PHP_VERSION_STRING = PHP version string eg 5.3.3-1ubuntu9.3 +# PHP_API = PHP version api string eg 20131226 +# PHP_FOUND = set to TRUE if all of the above has been found. +# + +#============================================================================= +# Copyright 2016 Jerry Jacobs +# Copyright 2011-2012 Paul Colby +# +# Distributed under the OSI-approved BSD License (the "License"); +# see accompanying file LICENSE.md for details. +# +# This software is distributed WITHOUT ANY WARRANTY; without even the +# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the License for more information. +#============================================================================= +# (To distribute this file outside of CMake, substitute the full +# License text for the above reference.) + +set(FINDPHP_DEBUG No) + +find_program(PHP_CONFIG_EXECUTABLE NAMES php-config7 php-config5 php-config4 php-config) + +if (PHP_CONFIG_EXECUTABLE) + # PHP_CONFIG_DIR + execute_process( + COMMAND + ${PHP_CONFIG_EXECUTABLE} --configure-options + #COMMAND sed -ne "s/^.*--with-config-file-scan-dir=\\([^ ]*\\).*/\\1/p" + OUTPUT_VARIABLE PHP_CONFIG_DIR + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + # PHP_EXECUTABLE + execute_process( + COMMAND + ${PHP_CONFIG_EXECUTABLE} --php-binary + OUTPUT_VARIABLE PHP_EXECUTABLE + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + # PHP_EXTENSIONS_DIR + execute_process( + COMMAND + ${PHP_CONFIG_EXECUTABLE} --extension-dir + OUTPUT_VARIABLE PHP_EXTENSIONS_DIR + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + # PHP_EXTENSIONS_INCLUDE_DIR + execute_process(COMMAND + ${PHP_CONFIG_EXECUTABLE} --include-dir + OUTPUT_VARIABLE PHP_EXTENSIONS_INCLUDE_DIR + OUTPUT_STRIP_TRAILING_WHITESPACE) + + # PHP_INCLUDE_DIRS + execute_process(COMMAND + ${PHP_CONFIG_EXECUTABLE} --includes + OUTPUT_VARIABLE _PHP_INCLUDE_DIRS + OUTPUT_STRIP_TRAILING_WHITESPACE) + + # Create CMake list from compiler include paths string + string(REPLACE "-I" ";" PHP_INCLUDE_DIRS ${_PHP_INCLUDE_DIRS}) + + # PHP_LIBS + execute_process(COMMAND + ${PHP_CONFIG_EXECUTABLE} --libs + OUTPUT_VARIABLE PHP_LIBS + OUTPUT_STRIP_TRAILING_WHITESPACE) + + + # PHP_VERSION_NUMBER + execute_process(COMMAND + ${PHP_CONFIG_EXECUTABLE} --vernum + OUTPUT_VARIABLE PHP_VERSION_NUMBER + OUTPUT_STRIP_TRAILING_WHITESPACE) + + # PHP_VERSION_MAJOR + # TODO sed should be replaced by CMake function(s) + execute_process( + COMMAND + ${PHP_CONFIG_EXECUTABLE} --vernum + OUTPUT_STRIP_TRAILING_WHITESPACE + COMMAND sed -ne "s/....$//p" + OUTPUT_VARIABLE PHP_VERSION_MAJOR + ) + + # PHP_VERSION_MINOR + # TODO sed should be replaced by CMake function(s) + execute_process( + COMMAND + ${PHP_CONFIG_EXECUTABLE} --vernum + OUTPUT_STRIP_TRAILING_WHITESPACE + COMMAND sed -ne "s/..$//p" + COMMAND sed -ne "s/^.0\\?//p" + OUTPUT_VARIABLE PHP_VERSION_MINOR + ) + + # PHP_VERSION_PATCH + # TODO sed should be replaced by CMake function(s) + execute_process( + COMMAND + ${PHP_CONFIG_EXECUTABLE} --vernum + OUTPUT_STRIP_TRAILING_WHITESPACE +# COMMAND sed -ne "s/^...0\\t\?//p" + OUTPUT_VARIABLE PHP_VERSION_PATCH + ) + + # PHP_VERSION_STRING + execute_process( + COMMAND + ${PHP_CONFIG_EXECUTABLE} --version + OUTPUT_VARIABLE PHP_VERSION_STRING + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + # PHP_API + execute_process( + COMMAND + ${PHP_CONFIG_EXECUTABLE} php-config --phpapi + OUTPUT_VARIABLE PHP_API + OUTPUT_STRIP_TRAILING_WHITESPACE + ) +endif(PHP_CONFIG_EXECUTABLE) + +mark_as_advanced( + PHP_CONFIG_DIR + PHP_CONFIG_EXECUTABLE + PHP_EXECUTABLE + PHP_EXTENSIONS_DIR + PHP_EXTENSIONS_INCLUDE_DIR + PHP_INCLUDE_DIRS + PHP_LIBS + PHP_VERSION_MAJOR + PHP_VERSION_MINOR + PHP_VERSION_PATCH + PHP_VERSION_STRING + PHP_API +) + +include(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS( + php + DEFAULT_MSG + PHP_VERSION_STRING + PHP_CONFIG_DIR + PHP_CONFIG_EXECUTABLE + PHP_EXECUTABLE + PHP_EXTENSIONS_DIR + PHP_EXTENSIONS_INCLUDE_DIR + PHP_INCLUDE_DIRS + PHP_LIBS + PHP_VERSION_NUMBER + PHP_VERSION_NUMBER + PHP_VERSION_MAJOR + PHP_VERSION_MINOR + PHP_VERSION_PATCH + PHP_VERSION_STRING +) + +# Some handy dev output. Is there a way to enable these in some debug mode? +if (${FINDPHP_DEBUG}) + message("PHP_FOUND = ${PHP_FOUND}") + message("PHP_CONFIG_DIR = ${PHP_CONFIG_DIR}") + message("PHP_CONFIG_EXECUTABLE = ${PHP_CONFIG_EXECUTABLE}") + message("PHP_EXECUTABLE = ${PHP_EXECUTABLE}") + message("PHP_EXTENSIONS_DIR = ${PHP_EXTENSIONS_DIR}") + message("PHP_EXTENSIONS_INCLUDE_DIR = ${PHP_EXTENSIONS_INCLUDE_DIR}") + message("PHP_INCLUDE_DIRS = ${PHP_INCLUDE_DIRS}") + message("PHP_LIBS = ${PHP_LIBS}") + message("PHP_VERSION_NUMBER = ${PHP_VERSION_NUMBER}") + message("PHP_VERSION_MAJOR = ${PHP_VERSION_MAJOR}") + message("PHP_VERSION_MINOR = ${PHP_VERSION_MINOR}") + message("PHP_VERSION_PATCH = ${PHP_VERSION_PATCH}") + message("PHP_VERSION_STRING = ${PHP_VERSION_STRING}") + message("PHP_API = ${PHP_API}") +endif() diff --git a/cmake/android.cmake b/cmake/android.cmake new file mode 100644 index 0000000..0bee797 --- /dev/null +++ b/cmake/android.cmake @@ -0,0 +1,1715 @@ +# Copyright (c) 2010-2011, Ethan Rublee +# Copyright (c) 2011-2014, Andrey Kamaev +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from this +# software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +# ------------------------------------------------------------------------------ +# Android CMake toolchain file, for use with the Android NDK r5-r10d +# Requires cmake 2.6.3 or newer (2.8.9 or newer is recommended). +# See home page: https://github.com/taka-no-me/android-cmake +# +# Usage Linux: +# $ export ANDROID_NDK=/absolute/path/to/the/android-ndk +# $ mkdir build && cd build +# $ cmake -DCMAKE_TOOLCHAIN_FILE=path/to/the/android.toolchain.cmake .. +# $ make -j8 +# +# Usage Windows: +# You need native port of make to build your project. +# Android NDK r7 (and newer) already has make.exe on board. +# For older NDK you have to install it separately. +# For example, this one: http://gnuwin32.sourceforge.net/packages/make.htm +# +# $ SET ANDROID_NDK=C:\absolute\path\to\the\android-ndk +# $ mkdir build && cd build +# $ cmake.exe -G"MinGW Makefiles" +# -DCMAKE_TOOLCHAIN_FILE=path\to\the\android.toolchain.cmake +# -DCMAKE_MAKE_PROGRAM="%ANDROID_NDK%\prebuilt\windows\bin\make.exe" .. +# $ cmake.exe --build . +# +# +# Options (can be set as cmake parameters: -D=): +# ANDROID_NDK=/opt/android-ndk - path to the NDK root. +# Can be set as environment variable. Can be set only at first cmake run. +# +# ANDROID_ABI=armeabi-v7a - specifies the target Application Binary +# Interface (ABI). This option nearly matches to the APP_ABI variable +# used by ndk-build tool from Android NDK. +# +# Possible targets are: +# "armeabi" - ARMv5TE based CPU with software floating point operations +# "armeabi-v7a" - ARMv7 based devices with hardware FPU instructions +# this ABI target is used by default +# "armeabi-v7a with NEON" - same as armeabi-v7a, but +# sets NEON as floating-point unit +# "armeabi-v7a with VFPV3" - same as armeabi-v7a, but +# sets VFPV3 as floating-point unit (has 32 registers instead of 16) +# "armeabi-v6 with VFP" - tuned for ARMv6 processors having VFP +# "x86" - IA-32 instruction set +# "mips" - MIPS32 instruction set +# +# 64-bit ABIs for NDK r10 and newer: +# "arm64-v8a" - ARMv8 AArch64 instruction set +# "x86_64" - Intel64 instruction set (r1) +# "mips64" - MIPS64 instruction set (r6) +# +# ANDROID_NATIVE_API_LEVEL=android-8 - level of Android API compile for. +# Option is read-only when standalone toolchain is used. +# Note: building for "android-L" requires explicit configuration. +# +# ANDROID_TOOLCHAIN_NAME=arm-linux-androideabi-4.9 - the name of compiler +# toolchain to be used. The list of possible values depends on the NDK +# version. For NDK r10c the possible values are: +# +# * aarch64-linux-android-4.9 +# * aarch64-linux-android-clang3.4 +# * aarch64-linux-android-clang3.5 +# * arm-linux-androideabi-4.6 +# * arm-linux-androideabi-4.8 +# * arm-linux-androideabi-4.9 (default) +# * arm-linux-androideabi-clang3.4 +# * arm-linux-androideabi-clang3.5 +# * mips64el-linux-android-4.9 +# * mips64el-linux-android-clang3.4 +# * mips64el-linux-android-clang3.5 +# * mipsel-linux-android-4.6 +# * mipsel-linux-android-4.8 +# * mipsel-linux-android-4.9 +# * mipsel-linux-android-clang3.4 +# * mipsel-linux-android-clang3.5 +# * x86-4.6 +# * x86-4.8 +# * x86-4.9 +# * x86-clang3.4 +# * x86-clang3.5 +# * x86_64-4.9 +# * x86_64-clang3.4 +# * x86_64-clang3.5 +# +# ANDROID_FORCE_ARM_BUILD=OFF - set ON to generate 32-bit ARM instructions +# instead of Thumb. Is not available for "armeabi-v6 with VFP" +# (is forced to be ON) ABI. +# +# ANDROID_NO_UNDEFINED=ON - set ON to show all undefined symbols as linker +# errors even if they are not used. +# +# ANDROID_SO_UNDEFINED=OFF - set ON to allow undefined symbols in shared +# libraries. Automatically turned for NDK r5x and r6x due to GLESv2 +# problems. +# +# ANDROID_STL=gnustl_static - specify the runtime to use. +# +# Possible values are: +# none -> Do not configure the runtime. +# system -> Use the default minimal system C++ runtime library. +# Implies -fno-rtti -fno-exceptions. +# Is not available for standalone toolchain. +# system_re -> Use the default minimal system C++ runtime library. +# Implies -frtti -fexceptions. +# Is not available for standalone toolchain. +# gabi++_static -> Use the GAbi++ runtime as a static library. +# Implies -frtti -fno-exceptions. +# Available for NDK r7 and newer. +# Is not available for standalone toolchain. +# gabi++_shared -> Use the GAbi++ runtime as a shared library. +# Implies -frtti -fno-exceptions. +# Available for NDK r7 and newer. +# Is not available for standalone toolchain. +# stlport_static -> Use the STLport runtime as a static library. +# Implies -fno-rtti -fno-exceptions for NDK before r7. +# Implies -frtti -fno-exceptions for NDK r7 and newer. +# Is not available for standalone toolchain. +# stlport_shared -> Use the STLport runtime as a shared library. +# Implies -fno-rtti -fno-exceptions for NDK before r7. +# Implies -frtti -fno-exceptions for NDK r7 and newer. +# Is not available for standalone toolchain. +# gnustl_static -> Use the GNU STL as a static library. +# Implies -frtti -fexceptions. +# gnustl_shared -> Use the GNU STL as a shared library. +# Implies -frtti -fno-exceptions. +# Available for NDK r7b and newer. +# Silently degrades to gnustl_static if not available. +# c++_shared -> Use the LLVM libc++ runtime as a shared library. +# Implies -std=c++11. +# Available for NDK r7b and newer. +# Is not available for standalone toolchain. +# +# ANDROID_STL_FORCE_FEATURES=ON - turn rtti and exceptions support based on +# chosen runtime. If disabled, then the user is responsible for settings +# these options. +# +# What?: +# android-cmake toolchain searches for NDK/toolchain in the following order: +# ANDROID_NDK - cmake parameter +# ANDROID_NDK - environment variable +# ANDROID_STANDALONE_TOOLCHAIN - cmake parameter +# ANDROID_STANDALONE_TOOLCHAIN - environment variable +# ANDROID_NDK - default locations +# ANDROID_STANDALONE_TOOLCHAIN - default locations +# +# Make sure to do the following in your scripts: +# SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${my_cxx_flags}" ) +# SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${my_cxx_flags}" ) +# The flags will be prepopulated with critical flags, so don't loose them. +# Also be aware that toolchain also sets configuration-specific compiler +# flags and linker flags. +# +# ANDROID and BUILD_ANDROID will be set to true, you may test any of these +# variables to make necessary Android-specific configuration changes. +# +# Also ARMEABI or ARMEABI_V7A or X86 or MIPS or ARM64_V8A or X86_64 or MIPS64 +# will be set true, mutually exclusive. NEON option will be set true +# if VFP is set to NEON. +# +# ------------------------------------------------------------------------------ + +cmake_minimum_required( VERSION 2.6.3 ) + +if( DEFINED CMAKE_CROSSCOMPILING ) + # subsequent toolchain loading is not really needed + return() +endif() + +if( CMAKE_TOOLCHAIN_FILE ) + # touch toolchain variable to suppress "unused variable" warning +endif() + +# inherit settings in recursive loads +get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE ) +if( _CMAKE_IN_TRY_COMPILE ) + include( "${CMAKE_CURRENT_SOURCE_DIR}/../android.toolchain.config.cmake" OPTIONAL ) +endif() + +# this one is important +if( CMAKE_VERSION VERSION_GREATER "3.0.99" ) + set( CMAKE_SYSTEM_NAME Android ) +else() + set( CMAKE_SYSTEM_NAME Linux ) +endif() + +# this one not so much +set( CMAKE_SYSTEM_VERSION 1 ) + +# rpath makes low sense for Android +set( CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG "" ) +set( CMAKE_SKIP_RPATH TRUE CACHE BOOL "If set, runtime paths are not added when using shared libraries." ) + +# NDK search paths +set( ANDROID_SUPPORTED_NDK_VERSIONS ${ANDROID_EXTRA_NDK_VERSIONS} -r10d -r10c -r10b -r10 -r9d -r9c -r9b -r9 -r8e -r8d -r8c -r8b -r8 -r7c -r7b -r7 -r6b -r6 -r5c -r5b -r5 "" ) +if( NOT DEFINED ANDROID_NDK_SEARCH_PATHS ) + if( CMAKE_HOST_WIN32 ) + file( TO_CMAKE_PATH "$ENV{PROGRAMFILES}" ANDROID_NDK_SEARCH_PATHS ) + set( ANDROID_NDK_SEARCH_PATHS "${ANDROID_NDK_SEARCH_PATHS}" "$ENV{SystemDrive}/NVPACK" ) + else() + file( TO_CMAKE_PATH "$ENV{HOME}" ANDROID_NDK_SEARCH_PATHS ) + set( ANDROID_NDK_SEARCH_PATHS /opt "${ANDROID_NDK_SEARCH_PATHS}/NVPACK" ) + endif() +endif() +if( NOT DEFINED ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH ) + set( ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH /opt/android-toolchain ) +endif() + +# known ABIs +set( ANDROID_SUPPORTED_ABIS_arm "armeabi-v7a;armeabi;armeabi-v7a with NEON;armeabi-v7a with VFPV3;armeabi-v6 with VFP" ) +set( ANDROID_SUPPORTED_ABIS_arm64 "arm64-v8a" ) +set( ANDROID_SUPPORTED_ABIS_x86 "x86" ) +set( ANDROID_SUPPORTED_ABIS_x86_64 "x86_64" ) +set( ANDROID_SUPPORTED_ABIS_mips "mips" ) +set( ANDROID_SUPPORTED_ABIS_mips64 "mips64" ) + +# API level defaults +set( ANDROID_DEFAULT_NDK_API_LEVEL 9 ) +set( ANDROID_DEFAULT_NDK_API_LEVEL_arm64 21 ) +set( ANDROID_DEFAULT_NDK_API_LEVEL_x86 9 ) +set( ANDROID_DEFAULT_NDK_API_LEVEL_x86_64 21 ) +set( ANDROID_DEFAULT_NDK_API_LEVEL_mips 9 ) +set( ANDROID_DEFAULT_NDK_API_LEVEL_mips64 21 ) + + +macro( __LIST_FILTER listvar regex ) + if( ${listvar} ) + foreach( __val ${${listvar}} ) + if( __val MATCHES "${regex}" ) + list( REMOVE_ITEM ${listvar} "${__val}" ) + endif() + endforeach() + endif() +endmacro() + +macro( __INIT_VARIABLE var_name ) + set( __test_path 0 ) + foreach( __var ${ARGN} ) + if( __var STREQUAL "PATH" ) + set( __test_path 1 ) + break() + endif() + endforeach() + + if( __test_path AND NOT EXISTS "${${var_name}}" ) + unset( ${var_name} CACHE ) + endif() + + if( " ${${var_name}}" STREQUAL " " ) + set( __values 0 ) + foreach( __var ${ARGN} ) + if( __var STREQUAL "VALUES" ) + set( __values 1 ) + elseif( NOT __var STREQUAL "PATH" ) + if( __var MATCHES "^ENV_.*$" ) + string( REPLACE "ENV_" "" __var "${__var}" ) + set( __value "$ENV{${__var}}" ) + elseif( DEFINED ${__var} ) + set( __value "${${__var}}" ) + elseif( __values ) + set( __value "${__var}" ) + else() + set( __value "" ) + endif() + + if( NOT " ${__value}" STREQUAL " " AND (NOT __test_path OR EXISTS "${__value}") ) + set( ${var_name} "${__value}" ) + break() + endif() + endif() + endforeach() + unset( __value ) + unset( __values ) + endif() + + if( __test_path ) + file( TO_CMAKE_PATH "${${var_name}}" ${var_name} ) + endif() + unset( __test_path ) +endmacro() + +macro( __DETECT_NATIVE_API_LEVEL _var _path ) + set( __ndkApiLevelRegex "^[\t ]*#define[\t ]+__ANDROID_API__[\t ]+([0-9]+)[\t ]*.*$" ) + file( STRINGS ${_path} __apiFileContent REGEX "${__ndkApiLevelRegex}" ) + if( NOT __apiFileContent ) + message( SEND_ERROR "Could not get Android native API level. Probably you have specified invalid level value, or your copy of NDK/toolchain is broken." ) + endif() + string( REGEX REPLACE "${__ndkApiLevelRegex}" "\\1" ${_var} "${__apiFileContent}" ) + unset( __apiFileContent ) + unset( __ndkApiLevelRegex ) +endmacro() + +macro( __DETECT_TOOLCHAIN_MACHINE_NAME _var _root ) + if( EXISTS "${_root}" ) + file( GLOB __gccExePath RELATIVE "${_root}/bin/" "${_root}/bin/*-gcc${TOOL_OS_SUFFIX}" ) + __LIST_FILTER( __gccExePath "^[.].*" ) + list( LENGTH __gccExePath __gccExePathsCount ) + if( NOT __gccExePathsCount EQUAL 1 AND NOT _CMAKE_IN_TRY_COMPILE ) + message( WARNING "Could not determine machine name for compiler from ${_root}" ) + set( ${_var} "" ) + else() + get_filename_component( __gccExeName "${__gccExePath}" NAME_WE ) + string( REPLACE "-gcc" "" ${_var} "${__gccExeName}" ) + endif() + unset( __gccExePath ) + unset( __gccExePathsCount ) + unset( __gccExeName ) + else() + set( ${_var} "" ) + endif() +endmacro() + + +# fight against cygwin +set( ANDROID_FORBID_SYGWIN TRUE CACHE BOOL "Prevent cmake from working under cygwin and using cygwin tools") +mark_as_advanced( ANDROID_FORBID_SYGWIN ) +if( ANDROID_FORBID_SYGWIN ) + if( CYGWIN ) + message( FATAL_ERROR "Android NDK and android-cmake toolchain are not welcome Cygwin. It is unlikely that this cmake toolchain will work under cygwin. But if you want to try then you can set cmake variable ANDROID_FORBID_SYGWIN to FALSE and rerun cmake." ) + endif() + + if( CMAKE_HOST_WIN32 ) + # remove cygwin from PATH + set( __new_path "$ENV{PATH}") + __LIST_FILTER( __new_path "cygwin" ) + set(ENV{PATH} "${__new_path}") + unset(__new_path) + endif() +endif() + + +# detect current host platform +if( NOT DEFINED ANDROID_NDK_HOST_X64 AND (CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|AMD64" OR CMAKE_HOST_APPLE) ) + set( ANDROID_NDK_HOST_X64 1 CACHE BOOL "Try to use 64-bit compiler toolchain" ) + mark_as_advanced( ANDROID_NDK_HOST_X64 ) +endif() + +set( TOOL_OS_SUFFIX "" ) +if( CMAKE_HOST_APPLE ) + set( ANDROID_NDK_HOST_SYSTEM_NAME "darwin-x86_64" ) + set( ANDROID_NDK_HOST_SYSTEM_NAME2 "darwin-x86" ) +elseif( CMAKE_HOST_WIN32 ) + set( ANDROID_NDK_HOST_SYSTEM_NAME "windows-x86_64" ) + set( ANDROID_NDK_HOST_SYSTEM_NAME2 "windows" ) + set( TOOL_OS_SUFFIX ".exe" ) +elseif( CMAKE_HOST_UNIX ) + set( ANDROID_NDK_HOST_SYSTEM_NAME "linux-x86_64" ) + set( ANDROID_NDK_HOST_SYSTEM_NAME2 "linux-x86" ) +else() + message( FATAL_ERROR "Cross-compilation on your platform is not supported by this cmake toolchain" ) +endif() + +if( NOT ANDROID_NDK_HOST_X64 ) + set( ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME2} ) +endif() + +# see if we have path to Android NDK +if( NOT ANDROID_NDK AND NOT ANDROID_STANDALONE_TOOLCHAIN ) + __INIT_VARIABLE( ANDROID_NDK PATH ENV_ANDROID_NDK ) +endif() +if( NOT ANDROID_NDK ) + # see if we have path to Android standalone toolchain + __INIT_VARIABLE( ANDROID_STANDALONE_TOOLCHAIN PATH ENV_ANDROID_STANDALONE_TOOLCHAIN ) + + if( NOT ANDROID_STANDALONE_TOOLCHAIN ) + #try to find Android NDK in one of the the default locations + set( __ndkSearchPaths ) + foreach( __ndkSearchPath ${ANDROID_NDK_SEARCH_PATHS} ) + foreach( suffix ${ANDROID_SUPPORTED_NDK_VERSIONS} ) + list( APPEND __ndkSearchPaths "${__ndkSearchPath}/android-ndk${suffix}" ) + endforeach() + endforeach() + __INIT_VARIABLE( ANDROID_NDK PATH VALUES ${__ndkSearchPaths} ) + unset( __ndkSearchPaths ) + + if( ANDROID_NDK ) + message( STATUS "Using default path for Android NDK: ${ANDROID_NDK}" ) + message( STATUS " If you prefer to use a different location, please define a cmake or environment variable: ANDROID_NDK" ) + else() + #try to find Android standalone toolchain in one of the the default locations + __INIT_VARIABLE( ANDROID_STANDALONE_TOOLCHAIN PATH ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH ) + + if( ANDROID_STANDALONE_TOOLCHAIN ) + message( STATUS "Using default path for standalone toolchain ${ANDROID_STANDALONE_TOOLCHAIN}" ) + message( STATUS " If you prefer to use a different location, please define the variable: ANDROID_STANDALONE_TOOLCHAIN" ) + endif( ANDROID_STANDALONE_TOOLCHAIN ) + endif( ANDROID_NDK ) + endif( NOT ANDROID_STANDALONE_TOOLCHAIN ) +endif( NOT ANDROID_NDK ) + +# remember found paths +if( ANDROID_NDK ) + get_filename_component( ANDROID_NDK "${ANDROID_NDK}" ABSOLUTE ) + set( ANDROID_NDK "${ANDROID_NDK}" CACHE INTERNAL "Path of the Android NDK" FORCE ) + set( BUILD_WITH_ANDROID_NDK True ) + if( EXISTS "${ANDROID_NDK}/RELEASE.TXT" ) + file( STRINGS "${ANDROID_NDK}/RELEASE.TXT" ANDROID_NDK_RELEASE_FULL LIMIT_COUNT 1 REGEX "r[0-9]+[a-z]?" ) + string( REGEX MATCH "r([0-9]+)([a-z]?)" ANDROID_NDK_RELEASE "${ANDROID_NDK_RELEASE_FULL}" ) + else() + set( ANDROID_NDK_RELEASE "r1x" ) + set( ANDROID_NDK_RELEASE_FULL "unreleased" ) + endif() + string( REGEX REPLACE "r([0-9]+)([a-z]?)" "\\1*1000" ANDROID_NDK_RELEASE_NUM "${ANDROID_NDK_RELEASE}" ) + string( FIND " abcdefghijklmnopqastuvwxyz" "${CMAKE_MATCH_2}" __ndkReleaseLetterNum ) + math( EXPR ANDROID_NDK_RELEASE_NUM "${ANDROID_NDK_RELEASE_NUM}+${__ndkReleaseLetterNum}" ) +elseif( ANDROID_STANDALONE_TOOLCHAIN ) + get_filename_component( ANDROID_STANDALONE_TOOLCHAIN "${ANDROID_STANDALONE_TOOLCHAIN}" ABSOLUTE ) + # try to detect change + if( CMAKE_AR ) + string( LENGTH "${ANDROID_STANDALONE_TOOLCHAIN}" __length ) + string( SUBSTRING "${CMAKE_AR}" 0 ${__length} __androidStandaloneToolchainPreviousPath ) + if( NOT __androidStandaloneToolchainPreviousPath STREQUAL ANDROID_STANDALONE_TOOLCHAIN ) + message( FATAL_ERROR "It is not possible to change path to the Android standalone toolchain on subsequent run." ) + endif() + unset( __androidStandaloneToolchainPreviousPath ) + unset( __length ) + endif() + set( ANDROID_STANDALONE_TOOLCHAIN "${ANDROID_STANDALONE_TOOLCHAIN}" CACHE INTERNAL "Path of the Android standalone toolchain" FORCE ) + set( BUILD_WITH_STANDALONE_TOOLCHAIN True ) +else() + list(GET ANDROID_NDK_SEARCH_PATHS 0 ANDROID_NDK_SEARCH_PATH) + message( FATAL_ERROR "Could not find neither Android NDK nor Android standalone toolchain. + You should either set an environment variable: + export ANDROID_NDK=~/my-android-ndk + or + export ANDROID_STANDALONE_TOOLCHAIN=~/my-android-toolchain + or put the toolchain or NDK in the default path: + sudo ln -s ~/my-android-ndk ${ANDROID_NDK_SEARCH_PATH}/android-ndk + sudo ln -s ~/my-android-toolchain ${ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH}" ) +endif() + +# android NDK layout +if( BUILD_WITH_ANDROID_NDK ) + if( NOT DEFINED ANDROID_NDK_LAYOUT ) + # try to automatically detect the layout + if( EXISTS "${ANDROID_NDK}/RELEASE.TXT") + set( ANDROID_NDK_LAYOUT "RELEASE" ) + elseif( EXISTS "${ANDROID_NDK}/../../linux-x86/toolchain/" ) + set( ANDROID_NDK_LAYOUT "LINARO" ) + elseif( EXISTS "${ANDROID_NDK}/../../gcc/" ) + set( ANDROID_NDK_LAYOUT "ANDROID" ) + endif() + endif() + set( ANDROID_NDK_LAYOUT "${ANDROID_NDK_LAYOUT}" CACHE STRING "The inner layout of NDK" ) + mark_as_advanced( ANDROID_NDK_LAYOUT ) + if( ANDROID_NDK_LAYOUT STREQUAL "LINARO" ) + set( ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME2} ) # only 32-bit at the moment + set( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK}/../../${ANDROID_NDK_HOST_SYSTEM_NAME}/toolchain" ) + set( ANDROID_NDK_TOOLCHAINS_SUBPATH "" ) + set( ANDROID_NDK_TOOLCHAINS_SUBPATH2 "" ) + elseif( ANDROID_NDK_LAYOUT STREQUAL "ANDROID" ) + set( ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME2} ) # only 32-bit at the moment + set( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK}/../../gcc/${ANDROID_NDK_HOST_SYSTEM_NAME}/arm" ) + set( ANDROID_NDK_TOOLCHAINS_SUBPATH "" ) + set( ANDROID_NDK_TOOLCHAINS_SUBPATH2 "" ) + else() # ANDROID_NDK_LAYOUT STREQUAL "RELEASE" + set( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK}/toolchains" ) + set( ANDROID_NDK_TOOLCHAINS_SUBPATH "/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" ) + set( ANDROID_NDK_TOOLCHAINS_SUBPATH2 "/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME2}" ) + endif() + get_filename_component( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK_TOOLCHAINS_PATH}" ABSOLUTE ) + + # try to detect change of NDK + if( CMAKE_AR ) + string( LENGTH "${ANDROID_NDK_TOOLCHAINS_PATH}" __length ) + string( SUBSTRING "${CMAKE_AR}" 0 ${__length} __androidNdkPreviousPath ) + if( NOT __androidNdkPreviousPath STREQUAL ANDROID_NDK_TOOLCHAINS_PATH ) + message( FATAL_ERROR "It is not possible to change the path to the NDK on subsequent CMake run. You must remove all generated files from your build folder first. + " ) + endif() + unset( __androidNdkPreviousPath ) + unset( __length ) + endif() +endif() + + +# get all the details about standalone toolchain +if( BUILD_WITH_STANDALONE_TOOLCHAIN ) + __DETECT_NATIVE_API_LEVEL( ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot/usr/include/android/api-level.h" ) + set( ANDROID_STANDALONE_TOOLCHAIN_API_LEVEL ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} ) + set( __availableToolchains "standalone" ) + __DETECT_TOOLCHAIN_MACHINE_NAME( __availableToolchainMachines "${ANDROID_STANDALONE_TOOLCHAIN}" ) + if( NOT __availableToolchainMachines ) + message( FATAL_ERROR "Could not determine machine name of your toolchain. Probably your Android standalone toolchain is broken." ) + endif() + if( __availableToolchainMachines MATCHES x86_64 ) + set( __availableToolchainArchs "x86_64" ) + elseif( __availableToolchainMachines MATCHES i686 ) + set( __availableToolchainArchs "x86" ) + elseif( __availableToolchainMachines MATCHES aarch64 ) + set( __availableToolchainArchs "arm64" ) + elseif( __availableToolchainMachines MATCHES arm ) + set( __availableToolchainArchs "arm" ) + elseif( __availableToolchainMachines MATCHES mips64el ) + set( __availableToolchainArchs "mips64" ) + elseif( __availableToolchainMachines MATCHES mipsel ) + set( __availableToolchainArchs "mips" ) + endif() + execute_process( COMMAND "${ANDROID_STANDALONE_TOOLCHAIN}/bin/${__availableToolchainMachines}-gcc${TOOL_OS_SUFFIX}" -dumpversion + OUTPUT_VARIABLE __availableToolchainCompilerVersions OUTPUT_STRIP_TRAILING_WHITESPACE ) + string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9]+)?" __availableToolchainCompilerVersions "${__availableToolchainCompilerVersions}" ) + if( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/bin/clang${TOOL_OS_SUFFIX}" ) + list( APPEND __availableToolchains "standalone-clang" ) + list( APPEND __availableToolchainMachines ${__availableToolchainMachines} ) + list( APPEND __availableToolchainArchs ${__availableToolchainArchs} ) + list( APPEND __availableToolchainCompilerVersions ${__availableToolchainCompilerVersions} ) + endif() +endif() + +macro( __GLOB_NDK_TOOLCHAINS __availableToolchainsVar __availableToolchainsLst __toolchain_subpath ) + foreach( __toolchain ${${__availableToolchainsLst}} ) + if( "${__toolchain}" MATCHES "-clang3[.][0-9]$" AND NOT EXISTS "${ANDROID_NDK_TOOLCHAINS_PATH}/${__toolchain}${__toolchain_subpath}" ) + SET( __toolchainVersionRegex "^TOOLCHAIN_VERSION[\t ]+:=[\t ]+(.*)$" ) + FILE( STRINGS "${ANDROID_NDK_TOOLCHAINS_PATH}/${__toolchain}/setup.mk" __toolchainVersionStr REGEX "${__toolchainVersionRegex}" ) + if( __toolchainVersionStr ) + string( REGEX REPLACE "${__toolchainVersionRegex}" "\\1" __toolchainVersionStr "${__toolchainVersionStr}" ) + string( REGEX REPLACE "-clang3[.][0-9]$" "-${__toolchainVersionStr}" __gcc_toolchain "${__toolchain}" ) + else() + string( REGEX REPLACE "-clang3[.][0-9]$" "-4.6" __gcc_toolchain "${__toolchain}" ) + endif() + unset( __toolchainVersionStr ) + unset( __toolchainVersionRegex ) + else() + set( __gcc_toolchain "${__toolchain}" ) + endif() + __DETECT_TOOLCHAIN_MACHINE_NAME( __machine "${ANDROID_NDK_TOOLCHAINS_PATH}/${__gcc_toolchain}${__toolchain_subpath}" ) + if( __machine ) + string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9x]+)?$" __version "${__gcc_toolchain}" ) + if( __machine MATCHES x86_64 ) + set( __arch "x86_64" ) + elseif( __machine MATCHES i686 ) + set( __arch "x86" ) + elseif( __machine MATCHES aarch64 ) + set( __arch "arm64" ) + elseif( __machine MATCHES arm ) + set( __arch "arm" ) + elseif( __machine MATCHES mips64el ) + set( __arch "mips64" ) + elseif( __machine MATCHES mipsel ) + set( __arch "mips" ) + else() + set( __arch "" ) + endif() + #message("machine: !${__machine}!\narch: !${__arch}!\nversion: !${__version}!\ntoolchain: !${__toolchain}!\n") + if (__arch) + list( APPEND __availableToolchainMachines "${__machine}" ) + list( APPEND __availableToolchainArchs "${__arch}" ) + list( APPEND __availableToolchainCompilerVersions "${__version}" ) + list( APPEND ${__availableToolchainsVar} "${__toolchain}" ) + endif() + endif() + unset( __gcc_toolchain ) + endforeach() +endmacro() + +# get all the details about NDK +if( BUILD_WITH_ANDROID_NDK ) + file( GLOB ANDROID_SUPPORTED_NATIVE_API_LEVELS RELATIVE "${ANDROID_NDK}/platforms" "${ANDROID_NDK}/platforms/android-*" ) + string( REPLACE "android-" "" ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_SUPPORTED_NATIVE_API_LEVELS}" ) + set( __availableToolchains "" ) + set( __availableToolchainMachines "" ) + set( __availableToolchainArchs "" ) + set( __availableToolchainCompilerVersions "" ) + if( ANDROID_TOOLCHAIN_NAME AND EXISTS "${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_TOOLCHAIN_NAME}/" ) + # do not go through all toolchains if we know the name + set( __availableToolchainsLst "${ANDROID_TOOLCHAIN_NAME}" ) + __GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH}" ) + if( NOT __availableToolchains AND NOT ANDROID_NDK_TOOLCHAINS_SUBPATH STREQUAL ANDROID_NDK_TOOLCHAINS_SUBPATH2 ) + __GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH2}" ) + if( __availableToolchains ) + set( ANDROID_NDK_TOOLCHAINS_SUBPATH ${ANDROID_NDK_TOOLCHAINS_SUBPATH2} ) + endif() + endif() + endif() + if( NOT __availableToolchains ) + file( GLOB __availableToolchainsLst RELATIVE "${ANDROID_NDK_TOOLCHAINS_PATH}" "${ANDROID_NDK_TOOLCHAINS_PATH}/*" ) + if( __availableToolchainsLst ) + list(SORT __availableToolchainsLst) # we need clang to go after gcc + endif() + __LIST_FILTER( __availableToolchainsLst "^[.]" ) + __LIST_FILTER( __availableToolchainsLst "llvm" ) + __LIST_FILTER( __availableToolchainsLst "renderscript" ) + __GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH}" ) + if( NOT __availableToolchains AND NOT ANDROID_NDK_TOOLCHAINS_SUBPATH STREQUAL ANDROID_NDK_TOOLCHAINS_SUBPATH2 ) + __GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH2}" ) + if( __availableToolchains ) + set( ANDROID_NDK_TOOLCHAINS_SUBPATH ${ANDROID_NDK_TOOLCHAINS_SUBPATH2} ) + endif() + endif() + endif() + if( NOT __availableToolchains ) + message( FATAL_ERROR "Could not find any working toolchain in the NDK. Probably your Android NDK is broken." ) + endif() +endif() + +# build list of available ABIs +set( ANDROID_SUPPORTED_ABIS "" ) +set( __uniqToolchainArchNames ${__availableToolchainArchs} ) +list( REMOVE_DUPLICATES __uniqToolchainArchNames ) +list( SORT __uniqToolchainArchNames ) +foreach( __arch ${__uniqToolchainArchNames} ) + list( APPEND ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${__arch}} ) +endforeach() +unset( __uniqToolchainArchNames ) +if( NOT ANDROID_SUPPORTED_ABIS ) + message( FATAL_ERROR "No one of known Android ABIs is supported by this cmake toolchain." ) +endif() + +# choose target ABI +__INIT_VARIABLE( ANDROID_ABI VALUES ${ANDROID_SUPPORTED_ABIS} ) +# verify that target ABI is supported +list( FIND ANDROID_SUPPORTED_ABIS "${ANDROID_ABI}" __androidAbiIdx ) +if( __androidAbiIdx EQUAL -1 ) + string( REPLACE ";" "\", \"" PRINTABLE_ANDROID_SUPPORTED_ABIS "${ANDROID_SUPPORTED_ABIS}" ) + message( FATAL_ERROR "Specified ANDROID_ABI = \"${ANDROID_ABI}\" is not supported by this cmake toolchain or your NDK/toolchain. + Supported values are: \"${PRINTABLE_ANDROID_SUPPORTED_ABIS}\" + " ) +endif() +unset( __androidAbiIdx ) + +# set target ABI options +if( ANDROID_ABI STREQUAL "x86" ) + set( X86 true ) + set( ANDROID_NDK_ABI_NAME "x86" ) + set( ANDROID_ARCH_NAME "x86" ) + set( ANDROID_LLVM_TRIPLE "i686-none-linux-android" ) + set( CMAKE_SYSTEM_PROCESSOR "i686" ) +elseif( ANDROID_ABI STREQUAL "x86_64" ) + set( X86 true ) + set( X86_64 true ) + set( ANDROID_NDK_ABI_NAME "x86_64" ) + set( ANDROID_ARCH_NAME "x86_64" ) + set( CMAKE_SYSTEM_PROCESSOR "x86_64" ) + set( ANDROID_LLVM_TRIPLE "x86_64-none-linux-android" ) +elseif( ANDROID_ABI STREQUAL "mips64" ) + set( MIPS64 true ) + set( ANDROID_NDK_ABI_NAME "mips64" ) + set( ANDROID_ARCH_NAME "mips64" ) + set( ANDROID_LLVM_TRIPLE "mips64el-none-linux-android" ) + set( CMAKE_SYSTEM_PROCESSOR "mips64" ) +elseif( ANDROID_ABI STREQUAL "mips" ) + set( MIPS true ) + set( ANDROID_NDK_ABI_NAME "mips" ) + set( ANDROID_ARCH_NAME "mips" ) + set( ANDROID_LLVM_TRIPLE "mipsel-none-linux-android" ) + set( CMAKE_SYSTEM_PROCESSOR "mips" ) +elseif( ANDROID_ABI STREQUAL "arm64-v8a" ) + set( ARM64_V8A true ) + set( ANDROID_NDK_ABI_NAME "arm64-v8a" ) + set( ANDROID_ARCH_NAME "arm64" ) + set( ANDROID_LLVM_TRIPLE "aarch64-none-linux-android" ) + set( CMAKE_SYSTEM_PROCESSOR "aarch64" ) + set( VFPV3 true ) + set( NEON true ) +elseif( ANDROID_ABI STREQUAL "armeabi" ) + set( ARMEABI true ) + set( ANDROID_NDK_ABI_NAME "armeabi" ) + set( ANDROID_ARCH_NAME "arm" ) + set( ANDROID_LLVM_TRIPLE "armv5te-none-linux-androideabi" ) + set( CMAKE_SYSTEM_PROCESSOR "armv5te" ) +elseif( ANDROID_ABI STREQUAL "armeabi-v6 with VFP" ) + set( ARMEABI_V6 true ) + set( ANDROID_NDK_ABI_NAME "armeabi" ) + set( ANDROID_ARCH_NAME "arm" ) + set( ANDROID_LLVM_TRIPLE "armv5te-none-linux-androideabi" ) + set( CMAKE_SYSTEM_PROCESSOR "armv6" ) + # need always fallback to older platform + set( ARMEABI true ) +elseif( ANDROID_ABI STREQUAL "armeabi-v7a") + set( ARMEABI_V7A true ) + set( ANDROID_NDK_ABI_NAME "armeabi-v7a" ) + set( ANDROID_ARCH_NAME "arm" ) + set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" ) + set( CMAKE_SYSTEM_PROCESSOR "armv7-a" ) +elseif( ANDROID_ABI STREQUAL "armeabi-v7a with VFPV3" ) + set( ARMEABI_V7A true ) + set( ANDROID_NDK_ABI_NAME "armeabi-v7a" ) + set( ANDROID_ARCH_NAME "arm" ) + set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" ) + set( CMAKE_SYSTEM_PROCESSOR "armv7-a" ) + set( VFPV3 true ) +elseif( ANDROID_ABI STREQUAL "armeabi-v7a with NEON" ) + set( ARMEABI_V7A true ) + set( ANDROID_NDK_ABI_NAME "armeabi-v7a" ) + set( ANDROID_ARCH_NAME "arm" ) + set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" ) + set( CMAKE_SYSTEM_PROCESSOR "armv7-a" ) + set( VFPV3 true ) + set( NEON true ) +else() + message( SEND_ERROR "Unknown ANDROID_ABI=\"${ANDROID_ABI}\" is specified." ) +endif() + +if( CMAKE_BINARY_DIR AND EXISTS "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake" ) + # really dirty hack + # it is not possible to change CMAKE_SYSTEM_PROCESSOR after the first run... + file( APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake" "SET(CMAKE_SYSTEM_PROCESSOR \"${CMAKE_SYSTEM_PROCESSOR}\")\n" ) +endif() + +if( ANDROID_ARCH_NAME STREQUAL "arm" AND NOT ARMEABI_V6 ) + __INIT_VARIABLE( ANDROID_FORCE_ARM_BUILD VALUES OFF ) + set( ANDROID_FORCE_ARM_BUILD ${ANDROID_FORCE_ARM_BUILD} CACHE BOOL "Use 32-bit ARM instructions instead of Thumb-1" FORCE ) + mark_as_advanced( ANDROID_FORCE_ARM_BUILD ) +else() + unset( ANDROID_FORCE_ARM_BUILD CACHE ) +endif() + +# choose toolchain +if( ANDROID_TOOLCHAIN_NAME ) + list( FIND __availableToolchains "${ANDROID_TOOLCHAIN_NAME}" __toolchainIdx ) + if( __toolchainIdx EQUAL -1 ) + list( SORT __availableToolchains ) + string( REPLACE ";" "\n * " toolchains_list "${__availableToolchains}" ) + set( toolchains_list " * ${toolchains_list}") + message( FATAL_ERROR "Specified toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is missing in your NDK or broken. Please verify that your NDK is working or select another compiler toolchain. +To configure the toolchain set CMake variable ANDROID_TOOLCHAIN_NAME to one of the following values:\n${toolchains_list}\n" ) + endif() + list( GET __availableToolchainArchs ${__toolchainIdx} __toolchainArch ) + if( NOT __toolchainArch STREQUAL ANDROID_ARCH_NAME ) + message( SEND_ERROR "Selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is not able to compile binaries for the \"${ANDROID_ARCH_NAME}\" platform." ) + endif() +else() + set( __toolchainIdx -1 ) + set( __applicableToolchains "" ) + set( __toolchainMaxVersion "0.0.0" ) + list( LENGTH __availableToolchains __availableToolchainsCount ) + math( EXPR __availableToolchainsCount "${__availableToolchainsCount}-1" ) + foreach( __idx RANGE ${__availableToolchainsCount} ) + list( GET __availableToolchainArchs ${__idx} __toolchainArch ) + if( __toolchainArch STREQUAL ANDROID_ARCH_NAME ) + list( GET __availableToolchainCompilerVersions ${__idx} __toolchainVersion ) + string( REPLACE "x" "99" __toolchainVersion "${__toolchainVersion}") + if( __toolchainVersion VERSION_GREATER __toolchainMaxVersion ) + set( __toolchainMaxVersion "${__toolchainVersion}" ) + set( __toolchainIdx ${__idx} ) + endif() + endif() + endforeach() + unset( __availableToolchainsCount ) + unset( __toolchainMaxVersion ) + unset( __toolchainVersion ) +endif() +unset( __toolchainArch ) +if( __toolchainIdx EQUAL -1 ) + message( FATAL_ERROR "No one of available compiler toolchains is able to compile for ${ANDROID_ARCH_NAME} platform." ) +endif() +list( GET __availableToolchains ${__toolchainIdx} ANDROID_TOOLCHAIN_NAME ) +list( GET __availableToolchainMachines ${__toolchainIdx} ANDROID_TOOLCHAIN_MACHINE_NAME ) +list( GET __availableToolchainCompilerVersions ${__toolchainIdx} ANDROID_COMPILER_VERSION ) + +unset( __toolchainIdx ) +unset( __availableToolchains ) +unset( __availableToolchainMachines ) +unset( __availableToolchainArchs ) +unset( __availableToolchainCompilerVersions ) + +# choose native API level +__INIT_VARIABLE( ANDROID_NATIVE_API_LEVEL ENV_ANDROID_NATIVE_API_LEVEL ANDROID_API_LEVEL ENV_ANDROID_API_LEVEL ANDROID_STANDALONE_TOOLCHAIN_API_LEVEL ANDROID_DEFAULT_NDK_API_LEVEL_${ANDROID_ARCH_NAME} ANDROID_DEFAULT_NDK_API_LEVEL ) +string( REPLACE "android-" "" ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" ) +string( STRIP "${ANDROID_NATIVE_API_LEVEL}" ANDROID_NATIVE_API_LEVEL ) +# adjust API level +set( __real_api_level ${ANDROID_DEFAULT_NDK_API_LEVEL_${ANDROID_ARCH_NAME}} ) +foreach( __level ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} ) + if( (__level LESS ANDROID_NATIVE_API_LEVEL OR __level STREQUAL ANDROID_NATIVE_API_LEVEL) AND NOT __level LESS __real_api_level ) + set( __real_api_level ${__level} ) + endif() +endforeach() +if( __real_api_level AND NOT ANDROID_NATIVE_API_LEVEL STREQUAL __real_api_level ) + message( STATUS "Adjusting Android API level 'android-${ANDROID_NATIVE_API_LEVEL}' to 'android-${__real_api_level}'") + set( ANDROID_NATIVE_API_LEVEL ${__real_api_level} ) +endif() +unset(__real_api_level) +# validate +list( FIND ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_NATIVE_API_LEVEL}" __levelIdx ) +if( __levelIdx EQUAL -1 ) + message( SEND_ERROR "Specified Android native API level 'android-${ANDROID_NATIVE_API_LEVEL}' is not supported by your NDK/toolchain." ) +else() + if( BUILD_WITH_ANDROID_NDK ) + __DETECT_NATIVE_API_LEVEL( __realApiLevel "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include/android/api-level.h" ) + if( NOT __realApiLevel EQUAL ANDROID_NATIVE_API_LEVEL AND NOT __realApiLevel GREATER 9000 ) + message( SEND_ERROR "Specified Android API level (${ANDROID_NATIVE_API_LEVEL}) does not match to the level found (${__realApiLevel}). Probably your copy of NDK is broken." ) + endif() + unset( __realApiLevel ) + endif() + set( ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" CACHE STRING "Android API level for native code" FORCE ) + set( CMAKE_ANDROID_API ${ANDROID_NATIVE_API_LEVEL} ) + if( CMAKE_VERSION VERSION_GREATER "2.8" ) + list( SORT ANDROID_SUPPORTED_NATIVE_API_LEVELS ) + set_property( CACHE ANDROID_NATIVE_API_LEVEL PROPERTY STRINGS ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} ) + endif() +endif() +unset( __levelIdx ) + + +# remember target ABI +set( ANDROID_ABI "${ANDROID_ABI}" CACHE STRING "The target ABI for Android. If arm, then armeabi-v7a is recommended for hardware floating point." FORCE ) +if( CMAKE_VERSION VERSION_GREATER "2.8" ) + list( SORT ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_NAME} ) + set_property( CACHE ANDROID_ABI PROPERTY STRINGS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_NAME}} ) +endif() + + +# runtime choice (STL, rtti, exceptions) +if( NOT ANDROID_STL ) + set( ANDROID_STL gnustl_static ) +endif() +set( ANDROID_STL "${ANDROID_STL}" CACHE STRING "C++ runtime" ) +set( ANDROID_STL_FORCE_FEATURES ON CACHE BOOL "automatically configure rtti and exceptions support based on C++ runtime" ) +mark_as_advanced( ANDROID_STL ANDROID_STL_FORCE_FEATURES ) + +if( BUILD_WITH_ANDROID_NDK ) + if( NOT "${ANDROID_STL}" MATCHES "^(none|system|system_re|gabi\\+\\+_static|gabi\\+\\+_shared|stlport_static|stlport_shared|gnustl_static|gnustl_shared|c\\+\\+_shared)$") + message( FATAL_ERROR "ANDROID_STL is set to invalid value \"${ANDROID_STL}\". +The possible values are: + none -> Do not configure the runtime. + system -> Use the default minimal system C++ runtime library. + system_re -> Same as system but with rtti and exceptions. + gabi++_static -> Use the GAbi++ runtime as a static library. + gabi++_shared -> Use the GAbi++ runtime as a shared library. + stlport_static -> Use the STLport runtime as a static library. + stlport_shared -> Use the STLport runtime as a shared library. + gnustl_static -> (default) Use the GNU STL as a static library. + gnustl_shared -> Use the GNU STL as a shared library. + c++_shared -> Use the LLVM libc++ as a shared library. +" ) + endif() +elseif( BUILD_WITH_STANDALONE_TOOLCHAIN ) + if( NOT "${ANDROID_STL}" MATCHES "^(none|gnustl_static|gnustl_shared)$") + message( FATAL_ERROR "ANDROID_STL is set to invalid value \"${ANDROID_STL}\". +The possible values are: + none -> Do not configure the runtime. + gnustl_static -> (default) Use the GNU STL as a static library. + gnustl_shared -> Use the GNU STL as a shared library. +" ) + endif() +endif() + +unset( ANDROID_RTTI ) +unset( ANDROID_EXCEPTIONS ) +unset( ANDROID_STL_INCLUDE_DIRS ) +unset( __libstl ) +unset( __libsupcxx ) + +if( NOT _CMAKE_IN_TRY_COMPILE AND ANDROID_NDK_RELEASE STREQUAL "r7b" AND ARMEABI_V7A AND NOT VFPV3 AND ANDROID_STL MATCHES "gnustl" ) + message( WARNING "The GNU STL armeabi-v7a binaries from NDK r7b can crash non-NEON devices. The files provided with NDK r7b were not configured properly, resulting in crashes on Tegra2-based devices and others when trying to use certain floating-point functions (e.g., cosf, sinf, expf). +You are strongly recommended to switch to another NDK release. +" ) +endif() + +if( NOT _CMAKE_IN_TRY_COMPILE AND X86 AND ANDROID_STL MATCHES "gnustl" AND ANDROID_NDK_RELEASE STREQUAL "r6" ) + message( WARNING "The x86 system header file from NDK r6 has incorrect definition for ptrdiff_t. You are recommended to upgrade to a newer NDK release or manually patch the header: +See https://android.googlesource.com/platform/development.git f907f4f9d4e56ccc8093df6fee54454b8bcab6c2 + diff --git a/ndk/platforms/android-9/arch-x86/include/machine/_types.h b/ndk/platforms/android-9/arch-x86/include/machine/_types.h + index 5e28c64..65892a1 100644 + --- a/ndk/platforms/android-9/arch-x86/include/machine/_types.h + +++ b/ndk/platforms/android-9/arch-x86/include/machine/_types.h + @@ -51,7 +51,11 @@ typedef long int ssize_t; + #endif + #ifndef _PTRDIFF_T + #define _PTRDIFF_T + -typedef long ptrdiff_t; + +# ifdef __ANDROID__ + + typedef int ptrdiff_t; + +# else + + typedef long ptrdiff_t; + +# endif + #endif +" ) +endif() + +# setup paths and STL for standalone toolchain +if( BUILD_WITH_STANDALONE_TOOLCHAIN ) + set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" ) + set( ANDROID_CLANG_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" ) + set( ANDROID_SYSROOT "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot" ) + + if( NOT ANDROID_STL STREQUAL "none" ) + set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_STANDALONE_TOOLCHAIN}/include/c++/${ANDROID_COMPILER_VERSION}" ) + if( NOT EXISTS "${ANDROID_STL_INCLUDE_DIRS}" ) + # old location ( pre r8c ) + set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}" ) + endif() + if( ARMEABI_V7A AND EXISTS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}/bits" ) + list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}" ) + elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb/bits" ) + list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb" ) + else() + list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}" ) + endif() + # always search static GNU STL to get the location of libsupc++.a + if( ARMEABI_V7A AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libstdc++.a" ) + set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb" ) + elseif( ARMEABI_V7A AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libstdc++.a" ) + set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}" ) + elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libstdc++.a" ) + set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb" ) + elseif( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libstdc++.a" ) + set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib" ) + endif() + if( __libstl ) + set( __libsupcxx "${__libstl}/libsupc++.a" ) + set( __libstl "${__libstl}/libstdc++.a" ) + endif() + if( NOT EXISTS "${__libsupcxx}" ) + message( FATAL_ERROR "The required libstdsupc++.a is missing in your standalone toolchain. + Usually it happens because of bug in make-standalone-toolchain.sh script from NDK r7, r7b and r7c. + You need to either upgrade to newer NDK or manually copy + $ANDROID_NDK/sources/cxx-stl/gnu-libstdc++/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a + to + ${__libsupcxx} + " ) + endif() + if( ANDROID_STL STREQUAL "gnustl_shared" ) + if( ARMEABI_V7A AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libgnustl_shared.so" ) + set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libgnustl_shared.so" ) + elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libgnustl_shared.so" ) + set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libgnustl_shared.so" ) + elseif( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libgnustl_shared.so" ) + set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libgnustl_shared.so" ) + endif() + endif() + endif() +endif() + +# clang +if( "${ANDROID_TOOLCHAIN_NAME}" STREQUAL "standalone-clang" ) + set( ANDROID_COMPILER_IS_CLANG 1 ) + execute_process( COMMAND "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/clang${TOOL_OS_SUFFIX}" --version OUTPUT_VARIABLE ANDROID_CLANG_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE ) + string( REGEX MATCH "[0-9]+[.][0-9]+" ANDROID_CLANG_VERSION "${ANDROID_CLANG_VERSION}") +elseif( "${ANDROID_TOOLCHAIN_NAME}" MATCHES "-clang3[.][0-9]?$" ) + string( REGEX MATCH "3[.][0-9]$" ANDROID_CLANG_VERSION "${ANDROID_TOOLCHAIN_NAME}") + string( REGEX REPLACE "-clang${ANDROID_CLANG_VERSION}$" "-${ANDROID_COMPILER_VERSION}" ANDROID_GCC_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}" ) + if( NOT EXISTS "${ANDROID_NDK_TOOLCHAINS_PATH}/llvm-${ANDROID_CLANG_VERSION}${ANDROID_NDK_TOOLCHAINS_SUBPATH}/bin/clang${TOOL_OS_SUFFIX}" ) + message( FATAL_ERROR "Could not find the Clang compiler driver" ) + endif() + set( ANDROID_COMPILER_IS_CLANG 1 ) + set( ANDROID_CLANG_TOOLCHAIN_ROOT "${ANDROID_NDK_TOOLCHAINS_PATH}/llvm-${ANDROID_CLANG_VERSION}${ANDROID_NDK_TOOLCHAINS_SUBPATH}" ) +else() + set( ANDROID_GCC_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}" ) + unset( ANDROID_COMPILER_IS_CLANG CACHE ) +endif() + +string( REPLACE "." "" _clang_name "clang${ANDROID_CLANG_VERSION}" ) +if( NOT EXISTS "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}${TOOL_OS_SUFFIX}" ) + set( _clang_name "clang" ) +endif() + + +# setup paths and STL for NDK +if( BUILD_WITH_ANDROID_NDK ) + set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_GCC_TOOLCHAIN_NAME}${ANDROID_NDK_TOOLCHAINS_SUBPATH}" ) + set( ANDROID_SYSROOT "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}" ) + + if( ANDROID_STL STREQUAL "none" ) + # do nothing + elseif( ANDROID_STL STREQUAL "system" ) + set( ANDROID_RTTI OFF ) + set( ANDROID_EXCEPTIONS OFF ) + set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/system/include" ) + elseif( ANDROID_STL STREQUAL "system_re" ) + set( ANDROID_RTTI ON ) + set( ANDROID_EXCEPTIONS ON ) + set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/system/include" ) + elseif( ANDROID_STL MATCHES "gabi" ) + if( ANDROID_NDK_RELEASE_NUM LESS 7000 ) # before r7 + message( FATAL_ERROR "gabi++ is not available in your NDK. You have to upgrade to NDK r7 or newer to use gabi++.") + endif() + set( ANDROID_RTTI ON ) + set( ANDROID_EXCEPTIONS OFF ) + set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/gabi++/include" ) + set( __libstl "${ANDROID_NDK}/sources/cxx-stl/gabi++/libs/${ANDROID_NDK_ABI_NAME}/libgabi++_static.a" ) + elseif( ANDROID_STL MATCHES "stlport" ) + if( NOT ANDROID_NDK_RELEASE_NUM LESS 8004 ) # before r8d + set( ANDROID_EXCEPTIONS ON ) + else() + set( ANDROID_EXCEPTIONS OFF ) + endif() + if( ANDROID_NDK_RELEASE_NUM LESS 7000 ) # before r7 + set( ANDROID_RTTI OFF ) + else() + set( ANDROID_RTTI ON ) + endif() + set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/stlport/stlport" ) + set( __libstl "${ANDROID_NDK}/sources/cxx-stl/stlport/libs/${ANDROID_NDK_ABI_NAME}/libstlport_static.a" ) + elseif( ANDROID_STL MATCHES "gnustl" ) + set( ANDROID_EXCEPTIONS ON ) + set( ANDROID_RTTI ON ) + if( EXISTS "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}" ) + if( ARMEABI_V7A AND ANDROID_COMPILER_VERSION VERSION_EQUAL "4.7" AND ANDROID_NDK_RELEASE STREQUAL "r8d" ) + # gnustl binary for 4.7 compiler is buggy :( + # TODO: look for right fix + set( __libstl "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/4.6" ) + else() + set( __libstl "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}" ) + endif() + else() + set( __libstl "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++" ) + endif() + set( ANDROID_STL_INCLUDE_DIRS "${__libstl}/include" "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/include" "${__libstl}/include/backward" ) + if( EXISTS "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libgnustl_static.a" ) + set( __libstl "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libgnustl_static.a" ) + else() + set( __libstl "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libstdc++.a" ) + endif() + elseif( ANDROID_STL MATCHES "c\\+\\+_shared" ) + set( ANDROID_EXCEPTIONS ON ) + set( ANDROID_RTTI ON ) + set( ANDROID_CXX_ROOT "${ANDROID_NDK}/sources/cxx-stl/" ) + set( ANDROID_LLVM_ROOT "${ANDROID_CXX_ROOT}/llvm-libc++" ) + if( X86 ) + set( ANDROID_ABI_INCLUDE_DIRS "${ANDROID_CXX_ROOT}/gabi++/include" ) + else() + set( ANDROID_ABI_INCLUDE_DIRS "${ANDROID_CXX_ROOT}/llvm-libc++abi/libcxxabi/include" ) + endif() + set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources" "${ANDROID_LLVM_ROOT}/libcxx/include" "${ANDROID_ABI_INCLUDE_DIRS}" ) + # android support files + include_directories ( SYSTEM ${ANDROID_NDK}/sources/android/support/include ) + if( EXISTS "${ANDROID_LLVM_ROOT}/libs/${ANDROID_NDK_ABI_NAME}/libc++_shared.so" ) + set( __libstl "${ANDROID_LLVM_ROOT}/libs/${ANDROID_NDK_ABI_NAME}/libc++_shared.so" ) + else() + message( "c++ shared library doesn't exist" ) + endif() + else() + message( FATAL_ERROR "Unknown runtime: ${ANDROID_STL}" ) + endif() + # find libsupc++.a - rtti & exceptions + if( ANDROID_STL STREQUAL "system_re" OR ANDROID_STL MATCHES "gnustl" ) + set( __libsupcxx "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" ) # r8b or newer + if( NOT EXISTS "${__libsupcxx}" ) + set( __libsupcxx "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" ) # r7-r8 + endif() + if( NOT EXISTS "${__libsupcxx}" ) # before r7 + if( ARMEABI_V7A ) + if( ANDROID_FORCE_ARM_BUILD ) + set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libsupc++.a" ) + else() + set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libsupc++.a" ) + endif() + elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD ) + set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libsupc++.a" ) + else() + set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libsupc++.a" ) + endif() + endif() + if( NOT EXISTS "${__libsupcxx}") + message( ERROR "Could not find libsupc++.a for a chosen platform. Either your NDK is not supported or is broken.") + endif() + endif() +endif() + + +# case of shared STL linkage +if( ANDROID_STL MATCHES "shared" AND DEFINED __libstl ) + string( REPLACE "_static.a" "_shared.so" __libstl "${__libstl}" ) + # TODO: check if .so file exists before the renaming +endif() + + +# ccache support +__INIT_VARIABLE( _ndk_ccache NDK_CCACHE ENV_NDK_CCACHE ) +if( _ndk_ccache ) + if( DEFINED NDK_CCACHE AND NOT EXISTS NDK_CCACHE ) + unset( NDK_CCACHE CACHE ) + endif() + find_program( NDK_CCACHE "${_ndk_ccache}" DOC "The path to ccache binary") +else() + unset( NDK_CCACHE CACHE ) +endif() +unset( _ndk_ccache ) + + +# setup the cross-compiler +if( NOT CMAKE_C_COMPILER ) + if( NDK_CCACHE AND NOT ANDROID_SYSROOT MATCHES "[ ;\"]" ) + set( CMAKE_C_COMPILER "${NDK_CCACHE}" CACHE PATH "ccache as C compiler" ) + set( CMAKE_CXX_COMPILER "${NDK_CCACHE}" CACHE PATH "ccache as C++ compiler" ) + if( ANDROID_COMPILER_IS_CLANG ) + set( CMAKE_C_COMPILER_ARG1 "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}${TOOL_OS_SUFFIX}" CACHE PATH "C compiler") + set( CMAKE_CXX_COMPILER_ARG1 "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler") + else() + set( CMAKE_C_COMPILER_ARG1 "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}" CACHE PATH "C compiler") + set( CMAKE_CXX_COMPILER_ARG1 "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler") + endif() + else() + if( ANDROID_COMPILER_IS_CLANG ) + set( CMAKE_C_COMPILER "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}${TOOL_OS_SUFFIX}" CACHE PATH "C compiler") + set( CMAKE_CXX_COMPILER "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler") + else() + set( CMAKE_C_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}" CACHE PATH "C compiler" ) + set( CMAKE_CXX_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler" ) + endif() + endif() + set( CMAKE_ASM_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}" CACHE PATH "assembler" ) + set( CMAKE_STRIP "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-strip${TOOL_OS_SUFFIX}" CACHE PATH "strip" ) + if( EXISTS "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc-ar${TOOL_OS_SUFFIX}" ) + # Use gcc-ar if we have it for better LTO support. + set( CMAKE_AR "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc-ar${TOOL_OS_SUFFIX}" CACHE PATH "archive" ) + else() + set( CMAKE_AR "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ar${TOOL_OS_SUFFIX}" CACHE PATH "archive" ) + endif() + set( CMAKE_LINKER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ld${TOOL_OS_SUFFIX}" CACHE PATH "linker" ) + set( CMAKE_NM "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-nm${TOOL_OS_SUFFIX}" CACHE PATH "nm" ) + set( CMAKE_OBJCOPY "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-objcopy${TOOL_OS_SUFFIX}" CACHE PATH "objcopy" ) + set( CMAKE_OBJDUMP "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-objdump${TOOL_OS_SUFFIX}" CACHE PATH "objdump" ) + set( CMAKE_RANLIB "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ranlib${TOOL_OS_SUFFIX}" CACHE PATH "ranlib" ) +endif() + +set( _CMAKE_TOOLCHAIN_PREFIX "${ANDROID_TOOLCHAIN_MACHINE_NAME}-" ) +if( CMAKE_VERSION VERSION_LESS 2.8.5 ) + set( CMAKE_ASM_COMPILER_ARG1 "-c" ) +endif() +if( APPLE ) + find_program( CMAKE_INSTALL_NAME_TOOL NAMES install_name_tool ) + if( NOT CMAKE_INSTALL_NAME_TOOL ) + message( FATAL_ERROR "Could not find install_name_tool, please check your installation." ) + endif() + mark_as_advanced( CMAKE_INSTALL_NAME_TOOL ) +endif() + +# Force set compilers because standard identification works badly for us +include( CMakeForceCompiler ) +CMAKE_FORCE_C_COMPILER( "${CMAKE_C_COMPILER}" GNU ) +if( ANDROID_COMPILER_IS_CLANG ) + set( CMAKE_C_COMPILER_ID Clang ) +endif() +set( CMAKE_C_PLATFORM_ID Linux ) +if( X86_64 OR MIPS64 OR ARM64_V8A ) + set( CMAKE_C_SIZEOF_DATA_PTR 8 ) +else() + set( CMAKE_C_SIZEOF_DATA_PTR 4 ) +endif() +set( CMAKE_C_HAS_ISYSROOT 1 ) +set( CMAKE_C_COMPILER_ABI ELF ) +CMAKE_FORCE_CXX_COMPILER( "${CMAKE_CXX_COMPILER}" GNU ) +if( ANDROID_COMPILER_IS_CLANG ) + set( CMAKE_CXX_COMPILER_ID Clang) +endif() +set( CMAKE_CXX_PLATFORM_ID Linux ) +set( CMAKE_CXX_SIZEOF_DATA_PTR ${CMAKE_C_SIZEOF_DATA_PTR} ) +set( CMAKE_CXX_HAS_ISYSROOT 1 ) +set( CMAKE_CXX_COMPILER_ABI ELF ) +set( CMAKE_CXX_SOURCE_FILE_EXTENSIONS cc cp cxx cpp CPP c++ C ) +# force ASM compiler (required for CMake < 2.8.5) +set( CMAKE_ASM_COMPILER_ID_RUN TRUE ) +set( CMAKE_ASM_COMPILER_ID GNU ) +set( CMAKE_ASM_COMPILER_WORKS TRUE ) +set( CMAKE_ASM_COMPILER_FORCED TRUE ) +set( CMAKE_COMPILER_IS_GNUASM 1) +set( CMAKE_ASM_SOURCE_FILE_EXTENSIONS s S asm ) + +foreach( lang C CXX ASM ) + if( ANDROID_COMPILER_IS_CLANG ) + set( CMAKE_${lang}_COMPILER_VERSION ${ANDROID_CLANG_VERSION} ) + else() + set( CMAKE_${lang}_COMPILER_VERSION ${ANDROID_COMPILER_VERSION} ) + endif() +endforeach() + +# flags and definitions +remove_definitions( -DANDROID ) +add_definitions( -DANDROID ) + +if( ANDROID_SYSROOT MATCHES "[ ;\"]" ) + if( CMAKE_HOST_WIN32 ) + # try to convert path to 8.3 form + file( WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/cvt83.cmd" "@echo %~s1" ) + execute_process( COMMAND "$ENV{ComSpec}" /c "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/cvt83.cmd" "${ANDROID_SYSROOT}" + OUTPUT_VARIABLE __path OUTPUT_STRIP_TRAILING_WHITESPACE + RESULT_VARIABLE __result ERROR_QUIET ) + if( __result EQUAL 0 ) + file( TO_CMAKE_PATH "${__path}" ANDROID_SYSROOT ) + set( ANDROID_CXX_FLAGS "--sysroot=${ANDROID_SYSROOT}" ) + else() + set( ANDROID_CXX_FLAGS "--sysroot=\"${ANDROID_SYSROOT}\"" ) + endif() + else() + set( ANDROID_CXX_FLAGS "'--sysroot=${ANDROID_SYSROOT}'" ) + endif() + if( NOT _CMAKE_IN_TRY_COMPILE ) + # quotes can break try_compile and compiler identification + message(WARNING "Path to your Android NDK (or toolchain) has non-alphanumeric symbols.\nThe build might be broken.\n") + endif() +else() + set( ANDROID_CXX_FLAGS "--sysroot=${ANDROID_SYSROOT}" ) +endif() + +# NDK flags +if (ARM64_V8A ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -funwind-tables" ) + set( ANDROID_CXX_FLAGS_RELEASE "-fomit-frame-pointer -fstrict-aliasing" ) + set( ANDROID_CXX_FLAGS_DEBUG "-fno-omit-frame-pointer -fno-strict-aliasing" ) + if( NOT ANDROID_COMPILER_IS_CLANG ) + set( ANDROID_CXX_FLAGS_RELEASE "${ANDROID_CXX_FLAGS_RELEASE} -funswitch-loops -finline-limit=300" ) + endif() +elseif( ARMEABI OR ARMEABI_V7A) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -funwind-tables" ) + if( NOT ANDROID_FORCE_ARM_BUILD AND NOT ARMEABI_V6 ) + set( ANDROID_CXX_FLAGS_RELEASE "-mthumb -fomit-frame-pointer -fno-strict-aliasing" ) + set( ANDROID_CXX_FLAGS_DEBUG "-marm -fno-omit-frame-pointer -fno-strict-aliasing" ) + if( NOT ANDROID_COMPILER_IS_CLANG ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -finline-limit=64" ) + endif() + else() + # always compile ARMEABI_V6 in arm mode; otherwise there is no difference from ARMEABI + set( ANDROID_CXX_FLAGS_RELEASE "-marm -fomit-frame-pointer -fstrict-aliasing" ) + set( ANDROID_CXX_FLAGS_DEBUG "-marm -fno-omit-frame-pointer -fno-strict-aliasing" ) + if( NOT ANDROID_COMPILER_IS_CLANG ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -funswitch-loops -finline-limit=300" ) + endif() + endif() +elseif( X86 OR X86_64 ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -funwind-tables" ) + if( NOT ANDROID_COMPILER_IS_CLANG ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -funswitch-loops -finline-limit=300" ) + endif() + set( ANDROID_CXX_FLAGS_RELEASE "-fomit-frame-pointer -fstrict-aliasing" ) + set( ANDROID_CXX_FLAGS_DEBUG "-fno-omit-frame-pointer -fno-strict-aliasing" ) +elseif( MIPS OR MIPS64 ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -fno-strict-aliasing -finline-functions -funwind-tables -fmessage-length=0" ) + set( ANDROID_CXX_FLAGS_RELEASE "-fomit-frame-pointer" ) + set( ANDROID_CXX_FLAGS_DEBUG "-fno-omit-frame-pointer" ) + if( NOT ANDROID_COMPILER_IS_CLANG ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -fno-inline-functions-called-once -fgcse-after-reload -frerun-cse-after-loop -frename-registers" ) + set( ANDROID_CXX_FLAGS_RELEASE "${ANDROID_CXX_FLAGS_RELEASE} -funswitch-loops -finline-limit=300" ) + endif() +elseif() + set( ANDROID_CXX_FLAGS_RELEASE "" ) + set( ANDROID_CXX_FLAGS_DEBUG "" ) +endif() + +set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -fsigned-char" ) # good/necessary when porting desktop libraries + +if( NOT X86 AND NOT ANDROID_COMPILER_IS_CLANG ) + set( ANDROID_CXX_FLAGS "-Wno-psabi ${ANDROID_CXX_FLAGS}" ) +endif() + +if( NOT ANDROID_COMPILER_VERSION VERSION_LESS "4.6" ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -no-canonical-prefixes" ) # see https://android-review.googlesource.com/#/c/47564/ +endif() + +# ABI-specific flags +if( ARMEABI_V7A ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv7-a -mfloat-abi=softfp" ) + if( NEON ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=neon" ) + elseif( VFPV3 ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfpv3" ) + else() + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfpv3-d16" ) + endif() +elseif( ARMEABI_V6 ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv6 -mfloat-abi=softfp -mfpu=vfp" ) # vfp == vfpv2 +elseif( ARMEABI ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv5te -mtune=xscale -msoft-float" ) +endif() + +if( ANDROID_STL MATCHES "gnustl" AND (EXISTS "${__libstl}" OR EXISTS "${__libsupcxx}") ) + set( CMAKE_CXX_CREATE_SHARED_LIBRARY " -o " ) + set( CMAKE_CXX_CREATE_SHARED_MODULE " -o " ) + set( CMAKE_CXX_LINK_EXECUTABLE " -o " ) +else() + set( CMAKE_CXX_CREATE_SHARED_LIBRARY " -o " ) + set( CMAKE_CXX_CREATE_SHARED_MODULE " -o " ) + set( CMAKE_CXX_LINK_EXECUTABLE " -o " ) +endif() + +# STL +if( EXISTS "${__libstl}" OR EXISTS "${__libsupcxx}" ) + if( EXISTS "${__libstl}" ) + set( CMAKE_CXX_CREATE_SHARED_LIBRARY "${CMAKE_CXX_CREATE_SHARED_LIBRARY} \"${__libstl}\"" ) + set( CMAKE_CXX_CREATE_SHARED_MODULE "${CMAKE_CXX_CREATE_SHARED_MODULE} \"${__libstl}\"" ) + set( CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_CXX_LINK_EXECUTABLE} \"${__libstl}\"" ) + endif() + if( EXISTS "${__libsupcxx}" ) + set( CMAKE_CXX_CREATE_SHARED_LIBRARY "${CMAKE_CXX_CREATE_SHARED_LIBRARY} \"${__libsupcxx}\"" ) + set( CMAKE_CXX_CREATE_SHARED_MODULE "${CMAKE_CXX_CREATE_SHARED_MODULE} \"${__libsupcxx}\"" ) + set( CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_CXX_LINK_EXECUTABLE} \"${__libsupcxx}\"" ) + # C objects: + set( CMAKE_C_CREATE_SHARED_LIBRARY " -o " ) + set( CMAKE_C_CREATE_SHARED_MODULE " -o " ) + set( CMAKE_C_LINK_EXECUTABLE " -o " ) + set( CMAKE_C_CREATE_SHARED_LIBRARY "${CMAKE_C_CREATE_SHARED_LIBRARY} \"${__libsupcxx}\"" ) + set( CMAKE_C_CREATE_SHARED_MODULE "${CMAKE_C_CREATE_SHARED_MODULE} \"${__libsupcxx}\"" ) + set( CMAKE_C_LINK_EXECUTABLE "${CMAKE_C_LINK_EXECUTABLE} \"${__libsupcxx}\"" ) + endif() + if( ANDROID_STL MATCHES "gnustl" ) + if( NOT EXISTS "${ANDROID_LIBM_PATH}" ) + set( ANDROID_LIBM_PATH -lm ) + endif() + set( CMAKE_CXX_CREATE_SHARED_LIBRARY "${CMAKE_CXX_CREATE_SHARED_LIBRARY} ${ANDROID_LIBM_PATH}" ) + set( CMAKE_CXX_CREATE_SHARED_MODULE "${CMAKE_CXX_CREATE_SHARED_MODULE} ${ANDROID_LIBM_PATH}" ) + set( CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_CXX_LINK_EXECUTABLE} ${ANDROID_LIBM_PATH}" ) + endif() +endif() + +# variables controlling optional build flags +if( ANDROID_NDK_RELEASE_NUM LESS 7000 ) # before r7 + # libGLESv2.so in NDK's prior to r7 refers to missing external symbols. + # So this flag option is required for all projects using OpenGL from native. + __INIT_VARIABLE( ANDROID_SO_UNDEFINED VALUES ON ) +else() + __INIT_VARIABLE( ANDROID_SO_UNDEFINED VALUES OFF ) +endif() +__INIT_VARIABLE( ANDROID_NO_UNDEFINED VALUES ON ) +__INIT_VARIABLE( ANDROID_FUNCTION_LEVEL_LINKING VALUES ON ) +__INIT_VARIABLE( ANDROID_GOLD_LINKER VALUES ON ) +__INIT_VARIABLE( ANDROID_NOEXECSTACK VALUES ON ) +__INIT_VARIABLE( ANDROID_RELRO VALUES ON ) + +set( ANDROID_NO_UNDEFINED ${ANDROID_NO_UNDEFINED} CACHE BOOL "Show all undefined symbols as linker errors" ) +set( ANDROID_SO_UNDEFINED ${ANDROID_SO_UNDEFINED} CACHE BOOL "Allows or disallows undefined symbols in shared libraries" ) +set( ANDROID_FUNCTION_LEVEL_LINKING ${ANDROID_FUNCTION_LEVEL_LINKING} CACHE BOOL "Put each function in separate section and enable garbage collection of unused input sections at link time" ) +set( ANDROID_GOLD_LINKER ${ANDROID_GOLD_LINKER} CACHE BOOL "Enables gold linker" ) +set( ANDROID_NOEXECSTACK ${ANDROID_NOEXECSTACK} CACHE BOOL "Allows or disallows undefined symbols in shared libraries" ) +set( ANDROID_RELRO ${ANDROID_RELRO} CACHE BOOL "Enables RELRO - a memory corruption mitigation technique" ) +mark_as_advanced( ANDROID_NO_UNDEFINED ANDROID_SO_UNDEFINED ANDROID_FUNCTION_LEVEL_LINKING ANDROID_GOLD_LINKER ANDROID_NOEXECSTACK ANDROID_RELRO ) + +# linker flags +set( ANDROID_LINKER_FLAGS "" ) + +if( ARMEABI_V7A ) + # this is *required* to use the following linker flags that routes around + # a CPU bug in some Cortex-A8 implementations: + set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--fix-cortex-a8" ) +endif() + +if( ANDROID_NO_UNDEFINED ) + if( MIPS ) + # there is some sysroot-related problem in mips linker... + if( NOT ANDROID_SYSROOT MATCHES "[ ;\"]" ) + set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--no-undefined -Wl,-rpath-link,${ANDROID_SYSROOT}/usr/lib" ) + endif() + else() + set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--no-undefined" ) + endif() +endif() + +if( ANDROID_SO_UNDEFINED ) + set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,-allow-shlib-undefined" ) +endif() + +if( ANDROID_FUNCTION_LEVEL_LINKING ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -fdata-sections -ffunction-sections" ) + set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--gc-sections" ) +endif() + +if( ANDROID_COMPILER_VERSION VERSION_EQUAL "4.6" ) + if( ANDROID_GOLD_LINKER AND (CMAKE_HOST_UNIX OR ANDROID_NDK_RELEASE_NUM GREATER 8002) AND (ARMEABI OR ARMEABI_V7A OR X86) ) + set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -fuse-ld=gold" ) + elseif( ANDROID_NDK_RELEASE_NUM GREATER 8002 ) # after r8b + set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -fuse-ld=bfd" ) + elseif( ANDROID_NDK_RELEASE STREQUAL "r8b" AND ARMEABI AND NOT _CMAKE_IN_TRY_COMPILE ) + message( WARNING "The default bfd linker from arm GCC 4.6 toolchain can fail with 'unresolvable R_ARM_THM_CALL relocation' error message. See https://code.google.com/p/android/issues/detail?id=35342 + On Linux and OS X host platform you can workaround this problem using gold linker (default). + Rerun cmake with -DANDROID_GOLD_LINKER=ON option in case of problems. +" ) + endif() +endif() # version 4.6 + +if( ANDROID_NOEXECSTACK ) + if( ANDROID_COMPILER_IS_CLANG ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -Xclang -mnoexecstack" ) + else() + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -Wa,--noexecstack" ) + endif() + set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,-z,noexecstack" ) +endif() + +if( ANDROID_RELRO ) + set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,-z,relro -Wl,-z,now" ) +endif() + +if( ANDROID_COMPILER_IS_CLANG ) + set( ANDROID_CXX_FLAGS "-target ${ANDROID_LLVM_TRIPLE} -Qunused-arguments ${ANDROID_CXX_FLAGS}" ) + if( BUILD_WITH_ANDROID_NDK ) + set( ANDROID_CXX_FLAGS "-gcc-toolchain ${ANDROID_TOOLCHAIN_ROOT} ${ANDROID_CXX_FLAGS}" ) + endif() +endif() + +# cache flags +set( CMAKE_CXX_FLAGS "" CACHE STRING "c++ flags" ) +set( CMAKE_C_FLAGS "" CACHE STRING "c flags" ) +set( CMAKE_CXX_FLAGS_RELEASE "-Os -DNDEBUG" CACHE STRING "c++ Release flags" ) +set( CMAKE_C_FLAGS_RELEASE "-Os -DNDEBUG" CACHE STRING "c Release flags" ) +set( CMAKE_CXX_FLAGS_DEBUG "-O0 -g -DDEBUG -D_DEBUG" CACHE STRING "c++ Debug flags" ) +set( CMAKE_C_FLAGS_DEBUG "-O0 -g -DDEBUG -D_DEBUG" CACHE STRING "c Debug flags" ) +set( CMAKE_SHARED_LINKER_FLAGS "-Wl,--gc-sections" CACHE STRING "shared linker flags" ) +set( CMAKE_MODULE_LINKER_FLAGS "" CACHE STRING "module linker flags" ) +set( CMAKE_EXE_LINKER_FLAGS "-Wl,-z,nocopyreloc" CACHE STRING "executable linker flags" ) + +# put flags to cache (for debug purpose only) +set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS}" CACHE INTERNAL "Android specific c/c++ flags" ) +set( ANDROID_CXX_FLAGS_RELEASE "${ANDROID_CXX_FLAGS_RELEASE}" CACHE INTERNAL "Android specific c/c++ Release flags" ) +set( ANDROID_CXX_FLAGS_DEBUG "${ANDROID_CXX_FLAGS_DEBUG}" CACHE INTERNAL "Android specific c/c++ Debug flags" ) +set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS}" CACHE INTERNAL "Android specific c/c++ linker flags" ) + +# finish flags +set( CMAKE_CXX_FLAGS "${ANDROID_CXX_FLAGS} ${CMAKE_CXX_FLAGS}" ) +set( CMAKE_C_FLAGS "${ANDROID_CXX_FLAGS} ${CMAKE_C_FLAGS}" ) +set( CMAKE_CXX_FLAGS_RELEASE "${ANDROID_CXX_FLAGS_RELEASE} ${CMAKE_CXX_FLAGS_RELEASE}" ) +set( CMAKE_C_FLAGS_RELEASE "${ANDROID_CXX_FLAGS_RELEASE} ${CMAKE_C_FLAGS_RELEASE}" ) +set( CMAKE_CXX_FLAGS_DEBUG "${ANDROID_CXX_FLAGS_DEBUG} ${CMAKE_CXX_FLAGS_DEBUG}" ) +set( CMAKE_C_FLAGS_DEBUG "${ANDROID_CXX_FLAGS_DEBUG} ${CMAKE_C_FLAGS_DEBUG}" ) +set( CMAKE_SHARED_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}" ) +set( CMAKE_MODULE_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}" ) +set( CMAKE_EXE_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}" ) + +if( MIPS AND BUILD_WITH_ANDROID_NDK AND ANDROID_NDK_RELEASE STREQUAL "r8" ) + set( CMAKE_SHARED_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_GCC_TOOLCHAIN_NAME}/mipself.xsc ${CMAKE_SHARED_LINKER_FLAGS}" ) + set( CMAKE_MODULE_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_GCC_TOOLCHAIN_NAME}/mipself.xsc ${CMAKE_MODULE_LINKER_FLAGS}" ) + set( CMAKE_EXE_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_GCC_TOOLCHAIN_NAME}/mipself.x ${CMAKE_EXE_LINKER_FLAGS}" ) +endif() + +# pie/pic +if( NOT (ANDROID_NATIVE_API_LEVEL LESS 16) AND (NOT DEFINED ANDROID_APP_PIE OR ANDROID_APP_PIE) AND (CMAKE_VERSION VERSION_GREATER 2.8.8) ) + set( CMAKE_POSITION_INDEPENDENT_CODE TRUE ) + set( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fPIE -pie") +else() + set( CMAKE_POSITION_INDEPENDENT_CODE FALSE ) + set( CMAKE_CXX_FLAGS "-fpic ${CMAKE_CXX_FLAGS}" ) + set( CMAKE_C_FLAGS "-fpic ${CMAKE_C_FLAGS}" ) +endif() + +# configure rtti +if( DEFINED ANDROID_RTTI AND ANDROID_STL_FORCE_FEATURES ) + if( ANDROID_RTTI ) + set( CMAKE_CXX_FLAGS "-frtti ${CMAKE_CXX_FLAGS}" ) + else() + set( CMAKE_CXX_FLAGS "-fno-rtti ${CMAKE_CXX_FLAGS}" ) + endif() +endif() + +# configure exceptios +if( DEFINED ANDROID_EXCEPTIONS AND ANDROID_STL_FORCE_FEATURES ) + if( ANDROID_EXCEPTIONS ) + set( CMAKE_CXX_FLAGS "-fexceptions ${CMAKE_CXX_FLAGS}" ) + set( CMAKE_C_FLAGS "-fexceptions ${CMAKE_C_FLAGS}" ) + else() + set( CMAKE_CXX_FLAGS "-fno-exceptions ${CMAKE_CXX_FLAGS}" ) + set( CMAKE_C_FLAGS "-fno-exceptions ${CMAKE_C_FLAGS}" ) + endif() +endif() + +# global includes and link directories +include_directories( SYSTEM "${ANDROID_SYSROOT}/usr/include" "${ANDROID_SYSROOT}/usr/include/machine" ${ANDROID_STL_INCLUDE_DIRS} ) +get_filename_component(__android_install_path "${CMAKE_INSTALL_PREFIX}/libs/${ANDROID_NDK_ABI_NAME}" ABSOLUTE) # avoid CMP0015 policy warning +link_directories( "${__android_install_path}" ) + +# detect if need link crtbegin_so.o explicitly +if( NOT DEFINED ANDROID_EXPLICIT_CRT_LINK ) + set( __cmd "${CMAKE_CXX_CREATE_SHARED_LIBRARY}" ) + string( REPLACE "" "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}" __cmd "${__cmd}" ) + string( REPLACE "" "${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}" __cmd "${__cmd}" ) + string( REPLACE "" "${CMAKE_CXX_FLAGS}" __cmd "${__cmd}" ) + string( REPLACE "" "" __cmd "${__cmd}" ) + string( REPLACE "" "${CMAKE_SHARED_LINKER_FLAGS}" __cmd "${__cmd}" ) + string( REPLACE "" "-shared" __cmd "${__cmd}" ) + string( REPLACE "" "" __cmd "${__cmd}" ) + string( REPLACE "" "" __cmd "${__cmd}" ) + string( REPLACE "" "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/toolchain_crtlink_test.so" __cmd "${__cmd}" ) + string( REPLACE "" "\"${ANDROID_SYSROOT}/usr/lib/crtbegin_so.o\"" __cmd "${__cmd}" ) + string( REPLACE "" "" __cmd "${__cmd}" ) + separate_arguments( __cmd ) + foreach( __var ANDROID_NDK ANDROID_NDK_TOOLCHAINS_PATH ANDROID_STANDALONE_TOOLCHAIN ) + if( ${__var} ) + set( __tmp "${${__var}}" ) + separate_arguments( __tmp ) + string( REPLACE "${__tmp}" "${${__var}}" __cmd "${__cmd}") + endif() + endforeach() + string( REPLACE "'" "" __cmd "${__cmd}" ) + string( REPLACE "\"" "" __cmd "${__cmd}" ) + execute_process( COMMAND ${__cmd} RESULT_VARIABLE __cmd_result OUTPUT_QUIET ERROR_QUIET ) + if( __cmd_result EQUAL 0 ) + set( ANDROID_EXPLICIT_CRT_LINK ON ) + else() + set( ANDROID_EXPLICIT_CRT_LINK OFF ) + endif() +endif() + +if( ANDROID_EXPLICIT_CRT_LINK ) + set( CMAKE_CXX_CREATE_SHARED_LIBRARY "${CMAKE_CXX_CREATE_SHARED_LIBRARY} \"${ANDROID_SYSROOT}/usr/lib/crtbegin_so.o\"" ) + set( CMAKE_CXX_CREATE_SHARED_MODULE "${CMAKE_CXX_CREATE_SHARED_MODULE} \"${ANDROID_SYSROOT}/usr/lib/crtbegin_so.o\"" ) +endif() + +# setup output directories +set( CMAKE_INSTALL_PREFIX "${ANDROID_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" ) + +if( DEFINED LIBRARY_OUTPUT_PATH_ROOT + OR EXISTS "${CMAKE_SOURCE_DIR}/AndroidManifest.xml" + OR (EXISTS "${CMAKE_SOURCE_DIR}/../AndroidManifest.xml" AND EXISTS "${CMAKE_SOURCE_DIR}/../jni/") ) + set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "Root for binaries output, set this to change where Android libs are installed to" ) + if( NOT _CMAKE_IN_TRY_COMPILE ) + if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" ) + set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ANDROID_NDK_ABI_NAME}" CACHE PATH "Output directory for applications" ) + else() + set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications" ) + endif() + set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}" CACHE PATH "Output directory for Android libs" ) + endif() +endif() + +# copy shaed stl library to build directory +if( NOT _CMAKE_IN_TRY_COMPILE AND __libstl MATCHES "[.]so$" AND DEFINED LIBRARY_OUTPUT_PATH ) + get_filename_component( __libstlname "${__libstl}" NAME ) + execute_process( COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${__libstl}" "${LIBRARY_OUTPUT_PATH}/${__libstlname}" RESULT_VARIABLE __fileCopyProcess ) + if( NOT __fileCopyProcess EQUAL 0 OR NOT EXISTS "${LIBRARY_OUTPUT_PATH}/${__libstlname}") + message( SEND_ERROR "Failed copying of ${__libstl} to the ${LIBRARY_OUTPUT_PATH}/${__libstlname}" ) + endif() + unset( __fileCopyProcess ) + unset( __libstlname ) +endif() + + +# set these global flags for cmake client scripts to change behavior +set( ANDROID True ) +set( BUILD_ANDROID True ) + +# where is the target environment +set( CMAKE_FIND_ROOT_PATH "${ANDROID_TOOLCHAIN_ROOT}/bin" "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}" "${ANDROID_SYSROOT}" "${CMAKE_INSTALL_PREFIX}" "${CMAKE_INSTALL_PREFIX}/share" ) + +# only search for libraries and includes in the ndk toolchain +set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY ) +set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY ) +set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY ) + + +# macro to find packages on the host OS +macro( find_host_package ) + set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER ) + set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER ) + set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER ) + if( CMAKE_HOST_WIN32 ) + SET( WIN32 1 ) + SET( UNIX ) + elseif( CMAKE_HOST_APPLE ) + SET( APPLE 1 ) + SET( UNIX ) + endif() + find_package( ${ARGN} ) + SET( WIN32 ) + SET( APPLE ) + SET( UNIX 1 ) + set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY ) + set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY ) + set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY ) +endmacro() + + +# macro to find programs on the host OS +macro( find_host_program ) + set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER ) + set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER ) + set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER ) + if( CMAKE_HOST_WIN32 ) + SET( WIN32 1 ) + SET( UNIX ) + elseif( CMAKE_HOST_APPLE ) + SET( APPLE 1 ) + SET( UNIX ) + endif() + find_program( ${ARGN} ) + SET( WIN32 ) + SET( APPLE ) + SET( UNIX 1 ) + set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY ) + set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY ) + set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY ) +endmacro() + + +# export toolchain settings for the try_compile() command +if( NOT _CMAKE_IN_TRY_COMPILE ) + set( __toolchain_config "") + foreach( __var NDK_CCACHE LIBRARY_OUTPUT_PATH_ROOT ANDROID_FORBID_SYGWIN + ANDROID_NDK_HOST_X64 + ANDROID_NDK + ANDROID_NDK_LAYOUT + ANDROID_STANDALONE_TOOLCHAIN + ANDROID_TOOLCHAIN_NAME + ANDROID_ABI + ANDROID_NATIVE_API_LEVEL + ANDROID_STL + ANDROID_STL_FORCE_FEATURES + ANDROID_FORCE_ARM_BUILD + ANDROID_NO_UNDEFINED + ANDROID_SO_UNDEFINED + ANDROID_FUNCTION_LEVEL_LINKING + ANDROID_GOLD_LINKER + ANDROID_NOEXECSTACK + ANDROID_RELRO + ANDROID_LIBM_PATH + ANDROID_EXPLICIT_CRT_LINK + ANDROID_APP_PIE + ) + if( DEFINED ${__var} ) + if( ${__var} MATCHES " ") + set( __toolchain_config "${__toolchain_config}set( ${__var} \"${${__var}}\" CACHE INTERNAL \"\" )\n" ) + else() + set( __toolchain_config "${__toolchain_config}set( ${__var} ${${__var}} CACHE INTERNAL \"\" )\n" ) + endif() + endif() + endforeach() + file( WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/android.toolchain.config.cmake" "${__toolchain_config}" ) + unset( __toolchain_config ) +endif() + + +# force cmake to produce / instead of \ in build commands for Ninja generator +if( CMAKE_GENERATOR MATCHES "Ninja" AND CMAKE_HOST_WIN32 ) + # it is a bad hack after all + # CMake generates Ninja makefiles with UNIX paths only if it thinks that we are going to build with MinGW + set( CMAKE_COMPILER_IS_MINGW TRUE ) # tell CMake that we are MinGW + set( CMAKE_CROSSCOMPILING TRUE ) # stop recursion + enable_language( C ) + enable_language( CXX ) + # unset( CMAKE_COMPILER_IS_MINGW ) # can't unset because CMake does not convert back-slashes in response files without it + unset( MINGW ) +endif() + + +# Variables controlling behavior or set by cmake toolchain: +# ANDROID_ABI : "armeabi-v7a" (default), "armeabi", "armeabi-v7a with NEON", "armeabi-v7a with VFPV3", "armeabi-v6 with VFP", "x86", "mips", "arm64-v8a", "x86_64", "mips64" +# ANDROID_NATIVE_API_LEVEL : 3,4,5,8,9,14,15,16,17,18,19,21 (depends on NDK version) +# ANDROID_STL : c++_shared/gnustl_static/gnustl_shared/stlport_static/stlport_shared/gabi++_static/gabi++_shared/system_re/system/none +# ANDROID_FORBID_SYGWIN : ON/OFF +# ANDROID_NO_UNDEFINED : ON/OFF +# ANDROID_SO_UNDEFINED : OFF/ON (default depends on NDK version) +# ANDROID_FUNCTION_LEVEL_LINKING : ON/OFF +# ANDROID_GOLD_LINKER : ON/OFF +# ANDROID_NOEXECSTACK : ON/OFF +# ANDROID_RELRO : ON/OFF +# ANDROID_FORCE_ARM_BUILD : ON/OFF +# ANDROID_STL_FORCE_FEATURES : ON/OFF +# ANDROID_LIBM_PATH : path to libm.so (set to something like $(TOP)/out/target/product//obj/lib/libm.so) to workaround unresolved `sincos` +# Can be set only at the first run: +# ANDROID_NDK : path to your NDK install +# NDK_CCACHE : path to your ccache executable +# ANDROID_TOOLCHAIN_NAME : the NDK name of compiler toolchain +# ANDROID_NDK_HOST_X64 : try to use x86_64 toolchain (default for x64 host systems) +# ANDROID_NDK_LAYOUT : the inner NDK structure (RELEASE, LINARO, ANDROID) +# LIBRARY_OUTPUT_PATH_ROOT : +# ANDROID_STANDALONE_TOOLCHAIN +# +# Primary read-only variables: +# ANDROID : always TRUE +# ARMEABI : TRUE for arm v6 and older devices +# ARMEABI_V6 : TRUE for arm v6 +# ARMEABI_V7A : TRUE for arm v7a +# ARM64_V8A : TRUE for arm64-v8a +# NEON : TRUE if NEON unit is enabled +# VFPV3 : TRUE if VFP version 3 is enabled +# X86 : TRUE if configured for x86 +# X86_64 : TRUE if configured for x86_64 +# MIPS : TRUE if configured for mips +# MIPS64 : TRUE if configured for mips64 +# BUILD_WITH_ANDROID_NDK : TRUE if NDK is used +# BUILD_WITH_STANDALONE_TOOLCHAIN : TRUE if standalone toolchain is used +# ANDROID_NDK_HOST_SYSTEM_NAME : "windows", "linux-x86" or "darwin-x86" depending on host platform +# ANDROID_NDK_ABI_NAME : "armeabi", "armeabi-v7a", "x86", "mips", "arm64-v8a", "x86_64", "mips64" depending on ANDROID_ABI +# ANDROID_NDK_RELEASE : from r5 to r10d; set only for NDK +# ANDROID_NDK_RELEASE_NUM : numeric ANDROID_NDK_RELEASE version (1000*major+minor) +# ANDROID_ARCH_NAME : "arm", "x86", "mips", "arm64", "x86_64", "mips64" depending on ANDROID_ABI +# ANDROID_SYSROOT : path to the compiler sysroot +# TOOL_OS_SUFFIX : "" or ".exe" depending on host platform +# ANDROID_COMPILER_IS_CLANG : TRUE if clang compiler is used +# +# Secondary (less stable) read-only variables: +# ANDROID_COMPILER_VERSION : GCC version used (not Clang version) +# ANDROID_CLANG_VERSION : version of clang compiler if clang is used +# ANDROID_CXX_FLAGS : C/C++ compiler flags required by Android platform +# ANDROID_SUPPORTED_ABIS : list of currently allowed values for ANDROID_ABI +# ANDROID_TOOLCHAIN_MACHINE_NAME : "arm-linux-androideabi", "arm-eabi" or "i686-android-linux" +# ANDROID_TOOLCHAIN_ROOT : path to the top level of toolchain (standalone or placed inside NDK) +# ANDROID_CLANG_TOOLCHAIN_ROOT : path to clang tools +# ANDROID_SUPPORTED_NATIVE_API_LEVELS : list of native API levels found inside NDK +# ANDROID_STL_INCLUDE_DIRS : stl include paths +# ANDROID_RTTI : if rtti is enabled by the runtime +# ANDROID_EXCEPTIONS : if exceptions are enabled by the runtime +# ANDROID_GCC_TOOLCHAIN_NAME : read-only, differs from ANDROID_TOOLCHAIN_NAME only if clang is used +# +# Defaults: +# ANDROID_DEFAULT_NDK_API_LEVEL +# ANDROID_DEFAULT_NDK_API_LEVEL_${ARCH} +# ANDROID_NDK_SEARCH_PATHS +# ANDROID_SUPPORTED_ABIS_${ARCH} +# ANDROID_SUPPORTED_NDK_VERSIONS diff --git a/cmake/ios.cmake b/cmake/ios.cmake new file mode 100644 index 0000000..1924c1f --- /dev/null +++ b/cmake/ios.cmake @@ -0,0 +1,436 @@ +# This file is part of the ios-cmake project. It was retrieved from +# https://github.com/cristeab/ios-cmake.git, which is a fork of +# https://code.google.com/p/ios-cmake/. Which in turn is based off of +# the Platform/Darwin.cmake and Platform/UnixPaths.cmake files which +# are included with CMake 2.8.4 +# +# The ios-cmake project is licensed under the new BSD license. +# +# Copyright (c) 2014, Bogdan Cristea and LTE Engineering Software, +# Kitware, Inc., Insight Software Consortium. All rights reserved. +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +# This file is based off of the Platform/Darwin.cmake and +# Platform/UnixPaths.cmake files which are included with CMake 2.8.4 +# It has been altered for iOS development. +# +# Updated by Alex Stewart (alexs.mac@gmail.com) +# +# ***************************************************************************** +# Now maintained by Alexander Widerberg (widerbergaren [at] gmail.com) +# under the BSD-3-Clause license +# https://github.com/leetal/ios-cmake +# ***************************************************************************** +# +# INFORMATION / HELP +# +# The following variables control the behaviour of this toolchain: +# +# IOS_PLATFORM: OS (default) or SIMULATOR or SIMULATOR64 or TVOS or SIMULATOR_TVOS +# OS = Build for iPhoneOS. +# SIMULATOR = Build for x86 i386 iPhone Simulator. +# SIMULATOR64 = Build for x86_64 iPhone Simulator. +# TVOS = Build for AppleTVOS. +# SIMULATOR_TVOS = Build for x86_64 AppleTV Simulator. +# CMAKE_OSX_SYSROOT: Path to the iOS SDK to use. By default this is +# automatically determined from IOS_PLATFORM and xcodebuild, but +# can also be manually specified (although this should not be required). +# CMAKE_IOS_DEVELOPER_ROOT: Path to the Developer directory for the iOS platform +# being compiled for. By default this is automatically determined from +# CMAKE_OSX_SYSROOT, but can also be manually specified (although this should +# not be required). +# ENABLE_BITCODE: (1|0) Enables or disables bitcode support. Default 1 (true) +# ENABLE_ARC: (1|0) Enables or disables ARC support. Default 1 (true, ARC enabled by default) +# ENABLE_VISIBILITY: (1|0) Enables or disables symbol visibility support. Default 0 (false, visibility hidden by default) +# IOS_ARCH: (armv7 armv7s arm64 i386 x86_64) If specified, will override the default architectures for the given IOS_PLATFORM +# OS = armv7 armv7s arm64 +# SIMULATOR = i386 +# SIMULATOR64 = x86_64 +# TVOS = arm64 +# SIMULATOR_TVOS = x86_64 +# +# This toolchain defines the following variables for use externally: +# +# XCODE_VERSION: Version number (not including Build version) of Xcode detected. +# IOS_SDK_VERSION: Version of iOS SDK being used. +# CMAKE_OSX_ARCHITECTURES: Architectures being compiled for (generated from +# IOS_PLATFORM). +# +# This toolchain defines the following macros for use externally: +# +# set_xcode_property (TARGET XCODE_PROPERTY XCODE_VALUE XCODE_VARIANT) +# A convenience macro for setting xcode specific properties on targets. +# Available variants are: All, Release, RelWithDebInfo, Debug, MinSizeRel +# example: set_xcode_property (myioslib IPHONEOS_DEPLOYMENT_TARGET "3.1" "all"). +# +# find_host_package (PROGRAM ARGS) +# A macro used to find executable programs on the host system, not within the +# iOS environment. Thanks to the android-cmake project for providing the +# command. + +# Fix for PThread library not in path +set(CMAKE_THREAD_LIBS_INIT "-lpthread") +set(CMAKE_HAVE_THREADS_LIBRARY 1) +set(CMAKE_USE_WIN32_THREADS_INIT 0) +set(CMAKE_USE_PTHREADS_INIT 1) + +# Get the Xcode version being used. +execute_process(COMMAND xcodebuild -version + OUTPUT_VARIABLE XCODE_VERSION + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +string(REGEX MATCH "Xcode [0-9\\.]+" XCODE_VERSION "${XCODE_VERSION}") +string(REGEX REPLACE "Xcode ([0-9\\.]+)" "\\1" XCODE_VERSION "${XCODE_VERSION}") +message(STATUS "Building with Xcode version: ${XCODE_VERSION}") +# Default to building for iPhoneOS if not specified otherwise, and we cannot +# determine the platform from the CMAKE_OSX_ARCHITECTURES variable. The use +# of CMAKE_OSX_ARCHITECTURES is such that try_compile() projects can correctly +# determine the value of IOS_PLATFORM from the root project, as +# CMAKE_OSX_ARCHITECTURES is propagated to them by CMake. +if (NOT DEFINED IOS_PLATFORM) + if (CMAKE_OSX_ARCHITECTURES) + if (CMAKE_OSX_ARCHITECTURES MATCHES ".*arm.*") + set(IOS_PLATFORM "OS") + elseif (CMAKE_OSX_ARCHITECTURES MATCHES "i386") + set(IOS_PLATFORM "SIMULATOR") + elseif (CMAKE_OSX_ARCHITECTURES MATCHES "x86_64") + set(IOS_PLATFORM "SIMULATOR64") + endif() + endif() + if (NOT IOS_PLATFORM) + set(IOS_PLATFORM "OS") + endif() +endif() +set(IOS_PLATFORM ${IOS_PLATFORM} CACHE STRING + "Type of iOS platform for which to build.") +# Determine the platform name and architectures for use in xcodebuild commands +# from the specified IOS_PLATFORM name. +if (IOS_PLATFORM STREQUAL "OS") + set(XCODE_IOS_PLATFORM iphoneos) + if(NOT IOS_ARCH) + set(IOS_ARCH armv7 armv7s arm64) + endif() +elseif (IOS_PLATFORM STREQUAL "SIMULATOR") + set(XCODE_IOS_PLATFORM iphonesimulator) + if(NOT IOS_ARCH) + set(IOS_ARCH i386) + endif() +elseif(IOS_PLATFORM STREQUAL "SIMULATOR64") + set(XCODE_IOS_PLATFORM iphonesimulator) + if(NOT IOS_ARCH) + set(IOS_ARCH x86_64) + endif() +elseif (IOS_PLATFORM STREQUAL "TVOS") + set(XCODE_IOS_PLATFORM appletvos) + if(NOT IOS_ARCH) + set(IOS_ARCH arm64) + endif() +elseif (IOS_PLATFORM STREQUAL "SIMULATOR_TVOS") + set(XCODE_IOS_PLATFORM appletvsimulator) + if(NOT IOS_ARCH) + set(IOS_ARCH x86_64) + endif() +else() + message(FATAL_ERROR "Invalid IOS_PLATFORM: ${IOS_PLATFORM}") +endif() +message(STATUS "Configuring iOS build for platform: ${IOS_PLATFORM}, " + "architecture(s): ${IOS_ARCH}") +# If user did not specify the SDK root to use, then query xcodebuild for it. +if (NOT CMAKE_OSX_SYSROOT) + execute_process(COMMAND xcodebuild -version -sdk ${XCODE_IOS_PLATFORM} Path + OUTPUT_VARIABLE CMAKE_OSX_SYSROOT + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + message(STATUS "Using SDK: ${CMAKE_OSX_SYSROOT} for platform: ${IOS_PLATFORM}") +endif() +if (NOT EXISTS ${CMAKE_OSX_SYSROOT}) + message(SEND_ERROR "Please make sure that Xcode is installed and that the toolchain" + "is pointing to the correct path. Please run:" + "sudo xcode-select -s /Applications/Xcode.app/Contents/Developer" + "and see if that fixes the problem for you.") + message(FATAL_ERROR "Invalid CMAKE_OSX_SYSROOT: ${CMAKE_OSX_SYSROOT} " + "does not exist.") +endif() +# Specify minimum version of deployment target. +if (NOT DEFINED IOS_DEPLOYMENT_TARGET) + # Unless specified, SDK version 8.0 is used by default as minimum target version. + set(IOS_DEPLOYMENT_TARGET "8.0" + CACHE STRING "Minimum iOS version to build for." ) + message(STATUS "Using the default min-version since IOS_DEPLOYMENT_TARGET not provided!") +endif() +# Use bitcode or not +if (NOT DEFINED ENABLE_BITCODE AND NOT IOS_ARCH MATCHES "((^|, )(i386|x86_64))+") + # Unless specified, enable bitcode support by default + set(ENABLE_BITCODE TRUE CACHE BOOL "Whether or not to enable bitcode") + message(STATUS "Enabling bitcode support by default. ENABLE_BITCODE not provided!") +endif() +if (NOT DEFINED ENABLE_BITCODE) + message(STATUS "Disabling bitcode support by default on simulators. ENABLE_BITCODE not provided for override!") +endif() +# Use ARC or not +if (NOT DEFINED ENABLE_ARC) + # Unless specified, enable ARC support by default + set(ENABLE_ARC TRUE CACHE BOOL "Whether or not to enable ARC") + message(STATUS "Enabling ARC support by default. ENABLE_ARC not provided!") +endif() +# Use hidden visibility or not +if (NOT DEFINED ENABLE_VISIBILITY) + # Unless specified, disable symbols visibility by default + set(ENABLE_VISIBILITY FALSE CACHE BOOL "Whether or not to hide symbols (-fvisibility=hidden)") + message(STATUS "Hiding symbols visibility by default. ENABLE_VISIBILITY not provided!") +endif() +# Get the SDK version information. +execute_process(COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version SDKVersion + OUTPUT_VARIABLE IOS_SDK_VERSION + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +# Find the Developer root for the specific iOS platform being compiled for +# from CMAKE_OSX_SYSROOT. Should be ../../ from SDK specified in +# CMAKE_OSX_SYSROOT. There does not appear to be a direct way to obtain +# this information from xcrun or xcodebuild. +if (NOT CMAKE_IOS_DEVELOPER_ROOT) + get_filename_component(IOS_PLATFORM_SDK_DIR ${CMAKE_OSX_SYSROOT} PATH) + get_filename_component(CMAKE_IOS_DEVELOPER_ROOT ${IOS_PLATFORM_SDK_DIR} PATH) +endif() +if (NOT EXISTS ${CMAKE_IOS_DEVELOPER_ROOT}) + message(FATAL_ERROR "Invalid CMAKE_IOS_DEVELOPER_ROOT: " + "${CMAKE_IOS_DEVELOPER_ROOT} does not exist.") +endif() +# Find the C & C++ compilers for the specified SDK. +if (NOT CMAKE_C_COMPILER) + execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang + OUTPUT_VARIABLE CMAKE_C_COMPILER + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + message(STATUS "Using C compiler: ${CMAKE_C_COMPILER}") +endif() +if (NOT CMAKE_CXX_COMPILER) + execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang++ + OUTPUT_VARIABLE CMAKE_CXX_COMPILER + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + message(STATUS "Using CXX compiler: ${CMAKE_CXX_COMPILER}") +endif() +# Find (Apple's) libtool. +execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find libtool + OUTPUT_VARIABLE IOS_LIBTOOL + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +message(STATUS "Using libtool: ${IOS_LIBTOOL}") +# Configure libtool to be used instead of ar + ranlib to build static libraries. +# This is required on Xcode 7+, but should also work on previous versions of +# Xcode. +set(CMAKE_C_CREATE_STATIC_LIBRARY + "${IOS_LIBTOOL} -static -o ") +set(CMAKE_CXX_CREATE_STATIC_LIBRARY + "${IOS_LIBTOOL} -static -o ") +# Get the version of Darwin (OS X) of the host. +execute_process(COMMAND uname -r + OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_VERSION + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +# Standard settings. +set(CMAKE_SYSTEM_NAME Darwin CACHE INTERNAL "") +set(CMAKE_SYSTEM_VERSION ${IOS_SDK_VERSION} CACHE INTERNAL "") +set(UNIX TRUE CACHE BOOL "") +set(APPLE TRUE CACHE BOOL "") +set(IOS TRUE CACHE BOOL "") +set(CMAKE_AR ar CACHE FILEPATH "" FORCE) +set(CMAKE_RANLIB ranlib CACHE FILEPATH "" FORCE) +# Force unset of OS X-specific deployment target (otherwise autopopulated), +# required as of cmake 2.8.10. +set(CMAKE_OSX_DEPLOYMENT_TARGET "" CACHE STRING + "Must be empty for iOS builds." FORCE) +# Set the architectures for which to build. +set(CMAKE_OSX_ARCHITECTURES ${IOS_ARCH} CACHE STRING "Build architecture for iOS") +# Change the type of target generated for try_compile() so it'll work when cross-compiling +set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) +# Skip the platform compiler checks for cross compiling. +set(CMAKE_CXX_COMPILER_FORCED TRUE) +set(CMAKE_CXX_COMPILER_WORKS TRUE) +set(CMAKE_C_COMPILER_FORCED TRUE) +set(CMAKE_C_COMPILER_WORKS TRUE) +# All iOS/Darwin specific settings - some may be redundant. +set(CMAKE_SHARED_LIBRARY_PREFIX "lib") +set(CMAKE_SHARED_LIBRARY_SUFFIX ".dylib") +set(CMAKE_SHARED_MODULE_PREFIX "lib") +set(CMAKE_SHARED_MODULE_SUFFIX ".so") +set(CMAKE_C_COMPILER_ABI ELF) +set(CMAKE_CXX_COMPILER_ABI ELF) +set(CMAKE_C_HAS_ISYSROOT 1) +set(CMAKE_CXX_HAS_ISYSROOT 1) +set(CMAKE_MODULE_EXISTS 1) +set(CMAKE_DL_LIBS "") +set(CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ") +set(CMAKE_C_OSX_CURRENT_VERSION_FLAG "-current_version ") +set(CMAKE_CXX_OSX_COMPATIBILITY_VERSION_FLAG "${CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG}") +set(CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}") + +if(IOS_ARCH MATCHES "((^|, )(arm64|x86_64))+") + set(CMAKE_C_SIZEOF_DATA_PTR 8) + set(CMAKE_CXX_SIZEOF_DATA_PTR 8) + message(STATUS "Using a data_ptr size of 8") +else() + set(CMAKE_C_SIZEOF_DATA_PTR 4) + set(CMAKE_CXX_SIZEOF_DATA_PTR 4) + message(STATUS "Using a data_ptr size of 4") +endif() + +message(STATUS "Building for minimum iOS version: ${IOS_DEPLOYMENT_TARGET}" + " (SDK version: ${IOS_SDK_VERSION})") +# Note that only Xcode 7+ supports the newer more specific: +# -m${XCODE_IOS_PLATFORM}-version-min flags, older versions of Xcode use: +# -m(ios/ios-simulator)-version-min instead. +if (IOS_PLATFORM STREQUAL "OS") + if (XCODE_VERSION VERSION_LESS 7.0) + set(XCODE_IOS_PLATFORM_VERSION_FLAGS + "-mios-version-min=${IOS_DEPLOYMENT_TARGET}") + else() + # Xcode 7.0+ uses flags we can build directly from XCODE_IOS_PLATFORM. + set(XCODE_IOS_PLATFORM_VERSION_FLAGS + "-m${XCODE_IOS_PLATFORM}-version-min=${IOS_DEPLOYMENT_TARGET}") + endif() +elseif (IOS_PLATFORM STREQUAL "TVOS") + set(XCODE_IOS_PLATFORM_VERSION_FLAGS + "-mtvos-version-min=${IOS_DEPLOYMENT_TARGET}") +elseif (IOS_PLATFORM STREQUAL "SIMULATOR_TVOS") + set(XCODE_IOS_PLATFORM_VERSION_FLAGS + "-mtvos-simulator-version-min=${IOS_DEPLOYMENT_TARGET}") +else() + # SIMULATOR or SIMULATOR64 both use -mios-simulator-version-min. + set(XCODE_IOS_PLATFORM_VERSION_FLAGS + "-mios-simulator-version-min=${IOS_DEPLOYMENT_TARGET}") +endif() +message(STATUS "Version flags set to: ${XCODE_IOS_PLATFORM_VERSION_FLAGS}") + +if (ENABLE_BITCODE) + set(BITCODE "-fembed-bitcode") + set(HEADER_PAD "") + message(STATUS "Enabling bitcode support.") +else() + set(BITCODE "") + set(HEADER_PAD "-headerpad_max_install_names") + message(STATUS "Disabling bitcode support.") +endif() + +if (ENABLE_ARC) + set(FOBJC_ARC "-fobjc-arc") + message(STATUS "Enabling ARC support.") +else() + set(FOBJC_ARC "-fno-objc-arc") + message(STATUS "Disabling ARC support.") +endif() + +if (NOT ENABLE_VISIBILITY) + set(VISIBILITY "-fvisibility=hidden") + message(STATUS "Hiding symbols (-fvisibility=hidden).") +else() + set(VISIBILITY "") +endif() + +set(CMAKE_C_FLAGS +"${XCODE_IOS_PLATFORM_VERSION_FLAGS} ${BITCODE} -fobjc-abi-version=2 ${FOBJC_ARC} ${C_FLAGS}") +# Hidden visibilty is required for C++ on iOS. +set(CMAKE_CXX_FLAGS +"${XCODE_IOS_PLATFORM_VERSION_FLAGS} ${BITCODE} ${VISIBILITY} -fvisibility-inlines-hidden -fobjc-abi-version=2 ${FOBJC_ARC} ${CXX_FLAGS}") +set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS} -DNDEBUG -Os -ffast-math ${BITCODE} ${CXX_FLAGS_MINSIZEREL}") +set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS} -DNDEBUG -O2 -g -ffast-math ${BITCODE} ${CXX_FLAGS_RELWITHDEBINFO}") +set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS} -DNDEBUG -O3 -ffast-math ${BITCODE} ${CXX_FLAGS_RELEASE}") +set(CMAKE_C_LINK_FLAGS "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -Wl,-search_paths_first ${C_LINK_FLAGS}") +set(CMAKE_CXX_LINK_FLAGS "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -Wl,-search_paths_first ${CXX_LINK_FLAGS}") + +# In order to ensure that the updated compiler flags are used in try_compile() +# tests, we have to forcibly set them in the CMake cache, not merely set them +# in the local scope. +list(APPEND VARS_TO_FORCE_IN_CACHE + CMAKE_C_FLAGS + CMAKE_CXX_FLAGS + CMAKE_CXX_FLAGS_RELWITHDEBINFO + CMAKE_CXX_FLAGS_MINSIZEREL + CMAKE_CXX_FLAGS_RELEASE + CMAKE_C_LINK_FLAGS + CMAKE_CXX_LINK_FLAGS) +foreach(VAR_TO_FORCE ${VARS_TO_FORCE_IN_CACHE}) + set(${VAR_TO_FORCE} "${${VAR_TO_FORCE}}" CACHE STRING "" FORCE) +endforeach() + +set(CMAKE_PLATFORM_HAS_INSTALLNAME 1) +set (CMAKE_SHARED_LINKER_FLAGS "-rpath @executable_path/Frameworks -rpath @loader_path/Frameworks") +set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib ${HEADER_PAD}") +set(CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle ${HEADER_PAD}") +set(CMAKE_SHARED_MODULE_LOADER_C_FLAG "-Wl,-bundle_loader,") +set(CMAKE_SHARED_MODULE_LOADER_CXX_FLAG "-Wl,-bundle_loader,") +set(CMAKE_FIND_LIBRARY_SUFFIXES ".dylib" ".so" ".a") + +# Hack: if a new cmake (which uses CMAKE_INSTALL_NAME_TOOL) runs on an old +# build tree (where install_name_tool was hardcoded) and where +# CMAKE_INSTALL_NAME_TOOL isn't in the cache and still cmake didn't fail in +# CMakeFindBinUtils.cmake (because it isn't rerun) hardcode +# CMAKE_INSTALL_NAME_TOOL here to install_name_tool, so it behaves as it did +# before, Alex. +if (NOT DEFINED CMAKE_INSTALL_NAME_TOOL) + find_program(CMAKE_INSTALL_NAME_TOOL install_name_tool) +endif (NOT DEFINED CMAKE_INSTALL_NAME_TOOL) + +# Set the find root to the iOS developer roots and to user defined paths. +set(CMAKE_FIND_ROOT_PATH ${CMAKE_IOS_DEVELOPER_ROOT} ${CMAKE_OSX_SYSROOT} + ${CMAKE_PREFIX_PATH} CACHE string "iOS find search path root" FORCE) +# Default to searching for frameworks first. +set(CMAKE_FIND_FRAMEWORK FIRST) +# Set up the default search directories for frameworks. +set(CMAKE_SYSTEM_FRAMEWORK_PATH + ${CMAKE_OSX_SYSROOT}/System/Library/Frameworks + ${CMAKE_OSX_SYSROOT}/System/Library/PrivateFrameworks + ${CMAKE_OSX_SYSROOT}/Developer/Library/Frameworks) +# Only search the specified iOS SDK, not the remainder of the host filesystem. +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +# This little macro lets you set any XCode specific property. +macro(set_xcode_property TARGET XCODE_PROPERTY XCODE_VALUE XCODE_RELVERSION) + set(XCODE_RELVERSION_I "${XCODE_RELVERSION}") + if (XCODE_RELVERSION_I STREQUAL "All") + set_property(TARGET ${TARGET} PROPERTY + XCODE_ATTRIBUTE_${XCODE_PROPERTY} "${XCODE_VALUE}") + else() + set_property(TARGET ${TARGET} PROPERTY + XCODE_ATTRIBUTE_${XCODE_PROPERTY}[variant=${XCODE_RELVERSION_I}] "${XCODE_VALUE}") + endif() +endmacro(set_xcode_property) +# This macro lets you find executable programs on the host system. +macro(find_host_package) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER) + set(IOS FALSE) + find_package(${ARGN}) + set(IOS TRUE) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +endmacro(find_host_package) \ No newline at end of file diff --git a/cmake/platform.cmake b/cmake/platform.cmake new file mode 100644 index 0000000..707c2a7 --- /dev/null +++ b/cmake/platform.cmake @@ -0,0 +1,57 @@ +#cmake has some strange defaults, this should help us a lot +#Please use them everywhere + +#WINDOWS = Windows Desktop +#WINRT = Windows RT +#WP8 = Windows Phone 8 +#ANDROID = Android +#IOS = iOS +#MACOSX = MacOS X +#LINUX = Linux + +#define PLATFORM_UNKNOWN 0 +#define PLATFORM_IOS 1 +#define PLATFORM_ANDROID 2 +#define PLATFORM_WIN32 3 +#define PLATFORM_WP8 4 +#define PLATFORM_WIN10 5 +#define PLATFORM_LINUX 6 + +if (${CMAKE_SYSTEM_NAME} MATCHES "Windows") + if(WINRT) + set(SYSTEM_STRING "Windows RT") + add_definitions(-DTARGET_PLATFORM=5) + elseif(WP8) + set(SYSTEM_STRING "Windows Phone 8") + add_definitions(-DTARGET_PLATFORM=4) + else() + set(WINDOWS TRUE) + set(SYSTEM_STRING "Windows Desktop") + add_definitions(-DTARGET_PLATFORM=3) + endif() +elseif (${CMAKE_SYSTEM_NAME} MATCHES "Linux") + if(ANDROID) + set(SYSTEM_STRING "Android") + add_definitions(-DTARGET_PLATFORM=2) + else() + set(LINUX TRUE) + set(SYSTEM_STRING "Linux") + add_definitions(-DTARGET_PLATFORM=6) + endif() +elseif (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") + if(IOS) + set(SYSTEM_STRING "IOS") + add_definitions(-DTARGET_PLATFORM=1) + else() + set(MACOSX TRUE) + set(APPLE TRUE) + set(SYSTEM_STRING "Mac OSX") + add_definitions(-DTARGET_PLATFORM=6) + endif() +elseif (EMSCRIPTEN) + add_definitions(-DTARGET_PLATFORM=6) +else() + message(ERROR "unrecognized target platform.") +endif() + +SET(CMAKE_INSTALL_RPATH "@executable_path") diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt new file mode 100644 index 0000000..0941a0e --- /dev/null +++ b/example/CMakeLists.txt @@ -0,0 +1,18 @@ +cmake_minimum_required(VERSION 3.6) +project(example) + +include_directories("../src") + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_C_STANDARD 11) + +IF(${CMAKE_SYSTEM_NAME} STREQUAL "Windows") +ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS) +add_compile_options("$<$:/utf-8>") +add_compile_options("$<$:/utf-8>") +ENDIF() + +file(GLOB SRC_FILES "*.cpp" ) +add_executable(example ${SRC_FILES}) +target_link_libraries(example +sxtwl) diff --git a/example/golang/go.mod b/example/golang/go.mod new file mode 100644 index 0000000..dc988b5 --- /dev/null +++ b/example/golang/go.mod @@ -0,0 +1,3 @@ +module sxtwl_example + +go 1.17 diff --git a/example/golang/main.go b/example/golang/main.go new file mode 100644 index 0000000..4b0b952 --- /dev/null +++ b/example/golang/main.go @@ -0,0 +1,217 @@ +package main + +import ( + "fmt" + "sxtwl_example/sxtwl" +) + +/** +* 本例子只给了win64的静态库，如果需要其它库请自行编译 +$ cd ~/code/sxtwl_cpp +$ mkdir build +$ cd build +$ cmake .. -DSXTWL_WRAPPER_GO=1 +$ cmake --build . + +编译好了，请把sxtwl.a及sxtwl_cgo.a放到lib目录下，并在sxtwl目录下的init.go加好链接路径 + + +注: 如果使用win系统的话，请安装mingw32, 作者推荐安装tdm-gcc +然后cmake 命令改成 cmake -G "MinGW Makefiles" .. -DSXTWL_WRAPPER_GO=1 +*/ + +var Gan = [...]string{"甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"} + +var Zhi = [...]string{"子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"} +var ShX = [...]string{"鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪"} +var MumCn = [...]string{"零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十"} +var Jqmc = [...]string{"冬至", "小寒", "大寒", "立春", "雨水", "惊蛰", "春分", "清明", "谷雨", "立夏", + "小满", "芒种", "夏至", "小暑", "大暑", "立秋", "处暑", "白露", "秋分", "寒露", "霜降", + "立冬", "小雪", "大雪"} +var Ymc = [...]string{"正", "二", "三", "四", "五", "六", "七", "八", "九", "十", "十一", "十二"} +var Rmc = [...]string{"初一", "初二", "初三", "初四", "初五", "初六", "初七", "初八", "初九", "初十", + "十一", "十二", "十三", "十四", "十五", "十六", "十七", "十八", "十九", "二十", + "廿一", "廿二", "廿三", "廿四", "廿五", "廿六", "廿七", "廿八", "廿九", "三十", "卅一"} +var XiZ = [...]string{"摩羯", "水瓶", "双鱼", "白羊", "金牛", "双子", "巨蟹", "狮子", "处女", "天秤", "天蝎", "射手"} +var WeekCn = [...]string{"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"} + +//============================================================================================= +//做反推的辅助函数 +// copy form https://blog.csdn.net/qianguozheng/article/details/52795395 +func SubString(str string, begin, length int) string { + fmt.Println("Substring =", str) + rs := []rune(str) + lth := len(rs) + fmt.Printf("begin=%d, end=%d, lth=%d\n", begin, length, lth) + if begin < 0 { + begin = 0 + } + if begin >= lth { + begin = lth + } + end := begin + length + + if end > lth { + end = lth + } + fmt.Printf("begin=%d, end=%d, lth=%d\n", begin, length, lth) + return string(rs[begin:end]) +} + +func GetGZ(gzStr string) sxtwl.GZ { + tg := -1 + dz := -1 + + for i, v := range Gan { + if SubString(gzStr, 0, 1) == v { + tg = i + break + } + } + + for i, v := range Zhi { + if SubString(gzStr, 1, 1) == v { + tg = i + break + } + } + + return sxtwl.NewGZ(tg, dz) +} + +//============================================================================================= + +func main() { + day := sxtwl.DayFromSolar(2021, 11, 7) + + // day := sxtwl.DayFromLunar(2020, 12, 1) + // # 如果是想查闰月，第四个参数加一个True即可 + // # day = sxtwl.DayFromLunar(2020, 12, 1, true) + + fmt.Printf("公历:%v年%v月%v日\n", day.GetSolarYear(), day.GetSolarMonth(), day.GetSolarDay()) + + // 星期几 + fmt.Printf("%v\n", WeekCn[day.GetWeek()]) + + // 这个月的第几周 + fmt.Printf("该日属于这个月的第%v周\n", day.GetWeekIndex()) + + //以春节为界的农历(注getLunarYear如果没有传参，或者传true，是以春节为界的) + runStr := "" + if day.IsLunarLeap() { + runStr = "闰" + } + fmt.Printf("农历:%d年%s%d月%d日\n", day.GetLunarYear(), runStr, day.GetLunarMonth(), day.GetLunarDay()) + + //不以立春为界的农历 + fmt.Printf("农历:%d年%s%d月%d日\n", day.GetLunarYear(true), runStr, day.GetLunarMonth(), day.GetLunarDay()) + + // 以春节为界的天干地支 + yTG := day.GetYearGZ(true) + fmt.Printf("以春节为界的年干支:%v", Gan[yTG.GetTg()]+Zhi[yTG.GetDz()]) + fmt.Printf("以春节为界的生肖:%v", ShX[yTG.GetDz()]) + + // 以立春为界的天干地支 （注，如果没有传参，或者传false，是以立春为界的。刚好和getLunarYear相反） + yTG = day.GetYearGZ() + fmt.Printf("以立春为界的年干支:%v", Gan[yTG.GetTg()]+Zhi[yTG.GetDz()]) + fmt.Printf("以立春为界的生肖:%v", ShX[yTG.GetDz()]) + + //月干支 + mTG := day.GetMonthGZ() + fmt.Printf("月干支:%v", Gan[mTG.GetTg()]+Zhi[mTG.GetDz()]) + + //日干支 + dTG := day.GetDayGZ() + fmt.Printf("日干支%v", Gan[dTG.GetTg()]+Zhi[dTG.GetDz()]) + + //时干支,传24小时制的时间，分早晚子时 + hour := 18 + sTG := day.GetHourGZ((byte)(hour)) + fmt.Printf("%d时的干支%v", hour, Gan[sTG.GetTg()]+Zhi[sTG.GetDz()]) + + // 第二种获取时干支方法 + //第一个参数为该天的天干，第二个参数为小时 + hTG := sxtwl.GetShiGz(dTG.GetTg(), (byte)(hour)) + fmt.Printf("%d时天干地支:%v", (hour), Gan[hTG.GetTg()]+Zhi[hTG.GetDz()]) + + // 当日是否有节气 + if day.HasJieQi() { + fmt.Printf("节气：%s", Jqmc[day.GetJieQi()]) + //获取节气的儒略日数 + jd := day.GetJieQiJD() + // 将儒略日数转换成年月日时秒 + t := sxtwl.JD2DD(jd) + fmt.Printf("节气时间:%v", t) + //注意，t.s是小数，需要四舍五入 + //fmt.Printf("节气时间:%d-%d-%d %d:%d:%d", t.GetY(), t.GetM(), t.GetD(), t.GetH(), t.GetM(), math.Round(t.GetS())) + } else { + fmt.Println("当天不是节气日") + } + + // 四注反查 分别传的是年天干，月天干，日天干，时天干， 开始查询年，结束查询年 返回满足条件的儒略日数 + jds := sxtwl.SiZhu2Year(GetGZ("辛丑"), GetGZ("己亥"), GetGZ("丙寅"), GetGZ("癸巳"), 2003, 2029) + for i := 0; i < int(jds.Size()); i++ { + jd := jds.Get(i) + t := sxtwl.JD2DD(jd) + fmt.Printf("符合条件的时间:%v", t) + // print("符合条件的时间:%d-%d-%d %d:%d:%d"%(t.Y, t.M, t.D, t.h, t.m, round(t.s))) + } + + // 获取一年中的闰月 + year := 2020 + month := sxtwl.GetRunMonth(year) + if month >= 0 { + fmt.Printf("%d年的闰月是%d", year, month) + } else { + fmt.Println("没有闰月") + } + + // 一个农历月的天数 + year = 2020 //农历年 + month = 4 //农历月 + isRun := false //是否是闰月 + daynum := sxtwl.GetLunarMonthNum(year, month, isRun) + runStr = "" + if isRun { + runStr = "闰" + } + fmt.Printf("农历%v年%v%v月的天数:%v", year, runStr, month, daynum) + + //儒略日数转公历 + jd := sxtwl.J2000 + t := sxtwl.JD2DD((float64)(jd)) + + //公历转儒略日 + // jd = sxtwl.ToJD(t) + + // 获取某天的后面几天 + num := 1 //你喜欢写多少天 也多少天，可以写负数，相当于往前 + day = day.After(num) //获取num天后的日信息 + fmt.Printf("公历:%d年%d月%d日\n", day.GetSolarYear(), day.GetSolarMonth(), day.GetSolarDay()) + + // 同上 + day = day.Before(num) + fmt.Printf("公历:%d年%d月%d日\n", day.GetSolarYear(), day.GetSolarMonth(), day.GetSolarDay()) + + // 查找某日前后的节气 + for true { + // 这里可以使用after或者before，不用担心速度，这里的计算在底层仅仅是+1这么简单 + day = day.After(1) + // hasJieQi的接口比getJieQiJD速度要快，你也可以使用getJieQiJD来判断是否有节气。 + if day.HasJieQi() { + fmt.Printf("节气：%s", Jqmc[day.GetJieQi()]) + //获取节气的儒略日数， 如果说你要计算什么时间的相距多少，直接比对儒略日要方便，相信我。 + jd := day.GetJieQiJD() + + // 将儒略日数转换成年月日时秒 + t = sxtwl.JD2DD(jd) + fmt.Printf("节气时间:%v", t) + // # 注意，t.s是小数，需要四舍五入 + // print("节气时间:%d-%d-%d %d:%d:%d"%(t.Y, t.M, t.D, t.h, t.m, round(t.s))) + + break + } + + } + +} diff --git a/example/golang/sxtwl/init.go b/example/golang/sxtwl/init.go new file mode 100644 index 0000000..e29f1e8 --- /dev/null +++ b/example/golang/sxtwl/init.go @@ -0,0 +1,8 @@ +package sxtwl + +/* +// 参考：https://kaisawind.gitee.io/2020/10/24/2020-10-24-cgo-build/ +#cgo windows LDFLAGS:-L${SRCDIR}/../lib/win64 -lsxtwl_go -lsxtwl -lstdc++ -Wl,-rpath=./ +#cgo linux LDFLAGS:-L${SRCDIR}/../lib/linux -lsxtwl_go -lsxtwl -lm -lstdc++ -Wl,-rpath=./ +*/ +import "C" diff --git a/example/golang/sxtwl/sxtwl.go b/example/golang/sxtwl/sxtwl.go new file mode 100644 index 0000000..eba91fe --- /dev/null +++ b/example/golang/sxtwl/sxtwl.go @@ -0,0 +1,790 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +// source: swig\sxtwl.i + +package sxtwl + +/* +#define intgo swig_intgo +typedef void *swig_voidp; + +#include + + +typedef int intgo; +typedef unsigned int uintgo; + + + +typedef struct { char *p; intgo n; } _gostring_; +typedef struct { void* array; intgo len; intgo cap; } _goslice_; + + +typedef long long swig_type_1; +typedef long long swig_type_2; +typedef long long swig_type_3; +typedef long long swig_type_4; +extern void _wrap_Swig_free_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern uintptr_t _wrap_Swig_malloc_sxtwl_258d85b6700e030a(swig_intgo arg1); +extern uintptr_t _wrap_new_JDList__SWIG_0_sxtwl_258d85b6700e030a(void); +extern uintptr_t _wrap_new_JDList__SWIG_1_sxtwl_258d85b6700e030a(swig_type_1 arg1); +extern uintptr_t _wrap_new_JDList__SWIG_2_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern swig_type_2 _wrap_JDList_size_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern swig_type_3 _wrap_JDList_capacity_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern void _wrap_JDList_reserve_sxtwl_258d85b6700e030a(uintptr_t arg1, swig_type_4 arg2); +extern _Bool _wrap_JDList_isEmpty_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern void _wrap_JDList_clear_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern void _wrap_JDList_add_sxtwl_258d85b6700e030a(uintptr_t arg1, double arg2); +extern double _wrap_JDList_get_sxtwl_258d85b6700e030a(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_JDList_set_sxtwl_258d85b6700e030a(uintptr_t arg1, swig_intgo arg2, double arg3); +extern void _wrap_delete_JDList_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern void _wrap_Time_Y_set_sxtwl_258d85b6700e030a(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_Time_Y_get_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern void _wrap_Time_M_set_sxtwl_258d85b6700e030a(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_Time_M_get_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern void _wrap_Time_D_set_sxtwl_258d85b6700e030a(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_Time_D_get_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern void _wrap_Time_h_set_sxtwl_258d85b6700e030a(uintptr_t arg1, double arg2); +extern double _wrap_Time_h_get_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern void _wrap_Time_s_set_sxtwl_258d85b6700e030a(uintptr_t arg1, double arg2); +extern double _wrap_Time_s_get_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern uintptr_t _wrap_new_Time_sxtwl_258d85b6700e030a(void); +extern void _wrap_delete_Time_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern uintptr_t _wrap_new_GZ__SWIG_0_sxtwl_258d85b6700e030a(void); +extern uintptr_t _wrap_new_GZ__SWIG_1_sxtwl_258d85b6700e030a(char arg1, char arg2); +extern void _wrap_GZ_tg_set_sxtwl_258d85b6700e030a(uintptr_t arg1, char arg2); +extern char _wrap_GZ_tg_get_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern void _wrap_GZ_dz_set_sxtwl_258d85b6700e030a(uintptr_t arg1, char arg2); +extern char _wrap_GZ_dz_get_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern void _wrap_delete_GZ_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern uintptr_t _wrap_Day_fromSolar_sxtwl_258d85b6700e030a(swig_intgo arg1, char arg2, swig_intgo arg3); +extern uintptr_t _wrap_Day_fromLunar__SWIG_0_sxtwl_258d85b6700e030a(swig_intgo arg1, char arg2, swig_intgo arg3, _Bool arg4); +extern uintptr_t _wrap_Day_fromLunar__SWIG_1_sxtwl_258d85b6700e030a(swig_intgo arg1, char arg2, swig_intgo arg3); +extern uintptr_t _wrap_Day_after_sxtwl_258d85b6700e030a(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_Day_before_sxtwl_258d85b6700e030a(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_Day_getLunarDay_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern char _wrap_Day_getLunarMonth_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern swig_intgo _wrap_Day_getLunarYear__SWIG_0_sxtwl_258d85b6700e030a(uintptr_t arg1, _Bool arg2); +extern swig_intgo _wrap_Day_getLunarYear__SWIG_1_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern uintptr_t _wrap_Day_getYearGZ__SWIG_0_sxtwl_258d85b6700e030a(uintptr_t arg1, _Bool arg2); +extern uintptr_t _wrap_Day_getYearGZ__SWIG_1_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern uintptr_t _wrap_Day_getMonthGZ_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern uintptr_t _wrap_Day_getDayGZ_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern uintptr_t _wrap_Day_getHourGZ_sxtwl_258d85b6700e030a(uintptr_t arg1, char arg2); +extern _Bool _wrap_Day_isLunarLeap_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern swig_intgo _wrap_Day_getSolarYear_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern char _wrap_Day_getSolarMonth_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern swig_intgo _wrap_Day_getSolarDay_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern char _wrap_Day_getWeek_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern char _wrap_Day_getWeekIndex_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern _Bool _wrap_Day_hasJieQi_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern char _wrap_Day_getJieQi_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern double _wrap_Day_getJieQiJD_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern char _wrap_Day_getConstellation_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern void _wrap_delete_Day_sxtwl_258d85b6700e030a(uintptr_t arg1); +extern uintptr_t _wrap_fromSolar_sxtwl_258d85b6700e030a(swig_intgo arg1, char arg2, swig_intgo arg3); +extern uintptr_t _wrap_fromLunar__SWIG_0_sxtwl_258d85b6700e030a(swig_intgo arg1, char arg2, swig_intgo arg3, _Bool arg4); +extern uintptr_t _wrap_fromLunar__SWIG_1_sxtwl_258d85b6700e030a(swig_intgo arg1, char arg2, swig_intgo arg3); +extern uintptr_t _wrap_siZhu2Year_sxtwl_258d85b6700e030a(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, swig_intgo arg5, swig_intgo arg6); +extern uintptr_t _wrap_getShiGz_sxtwl_258d85b6700e030a(char arg1, char arg2); +extern char _wrap_getRunMonth_sxtwl_258d85b6700e030a(swig_intgo arg1); +extern char _wrap_getLunarMonthNum__SWIG_0_sxtwl_258d85b6700e030a(swig_intgo arg1, char arg2, _Bool arg3); +extern char _wrap_getLunarMonthNum__SWIG_1_sxtwl_258d85b6700e030a(swig_intgo arg1, char arg2); +extern uintptr_t _wrap_JD2DD_sxtwl_258d85b6700e030a(double arg1); +extern double _wrap_toJD_sxtwl_258d85b6700e030a(uintptr_t arg1); +#undef intgo +*/ +import "C" + +import "unsafe" +import _ "runtime/cgo" +import "sync" + + +type _ unsafe.Pointer + + + +var Swig_escape_always_false bool +var Swig_escape_val interface{} + + +type _swig_fnptr *byte +type _swig_memberptr *byte + + +type _ sync.Mutex + +func Swig_free(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_Swig_free_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0)) +} + +func Swig_malloc(arg1 int) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_Swig_malloc_sxtwl_258d85b6700e030a(C.swig_intgo(_swig_i_0))) + return swig_r +} + +type SwigcptrJDList uintptr + +func (p SwigcptrJDList) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrJDList) SwigIsJDList() { +} + +func NewJDList__SWIG_0() (_swig_ret JDList) { + var swig_r JDList + swig_r = (JDList)(SwigcptrJDList(C._wrap_new_JDList__SWIG_0_sxtwl_258d85b6700e030a())) + return swig_r +} + +func NewJDList__SWIG_1(arg1 int64) (_swig_ret JDList) { + var swig_r JDList + _swig_i_0 := arg1 + swig_r = (JDList)(SwigcptrJDList(C._wrap_new_JDList__SWIG_1_sxtwl_258d85b6700e030a(C.swig_type_1(_swig_i_0)))) + return swig_r +} + +func NewJDList__SWIG_2(arg1 JDList) (_swig_ret JDList) { + var swig_r JDList + _swig_i_0 := arg1.Swigcptr() + swig_r = (JDList)(SwigcptrJDList(C._wrap_new_JDList__SWIG_2_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewJDList(a ...interface{}) JDList { + argc := len(a) + if argc == 0 { + return NewJDList__SWIG_0() + } + if argc == 1 { + if _, ok := a[0].(int64); !ok { + goto check_2 + } + return NewJDList__SWIG_1(a[0].(int64)) + } +check_2: + if argc == 1 { + return NewJDList__SWIG_2(a[0].(JDList)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrJDList) Size() (_swig_ret int64) { + var swig_r int64 + _swig_i_0 := arg1 + swig_r = (int64)(C._wrap_JDList_size_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrJDList) Capacity() (_swig_ret int64) { + var swig_r int64 + _swig_i_0 := arg1 + swig_r = (int64)(C._wrap_JDList_capacity_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrJDList) Reserve(arg2 int64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_JDList_reserve_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.swig_type_4(_swig_i_1)) +} + +func (arg1 SwigcptrJDList) IsEmpty() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_JDList_isEmpty_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrJDList) Clear() { + _swig_i_0 := arg1 + C._wrap_JDList_clear_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrJDList) Add(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_JDList_add_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrJDList) Get(arg2 int) (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float64)(C._wrap_JDList_get_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrJDList) Set(arg2 int, arg3 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_JDList_set_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.double(_swig_i_2)) +} + +func DeleteJDList(arg1 JDList) { + _swig_i_0 := arg1.Swigcptr() + C._wrap_delete_JDList_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0)) +} + +type JDList interface { + Swigcptr() uintptr + SwigIsJDList() + Size() (_swig_ret int64) + Capacity() (_swig_ret int64) + Reserve(arg2 int64) + IsEmpty() (_swig_ret bool) + Clear() + Add(arg2 float64) + Get(arg2 int) (_swig_ret float64) + Set(arg2 int, arg3 float64) +} + +const J2000 int = 2451545 +type SwigcptrTime uintptr + +func (p SwigcptrTime) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrTime) SwigIsTime() { +} + +func (arg1 SwigcptrTime) SetY(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_Y_set_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetY() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Time_Y_get_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetM(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_M_set_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetM() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Time_M_get_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetD(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_D_set_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetD() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Time_D_get_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetH(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_h_set_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetH() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_Time_h_get_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetS(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_s_set_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetS() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_Time_s_get_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewTime() (_swig_ret Time) { + var swig_r Time + swig_r = (Time)(SwigcptrTime(C._wrap_new_Time_sxtwl_258d85b6700e030a())) + return swig_r +} + +func DeleteTime(arg1 Time) { + _swig_i_0 := arg1.Swigcptr() + C._wrap_delete_Time_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0)) +} + +type Time interface { + Swigcptr() uintptr + SwigIsTime() + SetY(arg2 int) + GetY() (_swig_ret int) + SetM(arg2 int) + GetM() (_swig_ret int) + SetD(arg2 int) + GetD() (_swig_ret int) + SetH(arg2 float64) + GetH() (_swig_ret float64) + SetS(arg2 float64) + GetS() (_swig_ret float64) +} + +type SwigcptrGZ uintptr + +func (p SwigcptrGZ) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrGZ) SwigIsGZ() { +} + +func NewGZ__SWIG_0() (_swig_ret GZ) { + var swig_r GZ + swig_r = (GZ)(SwigcptrGZ(C._wrap_new_GZ__SWIG_0_sxtwl_258d85b6700e030a())) + return swig_r +} + +func NewGZ__SWIG_1(arg1 byte, arg2 byte) (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (GZ)(SwigcptrGZ(C._wrap_new_GZ__SWIG_1_sxtwl_258d85b6700e030a(C.char(_swig_i_0), C.char(_swig_i_1)))) + return swig_r +} + +func NewGZ(a ...interface{}) GZ { + argc := len(a) + if argc == 0 { + return NewGZ__SWIG_0() + } + if argc == 2 { + return NewGZ__SWIG_1(a[0].(byte), a[1].(byte)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrGZ) SetTg(arg2 byte) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_GZ_tg_set_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.char(_swig_i_1)) +} + +func (arg1 SwigcptrGZ) GetTg() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_GZ_tg_get_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrGZ) SetDz(arg2 byte) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_GZ_dz_set_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.char(_swig_i_1)) +} + +func (arg1 SwigcptrGZ) GetDz() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_GZ_dz_get_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteGZ(arg1 GZ) { + _swig_i_0 := arg1.Swigcptr() + C._wrap_delete_GZ_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0)) +} + +type GZ interface { + Swigcptr() uintptr + SwigIsGZ() + SetTg(arg2 byte) + GetTg() (_swig_ret byte) + SetDz(arg2 byte) + GetDz() (_swig_ret byte) +} + +type SwigcptrDay uintptr + +func (p SwigcptrDay) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrDay) SwigIsDay() { +} + +func DayFromSolar(arg1 int, arg2 byte, arg3 int) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (Day)(SwigcptrDay(C._wrap_Day_fromSolar_sxtwl_258d85b6700e030a(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func DayFromLunar__SWIG_0(arg1 int, arg2 byte, arg3 int, arg4 bool) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (Day)(SwigcptrDay(C._wrap_Day_fromLunar__SWIG_0_sxtwl_258d85b6700e030a(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C.swig_intgo(_swig_i_2), C._Bool(_swig_i_3)))) + return swig_r +} + +func DayFromLunar__SWIG_1(arg1 int, arg2 byte, arg3 int) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (Day)(SwigcptrDay(C._wrap_Day_fromLunar__SWIG_1_sxtwl_258d85b6700e030a(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func DayFromLunar(a ...interface{}) Day { + argc := len(a) + if argc == 3 { + return DayFromLunar__SWIG_1(a[0].(int), a[1].(byte), a[2].(int)) + } + if argc == 4 { + return DayFromLunar__SWIG_0(a[0].(int), a[1].(byte), a[2].(int), a[3].(bool)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrDay) After(arg2 int) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (Day)(SwigcptrDay(C._wrap_Day_after_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrDay) Before(arg2 int) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (Day)(SwigcptrDay(C._wrap_Day_before_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrDay) GetLunarDay() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Day_getLunarDay_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetLunarMonth() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_Day_getLunarMonth_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetLunarYear__SWIG_0(arg2 bool) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (int)(C._wrap_Day_getLunarYear__SWIG_0_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrDay) GetLunarYear__SWIG_1() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Day_getLunarYear__SWIG_1_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (p SwigcptrDay) GetLunarYear(a ...interface{}) int { + argc := len(a) + if argc == 0 { + return p.GetLunarYear__SWIG_1() + } + if argc == 1 { + return p.GetLunarYear__SWIG_0(a[0].(bool)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrDay) GetYearGZ__SWIG_0(arg2 bool) (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (GZ)(SwigcptrGZ(C._wrap_Day_getYearGZ__SWIG_0_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrDay) GetYearGZ__SWIG_1() (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + swig_r = (GZ)(SwigcptrGZ(C._wrap_Day_getYearGZ__SWIG_1_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrDay) GetYearGZ(a ...interface{}) GZ { + argc := len(a) + if argc == 0 { + return p.GetYearGZ__SWIG_1() + } + if argc == 1 { + return p.GetYearGZ__SWIG_0(a[0].(bool)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrDay) GetMonthGZ() (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + swig_r = (GZ)(SwigcptrGZ(C._wrap_Day_getMonthGZ_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrDay) GetDayGZ() (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + swig_r = (GZ)(SwigcptrGZ(C._wrap_Day_getDayGZ_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrDay) GetHourGZ(arg2 byte) (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (GZ)(SwigcptrGZ(C._wrap_Day_getHourGZ_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.char(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrDay) IsLunarLeap() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_Day_isLunarLeap_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetSolarYear() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Day_getSolarYear_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetSolarMonth() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_Day_getSolarMonth_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetSolarDay() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Day_getSolarDay_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetWeek() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_Day_getWeek_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetWeekIndex() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_Day_getWeekIndex_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) HasJieQi() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_Day_hasJieQi_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetJieQi() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_Day_getJieQi_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetJieQiJD() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_Day_getJieQiJD_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetConstellation() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_Day_getConstellation_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteDay(arg1 Day) { + _swig_i_0 := arg1.Swigcptr() + C._wrap_delete_Day_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0)) +} + +type Day interface { + Swigcptr() uintptr + SwigIsDay() + After(arg2 int) (_swig_ret Day) + Before(arg2 int) (_swig_ret Day) + GetLunarDay() (_swig_ret int) + GetLunarMonth() (_swig_ret byte) + GetLunarYear(a ...interface{}) int + GetYearGZ(a ...interface{}) GZ + GetMonthGZ() (_swig_ret GZ) + GetDayGZ() (_swig_ret GZ) + GetHourGZ(arg2 byte) (_swig_ret GZ) + IsLunarLeap() (_swig_ret bool) + GetSolarYear() (_swig_ret int) + GetSolarMonth() (_swig_ret byte) + GetSolarDay() (_swig_ret int) + GetWeek() (_swig_ret byte) + GetWeekIndex() (_swig_ret byte) + HasJieQi() (_swig_ret bool) + GetJieQi() (_swig_ret byte) + GetJieQiJD() (_swig_ret float64) + GetConstellation() (_swig_ret byte) +} + +func FromSolar(arg1 int, arg2 byte, arg3 int) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (Day)(SwigcptrDay(C._wrap_fromSolar_sxtwl_258d85b6700e030a(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func FromLunar__SWIG_0(arg1 int, arg2 byte, arg3 int, arg4 bool) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (Day)(SwigcptrDay(C._wrap_fromLunar__SWIG_0_sxtwl_258d85b6700e030a(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C.swig_intgo(_swig_i_2), C._Bool(_swig_i_3)))) + return swig_r +} + +func FromLunar__SWIG_1(arg1 int, arg2 byte, arg3 int) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (Day)(SwigcptrDay(C._wrap_fromLunar__SWIG_1_sxtwl_258d85b6700e030a(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func FromLunar(a ...interface{}) Day { + argc := len(a) + if argc == 3 { + return FromLunar__SWIG_1(a[0].(int), a[1].(byte), a[2].(int)) + } + if argc == 4 { + return FromLunar__SWIG_0(a[0].(int), a[1].(byte), a[2].(int), a[3].(bool)) + } + panic("No match for overloaded function call") +} + +func SiZhu2Year(arg1 GZ, arg2 GZ, arg3 GZ, arg4 GZ, arg5 int, arg6 int) (_swig_ret JDList) { + var swig_r JDList + _swig_i_0 := arg1.Swigcptr() + _swig_i_1 := arg2.Swigcptr() + _swig_i_2 := arg3.Swigcptr() + _swig_i_3 := arg4.Swigcptr() + _swig_i_4 := arg5 + _swig_i_5 := arg6 + swig_r = (JDList)(SwigcptrJDList(C._wrap_siZhu2Year_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_intgo(_swig_i_4), C.swig_intgo(_swig_i_5)))) + return swig_r +} + +func GetShiGz(arg1 byte, arg2 byte) (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (GZ)(SwigcptrGZ(C._wrap_getShiGz_sxtwl_258d85b6700e030a(C.char(_swig_i_0), C.char(_swig_i_1)))) + return swig_r +} + +func GetRunMonth(arg1 int) (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_getRunMonth_sxtwl_258d85b6700e030a(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func GetLunarMonthNum__SWIG_0(arg1 int, arg2 byte, arg3 bool) (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (byte)(C._wrap_getLunarMonthNum__SWIG_0_sxtwl_258d85b6700e030a(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C._Bool(_swig_i_2))) + return swig_r +} + +func GetLunarMonthNum__SWIG_1(arg1 int, arg2 byte) (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (byte)(C._wrap_getLunarMonthNum__SWIG_1_sxtwl_258d85b6700e030a(C.swig_intgo(_swig_i_0), C.char(_swig_i_1))) + return swig_r +} + +func GetLunarMonthNum(a ...interface{}) byte { + argc := len(a) + if argc == 2 { + return GetLunarMonthNum__SWIG_1(a[0].(int), a[1].(byte)) + } + if argc == 3 { + return GetLunarMonthNum__SWIG_0(a[0].(int), a[1].(byte), a[2].(bool)) + } + panic("No match for overloaded function call") +} + +func JD2DD(arg1 float64) (_swig_ret Time) { + var swig_r Time + _swig_i_0 := arg1 + swig_r = (Time)(SwigcptrTime(C._wrap_JD2DD_sxtwl_258d85b6700e030a(C.double(_swig_i_0)))) + return swig_r +} + +func ToJD(arg1 Time) (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1.Swigcptr() + swig_r = (float64)(C._wrap_toJD_sxtwl_258d85b6700e030a(C.uintptr_t(_swig_i_0))) + return swig_r +} + + diff --git a/example/main.cpp b/example/main.cpp new file mode 100644 index 0000000..1e6be0b --- /dev/null +++ b/example/main.cpp @@ -0,0 +1,203 @@ +#include +#include +#include +#include "const.h" +#include "sxtwl.h" + + +//=============================================================== +#ifdef _WIN32 +class MBuf : public std::stringbuf +{ + public: + int sync() + { + fputs(str().c_str(), stdout); + str(""); + return 0; + } +}; +#endif + + +//=============================================================== + +static const char *Gan[] = {"甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"}; +static const char *Zhi[] = {"子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"}; +static const char *ShX[] = {"鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪"}; +static const char *numCn[] = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十"}; //中文数字 +static const char *jqmc[] = {"冬至", "小寒", "大寒", "立春", "雨水", "惊蛰", "春分", "清明", "谷雨", "立夏", "小满", "芒种", "夏至", "小暑", "大暑", "立秋", "处暑", "白露", "秋分", "寒露", "霜降", "立冬", "小雪", "大雪"}; +static const char *ymc[] = { "正", "二", "三", "四", "五", "六", "七", "八", "九", "十","十一", "十二"}; //月名称,建寅 +static const char *rmc[] = {"初一", "初二", "初三", "初四", "初五", "初六", "初七", "初八", "初九", "初十", "十一", "十二", "十三", "十四", "十五", "十六", "十七", "十八", "十九", "二十", "廿一", "廿二", "廿三", "廿四", "廿五", "廿六", "廿七", "廿八", "廿九", "三十", "卅一"}; +static const char *WeekCn[] = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"}; + + +GZ getGZ(std::string tgStr, std::string dzStr) { + int tg = -1; + int dz = -1; + for (size_t i = 0; i < 10; i++) + { + if (std::string(Gan[i]) == tgStr) { + tg = i; + break; + } + } + + for (size_t i = 0; i < 12; i++) + { + if (std::string(Zhi[i]) == dzStr) { + dz = i; + break; + } + } + return GZ(tg, dz); +} + + + +void printDay(Day& day) +{ + + std::cout << "\n===================================================" << std::endl; + + // 公历 + std::cout << "公历：" << day.getSolarYear() << "年" + << (int)day.getSolarMonth() << "月" + << day.getSolarDay() << "日" << std::endl; + + // 农历 + std::cout << "农历：" << (day.isLunarLeap()? "闰":"") + << ymc[day.getLunarMonth() - 1] << "月" + << rmc[day.getLunarDay() - 1] << "日" << std::endl; + + // 星期几 + std::cout << "星期:" << WeekCn[day.getWeek()] << std::endl; + + //年天二地支 + std::cout << "天干:" + << Gan[day.getYearGZ().tg] << Zhi[day.getYearGZ().dz] << "年" + << Gan[day.getMonthGZ().tg] << Zhi[day.getMonthGZ().dz] << "月" + << Gan[day.getMonthGZ().tg] << Zhi[day.getMonthGZ().dz] << "日" + << std::endl; +}; + +int round_double(double number) +{ + return (number > 0.0) ? (number + 0.5) : (number - 0.5); +} + +int main() +{ + +//#ifdef _WIN32 + ////http://m.blog.csdn.net/article/details?id=52789570 + //https://stackoverflow.com/questions/45575863/how-to-print-utf-8-strings-to-stdcout-on-windows + setvbuf(stdout, nullptr, _IONBF, 0); + MBuf buf; + std::cout.rdbuf(&buf); +//#endif + + + + + GZ hourGZ = sxtwl::getShiGz(0, 23, false); + + do { + Day* day = sxtwl::fromSolar(2021, 11, 14); + day->getHourGZ(8); + auto ret = sxtwl::siZhu2Year(day->getYearGZ(), day->getMonthGZ(), day->getDayGZ(), getGZ("癸", "巳"), 2021, 2025); + printf("%d", ret.size()); + } while (false); + + do { + Day* day = sxtwl::fromSolar(1392, 1, 1); + for (int i = 0; i < 365; ++i) { + day = day->after(1); + if (day->hasJieQi()) { + auto jd = day->getJieQiJD(); + auto t = sxtwl::JD2DD(jd); + std::cout <getJieQi()] << ": " << t.getYear() << "-" << t.getMonth() << "-" + << t.getDay() << " " << int(t.getHour()) << ":" << int(t.getMin()) << ":" << round_double(t.getSec()) + << std::endl; + } + } + } while (false); + + + + + // 获取一年当中的闰月 + for(auto i = 1; i <= 3000; ++i) + { + auto lunMonth = (int)sxtwl::getRunMonth(i); + if(lunMonth <= 0) continue; + printf("%d年 闰%d月\n", i, lunMonth); + } + + //从阳历获取一个day对像 + Day* day = sxtwl::fromSolar(118, 10, 3); + printDay(*day); + for(auto i = 0; i < 100; ++i){ + day = day->after(1); + printDay(*day); + } + + // 阳历转阴历 + { + Day* day = sxtwl::fromSolar(2021, 11, 7); + std::cout << "农历:" << day->getLunarYear() << "年" << (int)day->getLunarMonth() << "月" << day-> getLunarDay() << "日" << std::endl; + + + day = sxtwl::fromLunar( day->getLunarYear(), day->getLunarMonth(), day-> getLunarDay(), day->isLunarLeap()); + std::cout << "公历:" << day->getSolarYear() << "年" << (int)day->getSolarMonth() << "月" << day-> getSolarDay() << "日" << std::endl; + + sxtwl::getShiGz(day->getDayGZ().tg, 0); + + auto c = day->getConstellation(); + printf("%c", c); + + if( day->hasJieQi()){ + auto jd = day->getJieQiJD(); + auto t = sxtwl::JD2DD(jd); + jd = sxtwl::toJD(t); + } + + auto ret = sxtwl::siZhu2Year(day->getYearGZ(), day->getMonthGZ(), day->getDayGZ(), + GZ(0, 0) + , 2003, 2029); + + + /* printf("finish");*/ + + } + { + + + + Day* day = sxtwl::fromSolar(202, 1, 20); + if (day->hasJieQi()) { + auto t = sxtwl::JD2DD(day->getJieQiJD()); + std::cout << jqmc[day->getJieQi()] << ": " << t.getYear() << "-" << t.getMonth() << "-" + << t.getDay() << " " << int(t.getHour()) << ":" << int(t.getMin()) << ":" << round_double(t.getSec()) + << std::endl; + } + delete day; + + } + + + //=========================================================================== + auto ret = sxtwl::getJieQiByYear(202); + + for (auto it = ret.begin(); it != ret.end(); ++it) { + auto t = sxtwl::JD2DD(it->jd); + std::cout << jqmc[it->jqIndex] << ": " << t.getYear() << "-" << t.getMonth() << "-" + << t.getDay() << " " << int(t.getHour()) << ":" << int(t.getMin()) << ":" << round_double(t.getSec()) + << std::endl; + } + + Time t(202, 1, 23, 12, 0, 0); + auto jd = sxtwl::toJD(t) - J2000; +//=========================================================================== + return 0; +} diff --git a/example/main.py b/example/main.py new file mode 100644 index 0000000..3195271 --- /dev/null +++ b/example/main.py @@ -0,0 +1,189 @@ +import sxtwl + +## 一些常量文字的定义。 +Gan = ["甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"] +Zhi = ["子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"] +ShX = ["鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪"] +numCn = ["零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十"] +jqmc = ["冬至", "小寒", "大寒", "立春", "雨水", "惊蛰", "春分", "清明", "谷雨", "立夏", + "小满", "芒种", "夏至", "小暑", "大暑", "立秋", "处暑","白露", "秋分", "寒露", "霜降", + "立冬", "小雪", "大雪"] +ymc = [ "正", "二", "三", "四", "五", "六", "七", "八", "九", "十", "十一", "十二" ] +rmc = ["初一", "初二", "初三", "初四", "初五", "初六", "初七", "初八", "初九", "初十", + "十一", "十二", "十三", "十四", "十五", "十六", "十七", "十八", "十九", "二十", + "廿一", "廿二", "廿三", "廿四", "廿五", "廿六", "廿七", "廿八", "廿九", "三十", "卅一"] +XiZ = ['摩羯', '水瓶', '双鱼', '白羊', '金牛', '双子', '巨蟹', '狮子', '处女', '天秤', '天蝎', '射手'] +WeekCn = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"] + + +# 从公历年月日获取一天的信息 +day = sxtwl.fromSolar(2021, 11, 7) + +# 从农历年月日获取一天的信息 +# day = sxtwl.fromLunar(2020, 12, 1) +# 如果是想查闰月，第四个参数加一个True即可 +# day = sxtwl.fromLunar(2020, 4, 1, True) + +# 公历的年月日 +s = "公历:%d年%d月%d日" % (day.getSolarYear(), day.getSolarMonth(), day.getSolarDay()) +print(s) + +# 星期几 +print(WeekCn[day.getWeek()]) + +# 这个月的第几周 +print('该日属于这个月的第%d周'%(day.getWeekIndex(),)) + +# 星座 +print("星座:", XiZ[day.getConstellation()]) + +# 以春节为界的农历(注getLunarYear如果没有传参，或者传true，是以春节为界的) +s = "农历:%d年%s%d月%d日" % (day.getLunarYear(), '闰' if day.isLunarLeap() else '', day.getLunarMonth(), day.getLunarDay()) +print(s) + +# 不以立春为界的农历 +s = "农历:%d年%s%d月%d日" % (day.getLunarYear(False), '闰' if day.isLunarLeap() else '', day.getLunarMonth(), day.getLunarDay()) +print(s) + +# 使用中文表示农历 +s = "农历:%d年%s%d月%d日" % (day.getLunarYear(False), '闰' if day.isLunarLeap() else '', ymc[day.getLunarMonth() - 1], rmc[day.getLunarDay() - 1]) +print(s) + +# 以春节为界的天干地支 +yTG = day.getYearGZ(True) +print("以春节为界的年干支", Gan[yTG.tg] + Zhi[yTG.dz]) +print("以春节为界的生肖:", ShX[yTG.dz]) + +# 以立春为界的天干地支 （注，如果没有传参，或者传false，是以立春为界的。刚好和getLunarYear相反） +yTG = day.getYearGZ() +print("以立春为界的年干支", Gan[yTG.tg] + Zhi[yTG.dz]) +print("以立春为界的生肖:", ShX[yTG.dz]) + +#月干支 +mTG = day.getMonthGZ() +print("月干支", Gan[mTG.tg] + Zhi[mTG.dz]) + +#日干支 +dTG = day.getDayGZ() +print("日干支", Gan[dTG.tg] + Zhi[dTG.dz]) + +#时干支,传24小时制的时间，默认分早晚子时 +hour = 18 +sTG = day.getHourGZ(hour) +print("%d时的干支"%(hour, ), Gan[sTG.tg] + Zhi[sTG.dz]) + + +# 如果想非早晚子时，第二个参数设置成false（注意，如果使用非早晚子时，那么Day要使用第二天的，相当于23点换日） +hour = 23 +sTG = day.getHourGZ(hour, False) +print("%d时的干支"%(hour, ), Gan[sTG.tg] + Zhi[sTG.dz]) + + +#时干支 +for hour in range(24): + # 第一个参数为该天的天干，第二个参数为小时 + hTG = sxtwl.getShiGz(dTG.tg, hour) + print("%d时天干地支:"%(hour), Gan[hTG.tg] + Zhi[hTG.dz]) + + +# 当日是否有节气 +if day.hasJieQi(): + print('节气：%s'% jqmc[day.getJieQi()]) + #获取节气的儒略日数 + jd = day.getJieQiJD() + # 将儒略日数转换成年月日时秒 + t = sxtwl.JD2DD(jd ) + + # 注意，t.s是小数，需要四舍五入 + print("节气时间:%d-%d-%d %d:%d:%d"%(t.Y, t.M, t.D, t.h, t.m, round(t.s))) +else: + print("当天不是节气日") + +###================================================================================== +# 四柱反查工具方法 +# 实际项目中不要这样子搞哈，因为汉字utf-8，GBK2312不同的编码。建议还是直接使用天干地支的数字索引 +def getGZ(gzStr): + tg = -1 + dz = -1 + for i, v in enumerate(Gan): + if gzStr[0] == v: + tg = i + break + + for i, v in enumerate(Zhi): + if gzStr[1] == v: + dz = i + break + return sxtwl.GZ(tg, dz) +###================================================================================== + +# 四注反查 分别传的是年天干，月天干，日天干，时天干， 开始查询年，结束查询年 返回满足条件的儒略日数 +jds = sxtwl.siZhu2Year(getGZ('辛丑'), getGZ('己亥'), getGZ('丙寅'), getGZ('癸巳'), 2003, 2029); +for jd in jds: + t = sxtwl.JD2DD(jd ) + print("符合条件的时间:%d-%d-%d %d:%d:%d"%(t.Y, t.M, t.D, t.h, t.m, round(t.s))) + + +# 获取一年中的闰月 +year = 2020 +month = sxtwl.getRunMonth(year) +if month >= 0: + print("%d年的闰月是%d"%(year, month) ) +else: + print("没有闰月") + + +# 一个农历月的天数 +year = 2020 #农历年 +month = 4 #农历月 +isRun = False #是否是闰月 +daynum = sxtwl.getLunarMonthNum(year, month, isRun) +print("农历%d年%s%d月的天数:"%(year, '闰'if isRun else '', month), daynum) + + +#儒略日数转公历 +jd = sxtwl.J2000 +t = sxtwl.JD2DD(jd ) + +#公历转儒略日 +jd = sxtwl.toJD(t) + +# 获取某天的后面几天 +num = 1 #你喜欢写多少天 也多少天，可以写负数，相当于往前 +day = day.after(num) #获取num天后的日信息 +s = "公历:%d年%d月%d日" % (day.getSolarYear(), day.getSolarMonth(), day.getSolarDay()) +print(s) + +# 同上 +day = day.before(num) +s = "公历:%d年%d月%d日" % (day.getSolarYear(), day.getSolarMonth(), day.getSolarDay()) +print(s) + + +# 查找某日前后的节气 +while True: + # 这里可以使用after或者before，不用担心速度，这里的计算在底层仅仅是+1这么简单 + day = day.after(1) + # hasJieQi的接口比getJieQiJD速度要快，你也可以使用getJieQiJD来判断是否有节气。 + if day.hasJieQi(): + print('节气：%s'% jqmc[day.getJieQi()]) + #获取节气的儒略日数， 如果说你要计算什么时间的相距多少，直接比对儒略日要方便，相信我。 + jd = day.getJieQiJD() + + # 将儒略日数转换成年月日时秒 + t = sxtwl.JD2DD(jd ) + + # 注意，t.s是小数，需要四舍五入 + print("节气时间:%d-%d-%d %d:%d:%d"%(t.Y, t.M, t.D, t.h, t.m, round(t.s))) + + break + +### 快速获取一年的节气时间 （注意，网页版的寿星天文历，202年1月份的大寒显示是不对的） +ret = sxtwl.getJieQiByYear(202) + +for v in ret: + # 将儒略日数转换成年月日时秒 + t = sxtwl.JD2DD(v.jd) + print('节气：%s 节气时间:%d-%d-%d %d:%d:%d'% (jqmc[v.jqIndex],t.Y, t.M, t.D, t.h, t.m, round(t.s))) + + \ No newline at end of file diff --git a/export.sh b/export.sh new file mode 100644 index 0000000..2955d2d --- /dev/null +++ b/export.sh @@ -0,0 +1,26 @@ +#php +# swig -c++ -php5 -outcurrentdir -outdir export/php5 swig/sxtwl.i +# mv sxtwl_wrap.cxx export/php5/sxtwl_wrap.cxx + +swig -c++ -php7 -outcurrentdir -outdir export/php7 swig/sxtwl.i +mv sxtwl_wrap.cxx export/php7/sxtwl_wrap.cxx + +# lua +swig -c++ -lua -outcurrentdir -outdir export/lua swig/sxtwl.i +mv sxtwl_wrap.cxx export/lua/sxtwl_wrap.cxx + +# java +swig -c++ -java -outcurrentdir -outdir export/java -package com.seantone.sxtwl swig/sxtwl.i +mv sxtwl_wrap.cxx export/java/sxtwl_wrap.cxx + +# C# +swig -c++ -csharp -outcurrentdir -outdir export/C# swig/sxtwl.i +mv sxtwl_wrap.cxx export/C#/sxtwl_wrap.cxx + +# go +swig -c++ -go -cgo -intgosize 32 -outdir export/golang swig/sxtwl.i +mv swig/sxtwl_wrap.cxx export/golang/sxtwl_wrap.cxx + +# python +swig -c++ -python -outdir python swig/sxtwl.i +mv swig/sxtwl_wrap.cxx python/sxtwl_wrap.cxx \ No newline at end of file diff --git a/export/C#/Day.cs b/export/C#/Day.cs new file mode 100644 index 0000000..592ee8c --- /dev/null +++ b/export/C#/Day.cs @@ -0,0 +1,189 @@ +//------------------------------------------------------------------------------ +// +// +// 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. +//------------------------------------------------------------------------------ + + +public class Day : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Day(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Day obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + internal static global::System.Runtime.InteropServices.HandleRef swigRelease(Day obj) { + if (obj != null) { + if (!obj.swigCMemOwn) + throw new global::System.ApplicationException("Cannot release ownership as memory is not owned"); + global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.Dispose(); + return ptr; + } else { + return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + } + + ~Day() { + Dispose(false); + } + + public void Dispose() { + Dispose(true); + global::System.GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + sxtwlPINVOKE.delete_Day(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + } + } + + public static Day fromSolar(int _year, byte _month, int _day) { + global::System.IntPtr cPtr = sxtwlPINVOKE.Day_fromSolar(_year, _month, _day); + Day ret = (cPtr == global::System.IntPtr.Zero) ? null : new Day(cPtr, false); + return ret; + } + + public static Day fromLunar(int year, byte month, int day, bool isRun) { + global::System.IntPtr cPtr = sxtwlPINVOKE.Day_fromLunar__SWIG_0(year, month, day, isRun); + Day ret = (cPtr == global::System.IntPtr.Zero) ? null : new Day(cPtr, false); + return ret; + } + + public static Day fromLunar(int year, byte month, int day) { + global::System.IntPtr cPtr = sxtwlPINVOKE.Day_fromLunar__SWIG_1(year, month, day); + Day ret = (cPtr == global::System.IntPtr.Zero) ? null : new Day(cPtr, false); + return ret; + } + + public Day after(int day) { + global::System.IntPtr cPtr = sxtwlPINVOKE.Day_after(swigCPtr, day); + Day ret = (cPtr == global::System.IntPtr.Zero) ? null : new Day(cPtr, false); + return ret; + } + + public Day before(int day) { + global::System.IntPtr cPtr = sxtwlPINVOKE.Day_before(swigCPtr, day); + Day ret = (cPtr == global::System.IntPtr.Zero) ? null : new Day(cPtr, false); + return ret; + } + + public int getLunarDay() { + int ret = sxtwlPINVOKE.Day_getLunarDay(swigCPtr); + return ret; + } + + public byte getLunarMonth() { + byte ret = sxtwlPINVOKE.Day_getLunarMonth(swigCPtr); + return ret; + } + + public int getLunarYear(bool chineseNewYearBoundary) { + int ret = sxtwlPINVOKE.Day_getLunarYear__SWIG_0(swigCPtr, chineseNewYearBoundary); + return ret; + } + + public int getLunarYear() { + int ret = sxtwlPINVOKE.Day_getLunarYear__SWIG_1(swigCPtr); + return ret; + } + + public GZ getYearGZ(bool chineseNewYearBoundary) { + GZ ret = new GZ(sxtwlPINVOKE.Day_getYearGZ__SWIG_0(swigCPtr, chineseNewYearBoundary), true); + return ret; + } + + public GZ getYearGZ() { + GZ ret = new GZ(sxtwlPINVOKE.Day_getYearGZ__SWIG_1(swigCPtr), true); + return ret; + } + + public GZ getMonthGZ() { + GZ ret = new GZ(sxtwlPINVOKE.Day_getMonthGZ(swigCPtr), true); + return ret; + } + + public GZ getDayGZ() { + GZ ret = new GZ(sxtwlPINVOKE.Day_getDayGZ(swigCPtr), true); + return ret; + } + + public GZ getHourGZ(byte hour, bool isZaoWanZiShi) { + GZ ret = new GZ(sxtwlPINVOKE.Day_getHourGZ__SWIG_0(swigCPtr, hour, isZaoWanZiShi), true); + return ret; + } + + public GZ getHourGZ(byte hour) { + GZ ret = new GZ(sxtwlPINVOKE.Day_getHourGZ__SWIG_1(swigCPtr, hour), true); + return ret; + } + + public bool isLunarLeap() { + bool ret = sxtwlPINVOKE.Day_isLunarLeap(swigCPtr); + return ret; + } + + public int getSolarYear() { + int ret = sxtwlPINVOKE.Day_getSolarYear(swigCPtr); + return ret; + } + + public byte getSolarMonth() { + byte ret = sxtwlPINVOKE.Day_getSolarMonth(swigCPtr); + return ret; + } + + public int getSolarDay() { + int ret = sxtwlPINVOKE.Day_getSolarDay(swigCPtr); + return ret; + } + + public byte getWeek() { + byte ret = sxtwlPINVOKE.Day_getWeek(swigCPtr); + return ret; + } + + public byte getWeekIndex() { + byte ret = sxtwlPINVOKE.Day_getWeekIndex(swigCPtr); + return ret; + } + + public bool hasJieQi() { + bool ret = sxtwlPINVOKE.Day_hasJieQi(swigCPtr); + return ret; + } + + public byte getJieQi() { + byte ret = sxtwlPINVOKE.Day_getJieQi(swigCPtr); + return ret; + } + + public double getJieQiJD() { + double ret = sxtwlPINVOKE.Day_getJieQiJD(swigCPtr); + return ret; + } + + public byte getConstellation() { + byte ret = sxtwlPINVOKE.Day_getConstellation(swigCPtr); + return ret; + } + +} diff --git a/export/C#/GZ.cs b/export/C#/GZ.cs new file mode 100644 index 0000000..9de8cbf --- /dev/null +++ b/export/C#/GZ.cs @@ -0,0 +1,85 @@ +//------------------------------------------------------------------------------ +// +// +// 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. +//------------------------------------------------------------------------------ + + +public class GZ : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal GZ(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(GZ obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + internal static global::System.Runtime.InteropServices.HandleRef swigRelease(GZ obj) { + if (obj != null) { + if (!obj.swigCMemOwn) + throw new global::System.ApplicationException("Cannot release ownership as memory is not owned"); + global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.Dispose(); + return ptr; + } else { + return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + } + + ~GZ() { + Dispose(false); + } + + public void Dispose() { + Dispose(true); + global::System.GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + sxtwlPINVOKE.delete_GZ(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + } + } + + public GZ() : this(sxtwlPINVOKE.new_GZ__SWIG_0(), true) { + } + + public GZ(byte tg, byte dz) : this(sxtwlPINVOKE.new_GZ__SWIG_1(tg, dz), true) { + } + + public byte tg { + set { + sxtwlPINVOKE.GZ_tg_set(swigCPtr, value); + } + get { + byte ret = sxtwlPINVOKE.GZ_tg_get(swigCPtr); + return ret; + } + } + + public byte dz { + set { + sxtwlPINVOKE.GZ_dz_set(swigCPtr, value); + } + get { + byte ret = sxtwlPINVOKE.GZ_dz_get(swigCPtr); + return ret; + } + } + +} diff --git a/export/C#/JDList.cs b/export/C#/JDList.cs new file mode 100644 index 0000000..1ebbe7c --- /dev/null +++ b/export/C#/JDList.cs @@ -0,0 +1,355 @@ +//------------------------------------------------------------------------------ +// +// +// 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. +//------------------------------------------------------------------------------ + + +public class JDList : global::System.IDisposable, global::System.Collections.IEnumerable, global::System.Collections.Generic.IList + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal JDList(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(JDList obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + internal static global::System.Runtime.InteropServices.HandleRef swigRelease(JDList obj) { + if (obj != null) { + if (!obj.swigCMemOwn) + throw new global::System.ApplicationException("Cannot release ownership as memory is not owned"); + global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.Dispose(); + return ptr; + } else { + return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + } + + ~JDList() { + Dispose(false); + } + + public void Dispose() { + Dispose(true); + global::System.GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + sxtwlPINVOKE.delete_JDList(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + } + } + + public JDList(global::System.Collections.IEnumerable c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (double element in c) { + this.Add(element); + } + } + + public JDList(global::System.Collections.Generic.IEnumerable c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (double element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public double this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < 0 || (uint)value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(double[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(double[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, double[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new JDListEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new JDListEnumerator(this); + } + + public JDListEnumerator GetEnumerator() { + return new JDListEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class JDListEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private JDList collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public JDListEnumerator(JDList collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public double Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (double)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + sxtwlPINVOKE.JDList_Clear(swigCPtr); + } + + public void Add(double x) { + sxtwlPINVOKE.JDList_Add(swigCPtr, x); + } + + private uint size() { + uint ret = sxtwlPINVOKE.JDList_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = sxtwlPINVOKE.JDList_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + sxtwlPINVOKE.JDList_reserve(swigCPtr, n); + } + + public JDList() : this(sxtwlPINVOKE.new_JDList__SWIG_0(), true) { + } + + public JDList(JDList other) : this(sxtwlPINVOKE.new_JDList__SWIG_1(JDList.getCPtr(other)), true) { + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public JDList(int capacity) : this(sxtwlPINVOKE.new_JDList__SWIG_2(capacity), true) { + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + private double getitemcopy(int index) { + double ret = sxtwlPINVOKE.JDList_getitemcopy(swigCPtr, index); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private double getitem(int index) { + double ret = sxtwlPINVOKE.JDList_getitem(swigCPtr, index); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, double val) { + sxtwlPINVOKE.JDList_setitem(swigCPtr, index, val); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(JDList values) { + sxtwlPINVOKE.JDList_AddRange(swigCPtr, JDList.getCPtr(values)); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public JDList GetRange(int index, int count) { + global::System.IntPtr cPtr = sxtwlPINVOKE.JDList_GetRange(swigCPtr, index, count); + JDList ret = (cPtr == global::System.IntPtr.Zero) ? null : new JDList(cPtr, true); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, double x) { + sxtwlPINVOKE.JDList_Insert(swigCPtr, index, x); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, JDList values) { + sxtwlPINVOKE.JDList_InsertRange(swigCPtr, index, JDList.getCPtr(values)); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + sxtwlPINVOKE.JDList_RemoveAt(swigCPtr, index); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + sxtwlPINVOKE.JDList_RemoveRange(swigCPtr, index, count); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public static JDList Repeat(double value, int count) { + global::System.IntPtr cPtr = sxtwlPINVOKE.JDList_Repeat(value, count); + JDList ret = (cPtr == global::System.IntPtr.Zero) ? null : new JDList(cPtr, true); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + sxtwlPINVOKE.JDList_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + sxtwlPINVOKE.JDList_Reverse__SWIG_1(swigCPtr, index, count); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, JDList values) { + sxtwlPINVOKE.JDList_SetRange(swigCPtr, index, JDList.getCPtr(values)); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Contains(double value) { + bool ret = sxtwlPINVOKE.JDList_Contains(swigCPtr, value); + return ret; + } + + public int IndexOf(double value) { + int ret = sxtwlPINVOKE.JDList_IndexOf(swigCPtr, value); + return ret; + } + + public int LastIndexOf(double value) { + int ret = sxtwlPINVOKE.JDList_LastIndexOf(swigCPtr, value); + return ret; + } + + public bool Remove(double value) { + bool ret = sxtwlPINVOKE.JDList_Remove(swigCPtr, value); + return ret; + } + +} diff --git a/export/C#/JQList.cs b/export/C#/JQList.cs new file mode 100644 index 0000000..d69668b --- /dev/null +++ b/export/C#/JQList.cs @@ -0,0 +1,336 @@ +//------------------------------------------------------------------------------ +// +// +// 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. +//------------------------------------------------------------------------------ + + +public class JQList : global::System.IDisposable, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal JQList(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(JQList obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + internal static global::System.Runtime.InteropServices.HandleRef swigRelease(JQList obj) { + if (obj != null) { + if (!obj.swigCMemOwn) + throw new global::System.ApplicationException("Cannot release ownership as memory is not owned"); + global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.Dispose(); + return ptr; + } else { + return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + } + + ~JQList() { + Dispose(false); + } + + public void Dispose() { + Dispose(true); + global::System.GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + sxtwlPINVOKE.delete_JQList(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + } + } + + public JQList(global::System.Collections.IEnumerable c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (JieQiInfo element in c) { + this.Add(element); + } + } + + public JQList(global::System.Collections.Generic.IEnumerable c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (JieQiInfo element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public JieQiInfo this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < 0 || (uint)value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(JieQiInfo[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(JieQiInfo[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, JieQiInfo[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new JQListEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new JQListEnumerator(this); + } + + public JQListEnumerator GetEnumerator() { + return new JQListEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class JQListEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private JQList collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public JQListEnumerator(JQList collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public JieQiInfo Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (JieQiInfo)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + sxtwlPINVOKE.JQList_Clear(swigCPtr); + } + + public void Add(JieQiInfo x) { + sxtwlPINVOKE.JQList_Add(swigCPtr, JieQiInfo.getCPtr(x)); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = sxtwlPINVOKE.JQList_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = sxtwlPINVOKE.JQList_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + sxtwlPINVOKE.JQList_reserve(swigCPtr, n); + } + + public JQList() : this(sxtwlPINVOKE.new_JQList__SWIG_0(), true) { + } + + public JQList(JQList other) : this(sxtwlPINVOKE.new_JQList__SWIG_1(JQList.getCPtr(other)), true) { + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public JQList(int capacity) : this(sxtwlPINVOKE.new_JQList__SWIG_2(capacity), true) { + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + private JieQiInfo getitemcopy(int index) { + JieQiInfo ret = new JieQiInfo(sxtwlPINVOKE.JQList_getitemcopy(swigCPtr, index), true); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private JieQiInfo getitem(int index) { + JieQiInfo ret = new JieQiInfo(sxtwlPINVOKE.JQList_getitem(swigCPtr, index), false); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, JieQiInfo val) { + sxtwlPINVOKE.JQList_setitem(swigCPtr, index, JieQiInfo.getCPtr(val)); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(JQList values) { + sxtwlPINVOKE.JQList_AddRange(swigCPtr, JQList.getCPtr(values)); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public JQList GetRange(int index, int count) { + global::System.IntPtr cPtr = sxtwlPINVOKE.JQList_GetRange(swigCPtr, index, count); + JQList ret = (cPtr == global::System.IntPtr.Zero) ? null : new JQList(cPtr, true); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, JieQiInfo x) { + sxtwlPINVOKE.JQList_Insert(swigCPtr, index, JieQiInfo.getCPtr(x)); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, JQList values) { + sxtwlPINVOKE.JQList_InsertRange(swigCPtr, index, JQList.getCPtr(values)); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + sxtwlPINVOKE.JQList_RemoveAt(swigCPtr, index); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + sxtwlPINVOKE.JQList_RemoveRange(swigCPtr, index, count); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public static JQList Repeat(JieQiInfo value, int count) { + global::System.IntPtr cPtr = sxtwlPINVOKE.JQList_Repeat(JieQiInfo.getCPtr(value), count); + JQList ret = (cPtr == global::System.IntPtr.Zero) ? null : new JQList(cPtr, true); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + sxtwlPINVOKE.JQList_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + sxtwlPINVOKE.JQList_Reverse__SWIG_1(swigCPtr, index, count); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, JQList values) { + sxtwlPINVOKE.JQList_SetRange(swigCPtr, index, JQList.getCPtr(values)); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + } + +} diff --git a/export/C#/JieQiInfo.cs b/export/C#/JieQiInfo.cs new file mode 100644 index 0000000..17317b8 --- /dev/null +++ b/export/C#/JieQiInfo.cs @@ -0,0 +1,82 @@ +//------------------------------------------------------------------------------ +// +// +// 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. +//------------------------------------------------------------------------------ + + +public class JieQiInfo : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal JieQiInfo(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(JieQiInfo obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + internal static global::System.Runtime.InteropServices.HandleRef swigRelease(JieQiInfo obj) { + if (obj != null) { + if (!obj.swigCMemOwn) + throw new global::System.ApplicationException("Cannot release ownership as memory is not owned"); + global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.Dispose(); + return ptr; + } else { + return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + } + + ~JieQiInfo() { + Dispose(false); + } + + public void Dispose() { + Dispose(true); + global::System.GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + sxtwlPINVOKE.delete_JieQiInfo(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + } + } + + public double jd { + set { + sxtwlPINVOKE.JieQiInfo_jd_set(swigCPtr, value); + } + get { + double ret = sxtwlPINVOKE.JieQiInfo_jd_get(swigCPtr); + return ret; + } + } + + public byte jqIndex { + set { + sxtwlPINVOKE.JieQiInfo_jqIndex_set(swigCPtr, value); + } + get { + byte ret = sxtwlPINVOKE.JieQiInfo_jqIndex_get(swigCPtr); + return ret; + } + } + + public JieQiInfo() : this(sxtwlPINVOKE.new_JieQiInfo(), true) { + } + +} diff --git a/export/C#/Time.cs b/export/C#/Time.cs new file mode 100644 index 0000000..bd133b6 --- /dev/null +++ b/export/C#/Time.cs @@ -0,0 +1,179 @@ +//------------------------------------------------------------------------------ +// +// +// 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. +//------------------------------------------------------------------------------ + + +public class Time : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Time(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Time obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + internal static global::System.Runtime.InteropServices.HandleRef swigRelease(Time obj) { + if (obj != null) { + if (!obj.swigCMemOwn) + throw new global::System.ApplicationException("Cannot release ownership as memory is not owned"); + global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.Dispose(); + return ptr; + } else { + return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + } + + ~Time() { + Dispose(false); + } + + public void Dispose() { + Dispose(true); + global::System.GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + sxtwlPINVOKE.delete_Time(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + } + } + + public Time() : this(sxtwlPINVOKE.new_Time__SWIG_0(), true) { + } + + public Time(int year, int month, int day, double hour, double min, double sec) : this(sxtwlPINVOKE.new_Time__SWIG_1(year, month, day, hour, min, sec), true) { + } + + public int Y { + set { + sxtwlPINVOKE.Time_Y_set(swigCPtr, value); + } + get { + int ret = sxtwlPINVOKE.Time_Y_get(swigCPtr); + return ret; + } + } + + public int M { + set { + sxtwlPINVOKE.Time_M_set(swigCPtr, value); + } + get { + int ret = sxtwlPINVOKE.Time_M_get(swigCPtr); + return ret; + } + } + + public int D { + set { + sxtwlPINVOKE.Time_D_set(swigCPtr, value); + } + get { + int ret = sxtwlPINVOKE.Time_D_get(swigCPtr); + return ret; + } + } + + public double h { + set { + sxtwlPINVOKE.Time_h_set(swigCPtr, value); + } + get { + double ret = sxtwlPINVOKE.Time_h_get(swigCPtr); + return ret; + } + } + + public double m { + set { + sxtwlPINVOKE.Time_m_set(swigCPtr, value); + } + get { + double ret = sxtwlPINVOKE.Time_m_get(swigCPtr); + return ret; + } + } + + public double s { + set { + sxtwlPINVOKE.Time_s_set(swigCPtr, value); + } + get { + double ret = sxtwlPINVOKE.Time_s_get(swigCPtr); + return ret; + } + } + + public int getYear() { + int ret = sxtwlPINVOKE.Time_getYear(swigCPtr); + return ret; + } + + public void setYear(int year) { + sxtwlPINVOKE.Time_setYear(swigCPtr, year); + } + + public void setMonth(int month) { + sxtwlPINVOKE.Time_setMonth(swigCPtr, month); + } + + public int getMonth() { + int ret = sxtwlPINVOKE.Time_getMonth(swigCPtr); + return ret; + } + + public int getDay() { + int ret = sxtwlPINVOKE.Time_getDay(swigCPtr); + return ret; + } + + public void setDay(int day) { + sxtwlPINVOKE.Time_setDay(swigCPtr, day); + } + + public double getHour() { + double ret = sxtwlPINVOKE.Time_getHour(swigCPtr); + return ret; + } + + public void setHour(double hour) { + sxtwlPINVOKE.Time_setHour(swigCPtr, hour); + } + + public double getMin() { + double ret = sxtwlPINVOKE.Time_getMin(swigCPtr); + return ret; + } + + public void setMour(double min) { + sxtwlPINVOKE.Time_setMour(swigCPtr, min); + } + + public double getSec() { + double ret = sxtwlPINVOKE.Time_getSec(swigCPtr); + return ret; + } + + public void setSec(double sec) { + sxtwlPINVOKE.Time_setSec(swigCPtr, sec); + } + +} diff --git a/export/C#/sxtwl.cs b/export/C#/sxtwl.cs new file mode 100644 index 0000000..5e6c233 --- /dev/null +++ b/export/C#/sxtwl.cs @@ -0,0 +1,79 @@ +//------------------------------------------------------------------------------ +// +// +// 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. +//------------------------------------------------------------------------------ + + +public class sxtwl { + public static Day fromSolar(int year, byte month, int day) { + global::System.IntPtr cPtr = sxtwlPINVOKE.fromSolar(year, month, day); + Day ret = (cPtr == global::System.IntPtr.Zero) ? null : new Day(cPtr, false); + return ret; + } + + public static Day fromLunar(int year, byte month, int day, bool isRun) { + global::System.IntPtr cPtr = sxtwlPINVOKE.fromLunar__SWIG_0(year, month, day, isRun); + Day ret = (cPtr == global::System.IntPtr.Zero) ? null : new Day(cPtr, false); + return ret; + } + + public static Day fromLunar(int year, byte month, int day) { + global::System.IntPtr cPtr = sxtwlPINVOKE.fromLunar__SWIG_1(year, month, day); + Day ret = (cPtr == global::System.IntPtr.Zero) ? null : new Day(cPtr, false); + return ret; + } + + public static JDList siZhu2Year(GZ year, GZ yue, GZ ri, GZ shi, int fromYear, int toYear) { + JDList ret = new JDList(sxtwlPINVOKE.siZhu2Year(GZ.getCPtr(year), GZ.getCPtr(yue), GZ.getCPtr(ri), GZ.getCPtr(shi), fromYear, toYear), true); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static GZ getShiGz(byte dayTg, byte hour, bool isZaoWanZiShi) { + GZ ret = new GZ(sxtwlPINVOKE.getShiGz__SWIG_0(dayTg, hour, isZaoWanZiShi), true); + return ret; + } + + public static GZ getShiGz(byte dayTg, byte hour) { + GZ ret = new GZ(sxtwlPINVOKE.getShiGz__SWIG_1(dayTg, hour), true); + return ret; + } + + public static byte getRunMonth(int By) { + byte ret = sxtwlPINVOKE.getRunMonth(By); + return ret; + } + + public static byte getLunarMonthNum(int By, byte month, bool isRun) { + byte ret = sxtwlPINVOKE.getLunarMonthNum__SWIG_0(By, month, isRun); + return ret; + } + + public static byte getLunarMonthNum(int By, byte month) { + byte ret = sxtwlPINVOKE.getLunarMonthNum__SWIG_1(By, month); + return ret; + } + + public static Time JD2DD(double jd) { + Time ret = new Time(sxtwlPINVOKE.JD2DD(jd), true); + return ret; + } + + public static double toJD(Time time) { + double ret = sxtwlPINVOKE.toJD(Time.getCPtr(time)); + if (sxtwlPINVOKE.SWIGPendingException.Pending) throw sxtwlPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static JQList getJieQiByYear(int year) { + JQList ret = new JQList(sxtwlPINVOKE.getJieQiByYear(year), true); + return ret; + } + + public static readonly int J2000 = sxtwlPINVOKE.J2000_get(); +} diff --git a/export/C#/sxtwlPINVOKE.cs b/export/C#/sxtwlPINVOKE.cs new file mode 100644 index 0000000..e3bd371 --- /dev/null +++ b/export/C#/sxtwlPINVOKE.cs @@ -0,0 +1,575 @@ +//------------------------------------------------------------------------------ +// +// +// 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. +//------------------------------------------------------------------------------ + + +class sxtwlPINVOKE { + + protected class SWIGExceptionHelper { + + public delegate void ExceptionDelegate(string message); + public delegate void ExceptionArgumentDelegate(string message, string paramName); + + static ExceptionDelegate applicationDelegate = new ExceptionDelegate(SetPendingApplicationException); + static ExceptionDelegate arithmeticDelegate = new ExceptionDelegate(SetPendingArithmeticException); + static ExceptionDelegate divideByZeroDelegate = new ExceptionDelegate(SetPendingDivideByZeroException); + static ExceptionDelegate indexOutOfRangeDelegate = new ExceptionDelegate(SetPendingIndexOutOfRangeException); + static ExceptionDelegate invalidCastDelegate = new ExceptionDelegate(SetPendingInvalidCastException); + static ExceptionDelegate invalidOperationDelegate = new ExceptionDelegate(SetPendingInvalidOperationException); + static ExceptionDelegate ioDelegate = new ExceptionDelegate(SetPendingIOException); + static ExceptionDelegate nullReferenceDelegate = new ExceptionDelegate(SetPendingNullReferenceException); + static ExceptionDelegate outOfMemoryDelegate = new ExceptionDelegate(SetPendingOutOfMemoryException); + static ExceptionDelegate overflowDelegate = new ExceptionDelegate(SetPendingOverflowException); + static ExceptionDelegate systemDelegate = new ExceptionDelegate(SetPendingSystemException); + + static ExceptionArgumentDelegate argumentDelegate = new ExceptionArgumentDelegate(SetPendingArgumentException); + static ExceptionArgumentDelegate argumentNullDelegate = new ExceptionArgumentDelegate(SetPendingArgumentNullException); + static ExceptionArgumentDelegate argumentOutOfRangeDelegate = new ExceptionArgumentDelegate(SetPendingArgumentOutOfRangeException); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="SWIGRegisterExceptionCallbacks_sxtwl")] + public static extern void SWIGRegisterExceptionCallbacks_sxtwl( + ExceptionDelegate applicationDelegate, + ExceptionDelegate arithmeticDelegate, + ExceptionDelegate divideByZeroDelegate, + ExceptionDelegate indexOutOfRangeDelegate, + ExceptionDelegate invalidCastDelegate, + ExceptionDelegate invalidOperationDelegate, + ExceptionDelegate ioDelegate, + ExceptionDelegate nullReferenceDelegate, + ExceptionDelegate outOfMemoryDelegate, + ExceptionDelegate overflowDelegate, + ExceptionDelegate systemExceptionDelegate); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="SWIGRegisterExceptionArgumentCallbacks_sxtwl")] + public static extern void SWIGRegisterExceptionCallbacksArgument_sxtwl( + ExceptionArgumentDelegate argumentDelegate, + ExceptionArgumentDelegate argumentNullDelegate, + ExceptionArgumentDelegate argumentOutOfRangeDelegate); + + static void SetPendingApplicationException(string message) { + SWIGPendingException.Set(new global::System.ApplicationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingArithmeticException(string message) { + SWIGPendingException.Set(new global::System.ArithmeticException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingDivideByZeroException(string message) { + SWIGPendingException.Set(new global::System.DivideByZeroException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIndexOutOfRangeException(string message) { + SWIGPendingException.Set(new global::System.IndexOutOfRangeException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidCastException(string message) { + SWIGPendingException.Set(new global::System.InvalidCastException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidOperationException(string message) { + SWIGPendingException.Set(new global::System.InvalidOperationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIOException(string message) { + SWIGPendingException.Set(new global::System.IO.IOException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingNullReferenceException(string message) { + SWIGPendingException.Set(new global::System.NullReferenceException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOutOfMemoryException(string message) { + SWIGPendingException.Set(new global::System.OutOfMemoryException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOverflowException(string message) { + SWIGPendingException.Set(new global::System.OverflowException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingSystemException(string message) { + SWIGPendingException.Set(new global::System.SystemException(message, SWIGPendingException.Retrieve())); + } + + static void SetPendingArgumentException(string message, string paramName) { + SWIGPendingException.Set(new global::System.ArgumentException(message, paramName, SWIGPendingException.Retrieve())); + } + static void SetPendingArgumentNullException(string message, string paramName) { + global::System.Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new global::System.ArgumentNullException(paramName, message)); + } + static void SetPendingArgumentOutOfRangeException(string message, string paramName) { + global::System.Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new global::System.ArgumentOutOfRangeException(paramName, message)); + } + + static SWIGExceptionHelper() { + SWIGRegisterExceptionCallbacks_sxtwl( + applicationDelegate, + arithmeticDelegate, + divideByZeroDelegate, + indexOutOfRangeDelegate, + invalidCastDelegate, + invalidOperationDelegate, + ioDelegate, + nullReferenceDelegate, + outOfMemoryDelegate, + overflowDelegate, + systemDelegate); + + SWIGRegisterExceptionCallbacksArgument_sxtwl( + argumentDelegate, + argumentNullDelegate, + argumentOutOfRangeDelegate); + } + } + + protected static SWIGExceptionHelper swigExceptionHelper = new SWIGExceptionHelper(); + + public class SWIGPendingException { + [global::System.ThreadStatic] + private static global::System.Exception pendingException = null; + private static int numExceptionsPending = 0; + private static global::System.Object exceptionsLock = null; + + public static bool Pending { + get { + bool pending = false; + if (numExceptionsPending > 0) + if (pendingException != null) + pending = true; + return pending; + } + } + + public static void Set(global::System.Exception e) { + if (pendingException != null) + throw new global::System.ApplicationException("FATAL: An earlier pending exception from unmanaged code was missed and thus not thrown (" + pendingException.ToString() + ")", e); + pendingException = e; + lock(exceptionsLock) { + numExceptionsPending++; + } + } + + public static global::System.Exception Retrieve() { + global::System.Exception e = null; + if (numExceptionsPending > 0) { + if (pendingException != null) { + e = pendingException; + pendingException = null; + lock(exceptionsLock) { + numExceptionsPending--; + } + } + } + return e; + } + + static SWIGPendingException() { + exceptionsLock = new global::System.Object(); + } + } + + + protected class SWIGStringHelper { + + public delegate string SWIGStringDelegate(string message); + static SWIGStringDelegate stringDelegate = new SWIGStringDelegate(CreateString); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="SWIGRegisterStringCallback_sxtwl")] + public static extern void SWIGRegisterStringCallback_sxtwl(SWIGStringDelegate stringDelegate); + + static string CreateString(string cString) { + return cString; + } + + static SWIGStringHelper() { + SWIGRegisterStringCallback_sxtwl(stringDelegate); + } + } + + static protected SWIGStringHelper swigStringHelper = new SWIGStringHelper(); + + + static sxtwlPINVOKE() { + } + + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_Clear")] + public static extern void JDList_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_Add")] + public static extern void JDList_Add(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_size")] + public static extern uint JDList_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_capacity")] + public static extern uint JDList_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_reserve")] + public static extern void JDList_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_new_JDList__SWIG_0")] + public static extern global::System.IntPtr new_JDList__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_new_JDList__SWIG_1")] + public static extern global::System.IntPtr new_JDList__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_new_JDList__SWIG_2")] + public static extern global::System.IntPtr new_JDList__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_getitemcopy")] + public static extern double JDList_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_getitem")] + public static extern double JDList_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_setitem")] + public static extern void JDList_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, double jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_AddRange")] + public static extern void JDList_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_GetRange")] + public static extern global::System.IntPtr JDList_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_Insert")] + public static extern void JDList_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, double jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_InsertRange")] + public static extern void JDList_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_RemoveAt")] + public static extern void JDList_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_RemoveRange")] + public static extern void JDList_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_Repeat")] + public static extern global::System.IntPtr JDList_Repeat(double jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_Reverse__SWIG_0")] + public static extern void JDList_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_Reverse__SWIG_1")] + public static extern void JDList_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_SetRange")] + public static extern void JDList_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_Contains")] + public static extern bool JDList_Contains(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_IndexOf")] + public static extern int JDList_IndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_LastIndexOf")] + public static extern int JDList_LastIndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JDList_Remove")] + public static extern bool JDList_Remove(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_delete_JDList")] + public static extern void delete_JDList(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_Clear")] + public static extern void JQList_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_Add")] + public static extern void JQList_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_size")] + public static extern uint JQList_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_capacity")] + public static extern uint JQList_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_reserve")] + public static extern void JQList_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_new_JQList__SWIG_0")] + public static extern global::System.IntPtr new_JQList__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_new_JQList__SWIG_1")] + public static extern global::System.IntPtr new_JQList__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_new_JQList__SWIG_2")] + public static extern global::System.IntPtr new_JQList__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_getitemcopy")] + public static extern global::System.IntPtr JQList_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_getitem")] + public static extern global::System.IntPtr JQList_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_setitem")] + public static extern void JQList_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_AddRange")] + public static extern void JQList_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_GetRange")] + public static extern global::System.IntPtr JQList_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_Insert")] + public static extern void JQList_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_InsertRange")] + public static extern void JQList_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_RemoveAt")] + public static extern void JQList_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_RemoveRange")] + public static extern void JQList_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_Repeat")] + public static extern global::System.IntPtr JQList_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_Reverse__SWIG_0")] + public static extern void JQList_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_Reverse__SWIG_1")] + public static extern void JQList_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JQList_SetRange")] + public static extern void JQList_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_delete_JQList")] + public static extern void delete_JQList(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_J2000_get")] + public static extern int J2000_get(); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_new_Time__SWIG_0")] + public static extern global::System.IntPtr new_Time__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_new_Time__SWIG_1")] + public static extern global::System.IntPtr new_Time__SWIG_1(int jarg1, int jarg2, int jarg3, double jarg4, double jarg5, double jarg6); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_Y_set")] + public static extern void Time_Y_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_Y_get")] + public static extern int Time_Y_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_M_set")] + public static extern void Time_M_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_M_get")] + public static extern int Time_M_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_D_set")] + public static extern void Time_D_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_D_get")] + public static extern int Time_D_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_h_set")] + public static extern void Time_h_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_h_get")] + public static extern double Time_h_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_m_set")] + public static extern void Time_m_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_m_get")] + public static extern double Time_m_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_s_set")] + public static extern void Time_s_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_s_get")] + public static extern double Time_s_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_getYear")] + public static extern int Time_getYear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_setYear")] + public static extern void Time_setYear(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_setMonth")] + public static extern void Time_setMonth(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_getMonth")] + public static extern int Time_getMonth(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_getDay")] + public static extern int Time_getDay(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_setDay")] + public static extern void Time_setDay(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_getHour")] + public static extern double Time_getHour(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_setHour")] + public static extern void Time_setHour(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_getMin")] + public static extern double Time_getMin(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_setMour")] + public static extern void Time_setMour(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_getSec")] + public static extern double Time_getSec(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Time_setSec")] + public static extern void Time_setSec(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_delete_Time")] + public static extern void delete_Time(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_new_GZ__SWIG_0")] + public static extern global::System.IntPtr new_GZ__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_new_GZ__SWIG_1")] + public static extern global::System.IntPtr new_GZ__SWIG_1(byte jarg1, byte jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_GZ_tg_set")] + public static extern void GZ_tg_set(global::System.Runtime.InteropServices.HandleRef jarg1, byte jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_GZ_tg_get")] + public static extern byte GZ_tg_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_GZ_dz_set")] + public static extern void GZ_dz_set(global::System.Runtime.InteropServices.HandleRef jarg1, byte jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_GZ_dz_get")] + public static extern byte GZ_dz_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_delete_GZ")] + public static extern void delete_GZ(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_fromSolar")] + public static extern global::System.IntPtr Day_fromSolar(int jarg1, byte jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_fromLunar__SWIG_0")] + public static extern global::System.IntPtr Day_fromLunar__SWIG_0(int jarg1, byte jarg2, int jarg3, bool jarg4); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_fromLunar__SWIG_1")] + public static extern global::System.IntPtr Day_fromLunar__SWIG_1(int jarg1, byte jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_after")] + public static extern global::System.IntPtr Day_after(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_before")] + public static extern global::System.IntPtr Day_before(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getLunarDay")] + public static extern int Day_getLunarDay(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getLunarMonth")] + public static extern byte Day_getLunarMonth(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getLunarYear__SWIG_0")] + public static extern int Day_getLunarYear__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getLunarYear__SWIG_1")] + public static extern int Day_getLunarYear__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getYearGZ__SWIG_0")] + public static extern global::System.IntPtr Day_getYearGZ__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getYearGZ__SWIG_1")] + public static extern global::System.IntPtr Day_getYearGZ__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getMonthGZ")] + public static extern global::System.IntPtr Day_getMonthGZ(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getDayGZ")] + public static extern global::System.IntPtr Day_getDayGZ(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getHourGZ__SWIG_0")] + public static extern global::System.IntPtr Day_getHourGZ__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, byte jarg2, bool jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getHourGZ__SWIG_1")] + public static extern global::System.IntPtr Day_getHourGZ__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, byte jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_isLunarLeap")] + public static extern bool Day_isLunarLeap(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getSolarYear")] + public static extern int Day_getSolarYear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getSolarMonth")] + public static extern byte Day_getSolarMonth(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getSolarDay")] + public static extern int Day_getSolarDay(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getWeek")] + public static extern byte Day_getWeek(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getWeekIndex")] + public static extern byte Day_getWeekIndex(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_hasJieQi")] + public static extern bool Day_hasJieQi(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getJieQi")] + public static extern byte Day_getJieQi(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getJieQiJD")] + public static extern double Day_getJieQiJD(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_Day_getConstellation")] + public static extern byte Day_getConstellation(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_delete_Day")] + public static extern void delete_Day(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JieQiInfo_jd_set")] + public static extern void JieQiInfo_jd_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JieQiInfo_jd_get")] + public static extern double JieQiInfo_jd_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JieQiInfo_jqIndex_set")] + public static extern void JieQiInfo_jqIndex_set(global::System.Runtime.InteropServices.HandleRef jarg1, byte jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JieQiInfo_jqIndex_get")] + public static extern byte JieQiInfo_jqIndex_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_new_JieQiInfo")] + public static extern global::System.IntPtr new_JieQiInfo(); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_delete_JieQiInfo")] + public static extern void delete_JieQiInfo(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_fromSolar")] + public static extern global::System.IntPtr fromSolar(int jarg1, byte jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_fromLunar__SWIG_0")] + public static extern global::System.IntPtr fromLunar__SWIG_0(int jarg1, byte jarg2, int jarg3, bool jarg4); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_fromLunar__SWIG_1")] + public static extern global::System.IntPtr fromLunar__SWIG_1(int jarg1, byte jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_siZhu2Year")] + public static extern global::System.IntPtr siZhu2Year(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, global::System.Runtime.InteropServices.HandleRef jarg4, int jarg5, int jarg6); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_getShiGz__SWIG_0")] + public static extern global::System.IntPtr getShiGz__SWIG_0(byte jarg1, byte jarg2, bool jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_getShiGz__SWIG_1")] + public static extern global::System.IntPtr getShiGz__SWIG_1(byte jarg1, byte jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_getRunMonth")] + public static extern byte getRunMonth(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_getLunarMonthNum__SWIG_0")] + public static extern byte getLunarMonthNum__SWIG_0(int jarg1, byte jarg2, bool jarg3); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_getLunarMonthNum__SWIG_1")] + public static extern byte getLunarMonthNum__SWIG_1(int jarg1, byte jarg2); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_JD2DD")] + public static extern global::System.IntPtr JD2DD(double jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_toJD")] + public static extern double toJD(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("sxtwl", EntryPoint="CSharp_getJieQiByYear")] + public static extern global::System.IntPtr getJieQiByYear(int jarg1); +} diff --git a/export/C#/sxtwl_wrap.cxx b/export/C#/sxtwl_wrap.cxx new file mode 100644 index 0000000..d57f7af --- /dev/null +++ b/export/C#/sxtwl_wrap.cxx @@ -0,0 +1,2313 @@ +/* ---------------------------------------------------------------------------- + * 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 SWIGCSHARP + +/* ----------------------------------------------------------------------------- + * 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 + + +#include +#include +#include + + +/* Support for throwing C# exceptions from C/C++. There are two types: + * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */ +typedef enum { + SWIG_CSharpApplicationException, + SWIG_CSharpArithmeticException, + SWIG_CSharpDivideByZeroException, + SWIG_CSharpIndexOutOfRangeException, + SWIG_CSharpInvalidCastException, + SWIG_CSharpInvalidOperationException, + SWIG_CSharpIOException, + SWIG_CSharpNullReferenceException, + SWIG_CSharpOutOfMemoryException, + SWIG_CSharpOverflowException, + SWIG_CSharpSystemException +} SWIG_CSharpExceptionCodes; + +typedef enum { + SWIG_CSharpArgumentException, + SWIG_CSharpArgumentNullException, + SWIG_CSharpArgumentOutOfRangeException +} SWIG_CSharpExceptionArgumentCodes; + +typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *); +typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *); + +typedef struct { + SWIG_CSharpExceptionCodes code; + SWIG_CSharpExceptionCallback_t callback; +} SWIG_CSharpException_t; + +typedef struct { + SWIG_CSharpExceptionArgumentCodes code; + SWIG_CSharpExceptionArgumentCallback_t callback; +} SWIG_CSharpExceptionArgument_t; + +static SWIG_CSharpException_t SWIG_csharp_exceptions[] = { + { SWIG_CSharpApplicationException, NULL }, + { SWIG_CSharpArithmeticException, NULL }, + { SWIG_CSharpDivideByZeroException, NULL }, + { SWIG_CSharpIndexOutOfRangeException, NULL }, + { SWIG_CSharpInvalidCastException, NULL }, + { SWIG_CSharpInvalidOperationException, NULL }, + { SWIG_CSharpIOException, NULL }, + { SWIG_CSharpNullReferenceException, NULL }, + { SWIG_CSharpOutOfMemoryException, NULL }, + { SWIG_CSharpOverflowException, NULL }, + { SWIG_CSharpSystemException, NULL } +}; + +static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = { + { SWIG_CSharpArgumentException, NULL }, + { SWIG_CSharpArgumentNullException, NULL }, + { SWIG_CSharpArgumentOutOfRangeException, NULL } +}; + +static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) { + SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback; + if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) { + callback = SWIG_csharp_exceptions[code].callback; + } + callback(msg); +} + +static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) { + SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback; + if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) { + callback = SWIG_csharp_exceptions_argument[code].callback; + } + callback(msg, param_name); +} + + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_sxtwl( + SWIG_CSharpExceptionCallback_t applicationCallback, + SWIG_CSharpExceptionCallback_t arithmeticCallback, + SWIG_CSharpExceptionCallback_t divideByZeroCallback, + SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, + SWIG_CSharpExceptionCallback_t invalidCastCallback, + SWIG_CSharpExceptionCallback_t invalidOperationCallback, + SWIG_CSharpExceptionCallback_t ioCallback, + SWIG_CSharpExceptionCallback_t nullReferenceCallback, + SWIG_CSharpExceptionCallback_t outOfMemoryCallback, + SWIG_CSharpExceptionCallback_t overflowCallback, + SWIG_CSharpExceptionCallback_t systemCallback) { + SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback; + SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback; + SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback; + SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback; + SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback; + SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback; + SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback; + SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback; + SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback; + SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback; + SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback; +} + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_sxtwl( + SWIG_CSharpExceptionArgumentCallback_t argumentCallback, + SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback, + SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) { + SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback; + SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback; + SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback; +} + + +/* Callback for returning strings to C# without leaking memory */ +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); +static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL; + + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_sxtwl(SWIG_CSharpStringHelperCallback callback) { + SWIG_csharp_string_callback = callback; +} + + +/* Contract support */ + +#define SWIG_contract_assert(nullreturn, expr, msg) do { if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } } while (0) + + +#ifdef __cplusplus +#include +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigSmartPointer { + T *ptr; + SwigSmartPointer(T *p) : ptr(p) { } + ~SwigSmartPointer() { delete ptr; } + SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; } +#if __cplusplus >=201103L + SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; } + operator T&&() const { return std::move(*pointer.ptr); } +#else + operator T&() const { return *pointer.ptr; } +#endif + T *operator&() const { return pointer.ptr; } + static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); } +}; + +/* + * SwigValueInit() is a generic initialisation solution as the following approach: + * + * T c_result = T(); + * + * doesn't compile for all types for example: + * + * unsigned int c_result = unsigned int(); + */ +template T SwigValueInit() { + return T(); +} + +#if __cplusplus >=201103L +# define SWIG_STD_MOVE(OBJ) std::move(OBJ) +#else +# define SWIG_STD_MOVE(OBJ) OBJ +#endif + +#endif + + +#include "const.h" +#include "sxtwl.h" + + +#include // Use the C99 official header + + +#include +#include + + +#include +#include +#include + + +#include + +SWIGINTERN std::vector< double > *new_std_vector_Sl_double_Sg___SWIG_2(int capacity){ + std::vector< double >* pv = 0; + if (capacity >= 0) { + pv = new std::vector< double >(); + pv->reserve(capacity); + } else { + throw std::out_of_range("capacity"); + } + return pv; + } +SWIGINTERN double std_vector_Sl_double_Sg__getitemcopy(std::vector< double > *self,int index){ + if (index>=0 && index<(int)self->size()) + return (*self)[index]; + else + throw std::out_of_range("index"); + } +SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg__getitem(std::vector< double > *self,int index){ + if (index>=0 && index<(int)self->size()) + return (*self)[index]; + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_double_Sg__setitem(std::vector< double > *self,int index,double const &val){ + if (index>=0 && index<(int)self->size()) + (*self)[index] = val; + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_double_Sg__AddRange(std::vector< double > *self,std::vector< double > const &values){ + self->insert(self->end(), values.begin(), values.end()); + } +SWIGINTERN std::vector< double > *std_vector_Sl_double_Sg__GetRange(std::vector< double > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + return new std::vector< double >(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN void std_vector_Sl_double_Sg__Insert(std::vector< double > *self,int index,double const &x){ + if (index>=0 && index<(int)self->size()+1) + self->insert(self->begin()+index, x); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_double_Sg__InsertRange(std::vector< double > *self,int index,std::vector< double > const &values){ + if (index>=0 && index<(int)self->size()+1) + self->insert(self->begin()+index, values.begin(), values.end()); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_double_Sg__RemoveAt(std::vector< double > *self,int index){ + if (index>=0 && index<(int)self->size()) + self->erase(self->begin() + index); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_double_Sg__RemoveRange(std::vector< double > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + self->erase(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN std::vector< double > *std_vector_Sl_double_Sg__Repeat(double const &value,int count){ + if (count < 0) + throw std::out_of_range("count"); + return new std::vector< double >(count, value); + } +SWIGINTERN void std_vector_Sl_double_Sg__Reverse__SWIG_0(std::vector< double > *self){ + std::reverse(self->begin(), self->end()); + } +SWIGINTERN void std_vector_Sl_double_Sg__Reverse__SWIG_1(std::vector< double > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + std::reverse(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN void std_vector_Sl_double_Sg__SetRange(std::vector< double > *self,int index,std::vector< double > const &values){ + if (index < 0) + throw std::out_of_range("index"); + if (index+values.size() > self->size()) + throw std::out_of_range("index"); + std::copy(values.begin(), values.end(), self->begin()+index); + } +SWIGINTERN bool std_vector_Sl_double_Sg__Contains(std::vector< double > *self,double const &value){ + return std::find(self->begin(), self->end(), value) != self->end(); + } +SWIGINTERN int std_vector_Sl_double_Sg__IndexOf(std::vector< double > *self,double const &value){ + int index = -1; + std::vector< double >::iterator it = std::find(self->begin(), self->end(), value); + if (it != self->end()) + index = (int)(it - self->begin()); + return index; + } +SWIGINTERN int std_vector_Sl_double_Sg__LastIndexOf(std::vector< double > *self,double const &value){ + int index = -1; + std::vector< double >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value); + if (rit != self->rend()) + index = (int)(self->rend() - 1 - rit); + return index; + } +SWIGINTERN bool std_vector_Sl_double_Sg__Remove(std::vector< double > *self,double const &value){ + std::vector< double >::iterator it = std::find(self->begin(), self->end(), value); + if (it != self->end()) { + self->erase(it); + return true; + } + return false; + } +SWIGINTERN std::vector< sxtwl::JieQiInfo > *new_std_vector_Sl_sxtwl_JieQiInfo_Sg___SWIG_2(int capacity){ + std::vector< sxtwl::JieQiInfo >* pv = 0; + if (capacity >= 0) { + pv = new std::vector< sxtwl::JieQiInfo >(); + pv->reserve(capacity); + } else { + throw std::out_of_range("capacity"); + } + return pv; + } +SWIGINTERN sxtwl::JieQiInfo std_vector_Sl_sxtwl_JieQiInfo_Sg__getitemcopy(std::vector< sxtwl::JieQiInfo > *self,int index){ + if (index>=0 && index<(int)self->size()) + return (*self)[index]; + else + throw std::out_of_range("index"); + } +SWIGINTERN std::vector< sxtwl::JieQiInfo >::value_type const &std_vector_Sl_sxtwl_JieQiInfo_Sg__getitem(std::vector< sxtwl::JieQiInfo > *self,int index){ + if (index>=0 && index<(int)self->size()) + return (*self)[index]; + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__setitem(std::vector< sxtwl::JieQiInfo > *self,int index,sxtwl::JieQiInfo const &val){ + if (index>=0 && index<(int)self->size()) + (*self)[index] = val; + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__AddRange(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo > const &values){ + self->insert(self->end(), values.begin(), values.end()); + } +SWIGINTERN std::vector< sxtwl::JieQiInfo > *std_vector_Sl_sxtwl_JieQiInfo_Sg__GetRange(std::vector< sxtwl::JieQiInfo > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + return new std::vector< sxtwl::JieQiInfo >(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__Insert(std::vector< sxtwl::JieQiInfo > *self,int index,sxtwl::JieQiInfo const &x){ + if (index>=0 && index<(int)self->size()+1) + self->insert(self->begin()+index, x); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__InsertRange(std::vector< sxtwl::JieQiInfo > *self,int index,std::vector< sxtwl::JieQiInfo > const &values){ + if (index>=0 && index<(int)self->size()+1) + self->insert(self->begin()+index, values.begin(), values.end()); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__RemoveAt(std::vector< sxtwl::JieQiInfo > *self,int index){ + if (index>=0 && index<(int)self->size()) + self->erase(self->begin() + index); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__RemoveRange(std::vector< sxtwl::JieQiInfo > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + self->erase(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN std::vector< sxtwl::JieQiInfo > *std_vector_Sl_sxtwl_JieQiInfo_Sg__Repeat(sxtwl::JieQiInfo const &value,int count){ + if (count < 0) + throw std::out_of_range("count"); + return new std::vector< sxtwl::JieQiInfo >(count, value); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__Reverse__SWIG_0(std::vector< sxtwl::JieQiInfo > *self){ + std::reverse(self->begin(), self->end()); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__Reverse__SWIG_1(std::vector< sxtwl::JieQiInfo > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + std::reverse(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__SetRange(std::vector< sxtwl::JieQiInfo > *self,int index,std::vector< sxtwl::JieQiInfo > const &values){ + if (index < 0) + throw std::out_of_range("index"); + if (index+values.size() > self->size()) + throw std::out_of_range("index"); + std::copy(values.begin(), values.end(), self->begin()+index); + } + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void SWIGSTDCALL CSharp_JDList_Clear(void * jarg1) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + + arg1 = (std::vector< double > *)jarg1; + (arg1)->clear(); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JDList_Add(void * jarg1, double jarg2) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + double *arg2 = 0 ; + double temp2 ; + + arg1 = (std::vector< double > *)jarg1; + temp2 = (double)jarg2; + arg2 = &temp2; + (arg1)->push_back((double const &)*arg2); +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_JDList_size(void * jarg1) { + unsigned long jresult ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type result; + + arg1 = (std::vector< double > *)jarg1; + result = ((std::vector< double > const *)arg1)->size(); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_JDList_capacity(void * jarg1) { + unsigned long jresult ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type result; + + arg1 = (std::vector< double > *)jarg1; + result = ((std::vector< double > const *)arg1)->capacity(); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JDList_reserve(void * jarg1, unsigned long jarg2) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type arg2 ; + + arg1 = (std::vector< double > *)jarg1; + arg2 = (std::vector< double >::size_type)jarg2; + (arg1)->reserve(arg2); +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_JDList__SWIG_0() { + void * jresult ; + std::vector< double > *result = 0 ; + + result = (std::vector< double > *)new std::vector< double >(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_JDList__SWIG_1(void * jarg1) { + void * jresult ; + std::vector< double > *arg1 = 0 ; + std::vector< double > *result = 0 ; + + arg1 = (std::vector< double > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & is null", 0); + return 0; + } + result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_JDList__SWIG_2(int jarg1) { + void * jresult ; + int arg1 ; + std::vector< double > *result = 0 ; + + arg1 = (int)jarg1; + try { + result = (std::vector< double > *)new_std_vector_Sl_double_Sg___SWIG_2(arg1); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_JDList_getitemcopy(void * jarg1, int jarg2) { + double jresult ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + double result; + + arg1 = (std::vector< double > *)jarg1; + arg2 = (int)jarg2; + try { + result = (double)std_vector_Sl_double_Sg__getitemcopy(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + jresult = result; + return jresult; +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_JDList_getitem(void * jarg1, int jarg2) { + double jresult ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + std::vector< double >::value_type *result = 0 ; + + arg1 = (std::vector< double > *)jarg1; + arg2 = (int)jarg2; + try { + result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__getitem(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + jresult = *result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JDList_setitem(void * jarg1, int jarg2, double jarg3) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + double *arg3 = 0 ; + double temp3 ; + + arg1 = (std::vector< double > *)jarg1; + arg2 = (int)jarg2; + temp3 = (double)jarg3; + arg3 = &temp3; + try { + std_vector_Sl_double_Sg__setitem(arg1,arg2,(double const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JDList_AddRange(void * jarg1, void * jarg2) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double > *arg2 = 0 ; + + arg1 = (std::vector< double > *)jarg1; + arg2 = (std::vector< double > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & is null", 0); + return ; + } + std_vector_Sl_double_Sg__AddRange(arg1,(std::vector< double > const &)*arg2); +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_JDList_GetRange(void * jarg1, int jarg2, int jarg3) { + void * jresult ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + int arg3 ; + std::vector< double > *result = 0 ; + + arg1 = (std::vector< double > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + try { + result = (std::vector< double > *)std_vector_Sl_double_Sg__GetRange(arg1,arg2,arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return 0; + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JDList_Insert(void * jarg1, int jarg2, double jarg3) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + double *arg3 = 0 ; + double temp3 ; + + arg1 = (std::vector< double > *)jarg1; + arg2 = (int)jarg2; + temp3 = (double)jarg3; + arg3 = &temp3; + try { + std_vector_Sl_double_Sg__Insert(arg1,arg2,(double const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JDList_InsertRange(void * jarg1, int jarg2, void * jarg3) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + std::vector< double > *arg3 = 0 ; + + arg1 = (std::vector< double > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::vector< double > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & is null", 0); + return ; + } + try { + std_vector_Sl_double_Sg__InsertRange(arg1,arg2,(std::vector< double > const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JDList_RemoveAt(void * jarg1, int jarg2) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + + arg1 = (std::vector< double > *)jarg1; + arg2 = (int)jarg2; + try { + std_vector_Sl_double_Sg__RemoveAt(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JDList_RemoveRange(void * jarg1, int jarg2, int jarg3) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (std::vector< double > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + try { + std_vector_Sl_double_Sg__RemoveRange(arg1,arg2,arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return ; + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_JDList_Repeat(double jarg1, int jarg2) { + void * jresult ; + double *arg1 = 0 ; + int arg2 ; + double temp1 ; + std::vector< double > *result = 0 ; + + temp1 = (double)jarg1; + arg1 = &temp1; + arg2 = (int)jarg2; + try { + result = (std::vector< double > *)std_vector_Sl_double_Sg__Repeat((double const &)*arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JDList_Reverse__SWIG_0(void * jarg1) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + + arg1 = (std::vector< double > *)jarg1; + std_vector_Sl_double_Sg__Reverse__SWIG_0(arg1); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JDList_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (std::vector< double > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + try { + std_vector_Sl_double_Sg__Reverse__SWIG_1(arg1,arg2,arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return ; + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JDList_SetRange(void * jarg1, int jarg2, void * jarg3) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + std::vector< double > *arg3 = 0 ; + + arg1 = (std::vector< double > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::vector< double > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & is null", 0); + return ; + } + try { + std_vector_Sl_double_Sg__SetRange(arg1,arg2,(std::vector< double > const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_JDList_Contains(void * jarg1, double jarg2) { + unsigned int jresult ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + double *arg2 = 0 ; + double temp2 ; + bool result; + + arg1 = (std::vector< double > *)jarg1; + temp2 = (double)jarg2; + arg2 = &temp2; + result = (bool)std_vector_Sl_double_Sg__Contains(arg1,(double const &)*arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_JDList_IndexOf(void * jarg1, double jarg2) { + int jresult ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + double *arg2 = 0 ; + double temp2 ; + int result; + + arg1 = (std::vector< double > *)jarg1; + temp2 = (double)jarg2; + arg2 = &temp2; + result = (int)std_vector_Sl_double_Sg__IndexOf(arg1,(double const &)*arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_JDList_LastIndexOf(void * jarg1, double jarg2) { + int jresult ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + double *arg2 = 0 ; + double temp2 ; + int result; + + arg1 = (std::vector< double > *)jarg1; + temp2 = (double)jarg2; + arg2 = &temp2; + result = (int)std_vector_Sl_double_Sg__LastIndexOf(arg1,(double const &)*arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_JDList_Remove(void * jarg1, double jarg2) { + unsigned int jresult ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + double *arg2 = 0 ; + double temp2 ; + bool result; + + arg1 = (std::vector< double > *)jarg1; + temp2 = (double)jarg2; + arg2 = &temp2; + result = (bool)std_vector_Sl_double_Sg__Remove(arg1,(double const &)*arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_JDList(void * jarg1) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + + arg1 = (std::vector< double > *)jarg1; + delete arg1; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JQList_Clear(void * jarg1) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + (arg1)->clear(); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JQList_Add(void * jarg1, void * jarg2) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + sxtwl::JieQiInfo *arg2 = 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (sxtwl::JieQiInfo *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "sxtwl::JieQiInfo const & is null", 0); + return ; + } + (arg1)->push_back((sxtwl::JieQiInfo const &)*arg2); +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_JQList_size(void * jarg1) { + unsigned long jresult ; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type result; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + result = ((std::vector< sxtwl::JieQiInfo > const *)arg1)->size(); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_JQList_capacity(void * jarg1) { + unsigned long jresult ; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type result; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + result = ((std::vector< sxtwl::JieQiInfo > const *)arg1)->capacity(); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JQList_reserve(void * jarg1, unsigned long jarg2) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type arg2 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (std::vector< sxtwl::JieQiInfo >::size_type)jarg2; + (arg1)->reserve(arg2); +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_JQList__SWIG_0() { + void * jresult ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_JQList__SWIG_1(void * jarg1) { + void * jresult ; + std::vector< sxtwl::JieQiInfo > *arg1 = 0 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< sxtwl::JieQiInfo > const & is null", 0); + return 0; + } + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >((std::vector< sxtwl::JieQiInfo > const &)*arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_JQList__SWIG_2(int jarg1) { + void * jresult ; + int arg1 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + arg1 = (int)jarg1; + try { + result = (std::vector< sxtwl::JieQiInfo > *)new_std_vector_Sl_sxtwl_JieQiInfo_Sg___SWIG_2(arg1); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_JQList_getitemcopy(void * jarg1, int jarg2) { + void * jresult ; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + sxtwl::JieQiInfo result; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (int)jarg2; + try { + result = std_vector_Sl_sxtwl_JieQiInfo_Sg__getitemcopy(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + jresult = new sxtwl::JieQiInfo(result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_JQList_getitem(void * jarg1, int jarg2) { + void * jresult ; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + std::vector< sxtwl::JieQiInfo >::value_type *result = 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (int)jarg2; + try { + result = (std::vector< sxtwl::JieQiInfo >::value_type *) &std_vector_Sl_sxtwl_JieQiInfo_Sg__getitem(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JQList_setitem(void * jarg1, int jarg2, void * jarg3) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + sxtwl::JieQiInfo *arg3 = 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (int)jarg2; + arg3 = (sxtwl::JieQiInfo *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "sxtwl::JieQiInfo const & is null", 0); + return ; + } + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg__setitem(arg1,arg2,(sxtwl::JieQiInfo const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JQList_AddRange(void * jarg1, void * jarg2) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo > *arg2 = 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (std::vector< sxtwl::JieQiInfo > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< sxtwl::JieQiInfo > const & is null", 0); + return ; + } + std_vector_Sl_sxtwl_JieQiInfo_Sg__AddRange(arg1,(std::vector< sxtwl::JieQiInfo > const &)*arg2); +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_JQList_GetRange(void * jarg1, int jarg2, int jarg3) { + void * jresult ; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + int arg3 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + try { + result = (std::vector< sxtwl::JieQiInfo > *)std_vector_Sl_sxtwl_JieQiInfo_Sg__GetRange(arg1,arg2,arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return 0; + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JQList_Insert(void * jarg1, int jarg2, void * jarg3) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + sxtwl::JieQiInfo *arg3 = 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (int)jarg2; + arg3 = (sxtwl::JieQiInfo *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "sxtwl::JieQiInfo const & is null", 0); + return ; + } + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg__Insert(arg1,arg2,(sxtwl::JieQiInfo const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JQList_InsertRange(void * jarg1, int jarg2, void * jarg3) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + std::vector< sxtwl::JieQiInfo > *arg3 = 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::vector< sxtwl::JieQiInfo > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< sxtwl::JieQiInfo > const & is null", 0); + return ; + } + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg__InsertRange(arg1,arg2,(std::vector< sxtwl::JieQiInfo > const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JQList_RemoveAt(void * jarg1, int jarg2) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (int)jarg2; + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg__RemoveAt(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JQList_RemoveRange(void * jarg1, int jarg2, int jarg3) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg__RemoveRange(arg1,arg2,arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return ; + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_JQList_Repeat(void * jarg1, int jarg2) { + void * jresult ; + sxtwl::JieQiInfo *arg1 = 0 ; + int arg2 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + arg1 = (sxtwl::JieQiInfo *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "sxtwl::JieQiInfo const & is null", 0); + return 0; + } + arg2 = (int)jarg2; + try { + result = (std::vector< sxtwl::JieQiInfo > *)std_vector_Sl_sxtwl_JieQiInfo_Sg__Repeat((sxtwl::JieQiInfo const &)*arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JQList_Reverse__SWIG_0(void * jarg1) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + std_vector_Sl_sxtwl_JieQiInfo_Sg__Reverse__SWIG_0(arg1); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JQList_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg__Reverse__SWIG_1(arg1,arg2,arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return ; + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JQList_SetRange(void * jarg1, int jarg2, void * jarg3) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + std::vector< sxtwl::JieQiInfo > *arg3 = 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::vector< sxtwl::JieQiInfo > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< sxtwl::JieQiInfo > const & is null", 0); + return ; + } + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg__SetRange(arg1,arg2,(std::vector< sxtwl::JieQiInfo > const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_JQList(void * jarg1) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)jarg1; + delete arg1; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_J2000_get() { + int jresult ; + int result; + + result = (int)(2451545); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_Time__SWIG_0() { + void * jresult ; + Time *result = 0 ; + + result = (Time *)new Time(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_Time__SWIG_1(int jarg1, int jarg2, int jarg3, double jarg4, double jarg5, double jarg6) { + void * jresult ; + int arg1 ; + int arg2 ; + int arg3 ; + double arg4 ; + double arg5 ; + double arg6 ; + Time *result = 0 ; + + arg1 = (int)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + arg4 = (double)jarg4; + arg5 = (double)jarg5; + arg6 = (double)jarg6; + result = (Time *)new Time(arg1,arg2,arg3,arg4,arg5,arg6); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Time_Y_set(void * jarg1, int jarg2) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + arg1 = (Time *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->Y = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Time_Y_get(void * jarg1) { + int jresult ; + Time *arg1 = (Time *) 0 ; + int result; + + arg1 = (Time *)jarg1; + result = (int) ((arg1)->Y); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Time_M_set(void * jarg1, int jarg2) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + arg1 = (Time *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->M = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Time_M_get(void * jarg1) { + int jresult ; + Time *arg1 = (Time *) 0 ; + int result; + + arg1 = (Time *)jarg1; + result = (int) ((arg1)->M); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Time_D_set(void * jarg1, int jarg2) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + arg1 = (Time *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->D = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Time_D_get(void * jarg1) { + int jresult ; + Time *arg1 = (Time *) 0 ; + int result; + + arg1 = (Time *)jarg1; + result = (int) ((arg1)->D); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Time_h_set(void * jarg1, double jarg2) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + arg1 = (Time *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->h = arg2; +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_Time_h_get(void * jarg1) { + double jresult ; + Time *arg1 = (Time *) 0 ; + double result; + + arg1 = (Time *)jarg1; + result = (double) ((arg1)->h); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Time_m_set(void * jarg1, double jarg2) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + arg1 = (Time *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->m = arg2; +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_Time_m_get(void * jarg1) { + double jresult ; + Time *arg1 = (Time *) 0 ; + double result; + + arg1 = (Time *)jarg1; + result = (double) ((arg1)->m); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Time_s_set(void * jarg1, double jarg2) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + arg1 = (Time *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->s = arg2; +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_Time_s_get(void * jarg1) { + double jresult ; + Time *arg1 = (Time *) 0 ; + double result; + + arg1 = (Time *)jarg1; + result = (double) ((arg1)->s); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Time_getYear(void * jarg1) { + int jresult ; + Time *arg1 = (Time *) 0 ; + int result; + + arg1 = (Time *)jarg1; + result = (int)(arg1)->getYear(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Time_setYear(void * jarg1, int jarg2) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + arg1 = (Time *)jarg1; + arg2 = (int)jarg2; + (arg1)->setYear(arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Time_setMonth(void * jarg1, int jarg2) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + arg1 = (Time *)jarg1; + arg2 = (int)jarg2; + (arg1)->setMonth(arg2); +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Time_getMonth(void * jarg1) { + int jresult ; + Time *arg1 = (Time *) 0 ; + int result; + + arg1 = (Time *)jarg1; + result = (int)(arg1)->getMonth(); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Time_getDay(void * jarg1) { + int jresult ; + Time *arg1 = (Time *) 0 ; + int result; + + arg1 = (Time *)jarg1; + result = (int)(arg1)->getDay(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Time_setDay(void * jarg1, int jarg2) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + arg1 = (Time *)jarg1; + arg2 = (int)jarg2; + (arg1)->setDay(arg2); +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_Time_getHour(void * jarg1) { + double jresult ; + Time *arg1 = (Time *) 0 ; + double result; + + arg1 = (Time *)jarg1; + result = (double)(arg1)->getHour(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Time_setHour(void * jarg1, double jarg2) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + arg1 = (Time *)jarg1; + arg2 = (double)jarg2; + (arg1)->setHour(arg2); +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_Time_getMin(void * jarg1) { + double jresult ; + Time *arg1 = (Time *) 0 ; + double result; + + arg1 = (Time *)jarg1; + result = (double)(arg1)->getMin(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Time_setMour(void * jarg1, double jarg2) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + arg1 = (Time *)jarg1; + arg2 = (double)jarg2; + (arg1)->setMour(arg2); +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_Time_getSec(void * jarg1) { + double jresult ; + Time *arg1 = (Time *) 0 ; + double result; + + arg1 = (Time *)jarg1; + result = (double)(arg1)->getSec(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Time_setSec(void * jarg1, double jarg2) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + arg1 = (Time *)jarg1; + arg2 = (double)jarg2; + (arg1)->setSec(arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_Time(void * jarg1) { + Time *arg1 = (Time *) 0 ; + + arg1 = (Time *)jarg1; + delete arg1; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_GZ__SWIG_0() { + void * jresult ; + GZ *result = 0 ; + + result = (GZ *)new GZ(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_GZ__SWIG_1(unsigned char jarg1, unsigned char jarg2) { + void * jresult ; + uint8_t arg1 ; + uint8_t arg2 ; + GZ *result = 0 ; + + arg1 = (uint8_t)jarg1; + arg2 = (uint8_t)jarg2; + result = (GZ *)new GZ(arg1,arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_GZ_tg_set(void * jarg1, unsigned char jarg2) { + GZ *arg1 = (GZ *) 0 ; + uint8_t arg2 ; + + arg1 = (GZ *)jarg1; + arg2 = (uint8_t)jarg2; + if (arg1) (arg1)->tg = arg2; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_GZ_tg_get(void * jarg1) { + unsigned char jresult ; + GZ *arg1 = (GZ *) 0 ; + uint8_t result; + + arg1 = (GZ *)jarg1; + result = (uint8_t) ((arg1)->tg); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_GZ_dz_set(void * jarg1, unsigned char jarg2) { + GZ *arg1 = (GZ *) 0 ; + uint8_t arg2 ; + + arg1 = (GZ *)jarg1; + arg2 = (uint8_t)jarg2; + if (arg1) (arg1)->dz = arg2; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_GZ_dz_get(void * jarg1) { + unsigned char jresult ; + GZ *arg1 = (GZ *) 0 ; + uint8_t result; + + arg1 = (GZ *)jarg1; + result = (uint8_t) ((arg1)->dz); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_GZ(void * jarg1) { + GZ *arg1 = (GZ *) 0 ; + + arg1 = (GZ *)jarg1; + delete arg1; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Day_fromSolar(int jarg1, unsigned char jarg2, int jarg3) { + void * jresult ; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = (int)jarg3; + result = (Day *)Day::fromSolar(arg1,arg2,arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Day_fromLunar__SWIG_0(int jarg1, unsigned char jarg2, int jarg3, unsigned int jarg4) { + void * jresult ; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + bool arg4 ; + Day *result = 0 ; + + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = (int)jarg3; + arg4 = jarg4 ? true : false; + result = (Day *)Day::fromLunar(arg1,arg2,arg3,arg4); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Day_fromLunar__SWIG_1(int jarg1, unsigned char jarg2, int jarg3) { + void * jresult ; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = (int)jarg3; + result = (Day *)Day::fromLunar(arg1,arg2,arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Day_after(void * jarg1, int jarg2) { + void * jresult ; + Day *arg1 = (Day *) 0 ; + int arg2 ; + Day *result = 0 ; + + arg1 = (Day *)jarg1; + arg2 = (int)jarg2; + result = (Day *)(arg1)->after(arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Day_before(void * jarg1, int jarg2) { + void * jresult ; + Day *arg1 = (Day *) 0 ; + int arg2 ; + Day *result = 0 ; + + arg1 = (Day *)jarg1; + arg2 = (int)jarg2; + result = (Day *)(arg1)->before(arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Day_getLunarDay(void * jarg1) { + int jresult ; + Day *arg1 = (Day *) 0 ; + int result; + + arg1 = (Day *)jarg1; + result = (int)(arg1)->getLunarDay(); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Day_getLunarMonth(void * jarg1) { + unsigned char jresult ; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + arg1 = (Day *)jarg1; + result = (uint8_t)(arg1)->getLunarMonth(); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Day_getLunarYear__SWIG_0(void * jarg1, unsigned int jarg2) { + int jresult ; + Day *arg1 = (Day *) 0 ; + bool arg2 ; + int result; + + arg1 = (Day *)jarg1; + arg2 = jarg2 ? true : false; + result = (int)(arg1)->getLunarYear(arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Day_getLunarYear__SWIG_1(void * jarg1) { + int jresult ; + Day *arg1 = (Day *) 0 ; + int result; + + arg1 = (Day *)jarg1; + result = (int)(arg1)->getLunarYear(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Day_getYearGZ__SWIG_0(void * jarg1, unsigned int jarg2) { + void * jresult ; + Day *arg1 = (Day *) 0 ; + bool arg2 ; + GZ result; + + arg1 = (Day *)jarg1; + arg2 = jarg2 ? true : false; + result = (arg1)->getYearGZ(arg2); + jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Day_getYearGZ__SWIG_1(void * jarg1) { + void * jresult ; + Day *arg1 = (Day *) 0 ; + GZ result; + + arg1 = (Day *)jarg1; + result = (arg1)->getYearGZ(); + jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Day_getMonthGZ(void * jarg1) { + void * jresult ; + Day *arg1 = (Day *) 0 ; + GZ result; + + arg1 = (Day *)jarg1; + result = (arg1)->getMonthGZ(); + jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Day_getDayGZ(void * jarg1) { + void * jresult ; + Day *arg1 = (Day *) 0 ; + GZ result; + + arg1 = (Day *)jarg1; + result = (arg1)->getDayGZ(); + jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Day_getHourGZ__SWIG_0(void * jarg1, unsigned char jarg2, unsigned int jarg3) { + void * jresult ; + Day *arg1 = (Day *) 0 ; + uint8_t arg2 ; + bool arg3 ; + GZ result; + + arg1 = (Day *)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = jarg3 ? true : false; + result = (arg1)->getHourGZ(arg2,arg3); + jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Day_getHourGZ__SWIG_1(void * jarg1, unsigned char jarg2) { + void * jresult ; + Day *arg1 = (Day *) 0 ; + uint8_t arg2 ; + GZ result; + + arg1 = (Day *)jarg1; + arg2 = (uint8_t)jarg2; + result = (arg1)->getHourGZ(arg2); + jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Day_isLunarLeap(void * jarg1) { + unsigned int jresult ; + Day *arg1 = (Day *) 0 ; + bool result; + + arg1 = (Day *)jarg1; + result = (bool)(arg1)->isLunarLeap(); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Day_getSolarYear(void * jarg1) { + int jresult ; + Day *arg1 = (Day *) 0 ; + int result; + + arg1 = (Day *)jarg1; + result = (int)(arg1)->getSolarYear(); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Day_getSolarMonth(void * jarg1) { + unsigned char jresult ; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + arg1 = (Day *)jarg1; + result = (uint8_t)(arg1)->getSolarMonth(); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Day_getSolarDay(void * jarg1) { + int jresult ; + Day *arg1 = (Day *) 0 ; + int result; + + arg1 = (Day *)jarg1; + result = (int)(arg1)->getSolarDay(); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Day_getWeek(void * jarg1) { + unsigned char jresult ; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + arg1 = (Day *)jarg1; + result = (uint8_t)(arg1)->getWeek(); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Day_getWeekIndex(void * jarg1) { + unsigned char jresult ; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + arg1 = (Day *)jarg1; + result = (uint8_t)(arg1)->getWeekIndex(); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Day_hasJieQi(void * jarg1) { + unsigned int jresult ; + Day *arg1 = (Day *) 0 ; + bool result; + + arg1 = (Day *)jarg1; + result = (bool)(arg1)->hasJieQi(); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Day_getJieQi(void * jarg1) { + unsigned char jresult ; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + arg1 = (Day *)jarg1; + result = (uint8_t)(arg1)->getJieQi(); + jresult = result; + return jresult; +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_Day_getJieQiJD(void * jarg1) { + double jresult ; + Day *arg1 = (Day *) 0 ; + double result; + + arg1 = (Day *)jarg1; + result = (double)(arg1)->getJieQiJD(); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Day_getConstellation(void * jarg1) { + unsigned char jresult ; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + arg1 = (Day *)jarg1; + result = (uint8_t)(arg1)->getConstellation(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_Day(void * jarg1) { + Day *arg1 = (Day *) 0 ; + + arg1 = (Day *)jarg1; + delete arg1; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JieQiInfo_jd_set(void * jarg1, double jarg2) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + double arg2 ; + + arg1 = (sxtwl::JieQiInfo *)jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->jd = arg2; +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_JieQiInfo_jd_get(void * jarg1) { + double jresult ; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + double result; + + arg1 = (sxtwl::JieQiInfo *)jarg1; + result = (double) ((arg1)->jd); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_JieQiInfo_jqIndex_set(void * jarg1, unsigned char jarg2) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + uint8_t arg2 ; + + arg1 = (sxtwl::JieQiInfo *)jarg1; + arg2 = (uint8_t)jarg2; + if (arg1) (arg1)->jqIndex = arg2; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_JieQiInfo_jqIndex_get(void * jarg1) { + unsigned char jresult ; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + uint8_t result; + + arg1 = (sxtwl::JieQiInfo *)jarg1; + result = (uint8_t) ((arg1)->jqIndex); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_JieQiInfo() { + void * jresult ; + sxtwl::JieQiInfo *result = 0 ; + + result = (sxtwl::JieQiInfo *)new sxtwl::JieQiInfo(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_JieQiInfo(void * jarg1) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + + arg1 = (sxtwl::JieQiInfo *)jarg1; + delete arg1; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_fromSolar(int jarg1, unsigned char jarg2, int jarg3) { + void * jresult ; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = (int)jarg3; + result = (Day *)sxtwl::fromSolar(arg1,arg2,arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_fromLunar__SWIG_0(int jarg1, unsigned char jarg2, int jarg3, unsigned int jarg4) { + void * jresult ; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + bool arg4 ; + Day *result = 0 ; + + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = (int)jarg3; + arg4 = jarg4 ? true : false; + result = (Day *)sxtwl::fromLunar(arg1,arg2,arg3,arg4); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_fromLunar__SWIG_1(int jarg1, unsigned char jarg2, int jarg3) { + void * jresult ; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = (int)jarg3; + result = (Day *)sxtwl::fromLunar(arg1,arg2,arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_siZhu2Year(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) { + void * jresult ; + GZ arg1 ; + GZ arg2 ; + GZ arg3 ; + GZ arg4 ; + int arg5 ; + int arg6 ; + GZ *argp1 ; + GZ *argp2 ; + GZ *argp3 ; + GZ *argp4 ; + std::vector< double > result; + + argp1 = (GZ *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null GZ", 0); + return 0; + } + arg1 = *argp1; + argp2 = (GZ *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null GZ", 0); + return 0; + } + arg2 = *argp2; + argp3 = (GZ *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null GZ", 0); + return 0; + } + arg3 = *argp3; + argp4 = (GZ *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null GZ", 0); + return 0; + } + arg4 = *argp4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + result = sxtwl::siZhu2Year(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,arg6); + jresult = new std::vector< double >(result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_getShiGz__SWIG_0(unsigned char jarg1, unsigned char jarg2, unsigned int jarg3) { + void * jresult ; + uint8_t arg1 ; + uint8_t arg2 ; + bool arg3 ; + GZ result; + + arg1 = (uint8_t)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = jarg3 ? true : false; + result = sxtwl::getShiGz(arg1,arg2,arg3); + jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_getShiGz__SWIG_1(unsigned char jarg1, unsigned char jarg2) { + void * jresult ; + uint8_t arg1 ; + uint8_t arg2 ; + GZ result; + + arg1 = (uint8_t)jarg1; + arg2 = (uint8_t)jarg2; + result = sxtwl::getShiGz(arg1,arg2); + jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_getRunMonth(int jarg1) { + unsigned char jresult ; + int arg1 ; + uint8_t result; + + arg1 = (int)jarg1; + result = (uint8_t)sxtwl::getRunMonth(arg1); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_getLunarMonthNum__SWIG_0(int jarg1, unsigned char jarg2, unsigned int jarg3) { + unsigned char jresult ; + int arg1 ; + uint8_t arg2 ; + bool arg3 ; + uint8_t result; + + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = jarg3 ? true : false; + result = (uint8_t)sxtwl::getLunarMonthNum(arg1,arg2,arg3); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_getLunarMonthNum__SWIG_1(int jarg1, unsigned char jarg2) { + unsigned char jresult ; + int arg1 ; + uint8_t arg2 ; + uint8_t result; + + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + result = (uint8_t)sxtwl::getLunarMonthNum(arg1,arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_JD2DD(double jarg1) { + void * jresult ; + double arg1 ; + Time result; + + arg1 = (double)jarg1; + result = sxtwl::JD2DD(arg1); + jresult = new Time(result); + return jresult; +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_toJD(void * jarg1) { + double jresult ; + Time *arg1 = 0 ; + double result; + + arg1 = (Time *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Time & is null", 0); + return 0; + } + result = (double)sxtwl::toJD(*arg1); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_getJieQiByYear(int jarg1) { + void * jresult ; + int arg1 ; + std::vector< sxtwl::JieQiInfo > result; + + arg1 = (int)jarg1; + result = sxtwl::getJieQiByYear(arg1); + jresult = new std::vector< sxtwl::JieQiInfo >(result); + return jresult; +} + + +#ifdef __cplusplus +} +#endif + diff --git a/export/golang/sxtwl.go b/export/golang/sxtwl.go new file mode 100644 index 0000000..b2093bd --- /dev/null +++ b/export/golang/sxtwl.go @@ -0,0 +1,1179 @@ +/* ---------------------------------------------------------------------------- + * 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. + * ----------------------------------------------------------------------------- */ + +// source: swig\sxtwl.i + +package sxtwl + +/* +#define intgo swig_intgo +typedef void *swig_voidp; + +#include +#include + + +typedef int intgo; +typedef unsigned int uintgo; + + + +typedef struct { char *p; intgo n; } _gostring_; +typedef struct { void* array; intgo len; intgo cap; } _goslice_; + + +typedef long long swig_type_1; +typedef long long swig_type_2; +typedef long long swig_type_3; +typedef long long swig_type_4; +typedef long long swig_type_5; +typedef long long swig_type_6; +typedef long long swig_type_7; +typedef long long swig_type_8; +extern void _wrap_Swig_free_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern uintptr_t _wrap_Swig_malloc_sxtwl_0d57379df002c83c(swig_intgo arg1); +extern uintptr_t _wrap_new_JDList__SWIG_0_sxtwl_0d57379df002c83c(void); +extern uintptr_t _wrap_new_JDList__SWIG_1_sxtwl_0d57379df002c83c(swig_type_1 arg1); +extern uintptr_t _wrap_new_JDList__SWIG_2_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern swig_type_2 _wrap_JDList_size_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern swig_type_3 _wrap_JDList_capacity_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_JDList_reserve_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_type_4 arg2); +extern _Bool _wrap_JDList_isEmpty_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_JDList_clear_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_JDList_add_sxtwl_0d57379df002c83c(uintptr_t arg1, double arg2); +extern double _wrap_JDList_get_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_JDList_set_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_intgo arg2, double arg3); +extern void _wrap_delete_JDList_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern uintptr_t _wrap_new_JQList__SWIG_0_sxtwl_0d57379df002c83c(void); +extern uintptr_t _wrap_new_JQList__SWIG_1_sxtwl_0d57379df002c83c(swig_type_5 arg1); +extern uintptr_t _wrap_new_JQList__SWIG_2_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern swig_type_6 _wrap_JQList_size_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern swig_type_7 _wrap_JQList_capacity_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_JQList_reserve_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_type_8 arg2); +extern _Bool _wrap_JQList_isEmpty_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_JQList_clear_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_JQList_add_sxtwl_0d57379df002c83c(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_JQList_get_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_JQList_set_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_intgo arg2, uintptr_t arg3); +extern void _wrap_delete_JQList_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern uintptr_t _wrap_new_Time__SWIG_0_sxtwl_0d57379df002c83c(void); +extern uintptr_t _wrap_new_Time__SWIG_1_sxtwl_0d57379df002c83c(swig_intgo arg1, swig_intgo arg2, swig_intgo arg3, double arg4, double arg5, double arg6); +extern void _wrap_Time_Y_set_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_Time_Y_get_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_Time_M_set_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_Time_M_get_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_Time_D_set_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_Time_D_get_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_Time_h_set_sxtwl_0d57379df002c83c(uintptr_t arg1, double arg2); +extern double _wrap_Time_h_get_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_Time_s_set_sxtwl_0d57379df002c83c(uintptr_t arg1, double arg2); +extern double _wrap_Time_s_get_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern swig_intgo _wrap_Time_getYear_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_Time_setYear_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_Time_setMonth_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_Time_getMonth_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern swig_intgo _wrap_Time_getDay_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_Time_setDay_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_intgo arg2); +extern double _wrap_Time_getHour_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_Time_setHour_sxtwl_0d57379df002c83c(uintptr_t arg1, double arg2); +extern double _wrap_Time_getMin_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_Time_setMour_sxtwl_0d57379df002c83c(uintptr_t arg1, double arg2); +extern double _wrap_Time_getSec_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_Time_setSec_sxtwl_0d57379df002c83c(uintptr_t arg1, double arg2); +extern void _wrap_delete_Time_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern uintptr_t _wrap_new_GZ__SWIG_0_sxtwl_0d57379df002c83c(void); +extern uintptr_t _wrap_new_GZ__SWIG_1_sxtwl_0d57379df002c83c(char arg1, char arg2); +extern void _wrap_GZ_tg_set_sxtwl_0d57379df002c83c(uintptr_t arg1, char arg2); +extern char _wrap_GZ_tg_get_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_GZ_dz_set_sxtwl_0d57379df002c83c(uintptr_t arg1, char arg2); +extern char _wrap_GZ_dz_get_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_delete_GZ_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern uintptr_t _wrap_Day_fromSolar_sxtwl_0d57379df002c83c(swig_intgo arg1, char arg2, swig_intgo arg3); +extern uintptr_t _wrap_Day_fromLunar__SWIG_0_sxtwl_0d57379df002c83c(swig_intgo arg1, char arg2, swig_intgo arg3, _Bool arg4); +extern uintptr_t _wrap_Day_fromLunar__SWIG_1_sxtwl_0d57379df002c83c(swig_intgo arg1, char arg2, swig_intgo arg3); +extern uintptr_t _wrap_Day_after_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_Day_before_sxtwl_0d57379df002c83c(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_Day_getLunarDay_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern char _wrap_Day_getLunarMonth_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern swig_intgo _wrap_Day_getLunarYear__SWIG_0_sxtwl_0d57379df002c83c(uintptr_t arg1, _Bool arg2); +extern swig_intgo _wrap_Day_getLunarYear__SWIG_1_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern uintptr_t _wrap_Day_getYearGZ__SWIG_0_sxtwl_0d57379df002c83c(uintptr_t arg1, _Bool arg2); +extern uintptr_t _wrap_Day_getYearGZ__SWIG_1_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern uintptr_t _wrap_Day_getMonthGZ_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern uintptr_t _wrap_Day_getDayGZ_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern uintptr_t _wrap_Day_getHourGZ__SWIG_0_sxtwl_0d57379df002c83c(uintptr_t arg1, char arg2, _Bool arg3); +extern uintptr_t _wrap_Day_getHourGZ__SWIG_1_sxtwl_0d57379df002c83c(uintptr_t arg1, char arg2); +extern _Bool _wrap_Day_isLunarLeap_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern swig_intgo _wrap_Day_getSolarYear_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern char _wrap_Day_getSolarMonth_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern swig_intgo _wrap_Day_getSolarDay_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern char _wrap_Day_getWeek_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern char _wrap_Day_getWeekIndex_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern _Bool _wrap_Day_hasJieQi_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern char _wrap_Day_getJieQi_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern double _wrap_Day_getJieQiJD_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern char _wrap_Day_getConstellation_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_delete_Day_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_JieQiInfo_jd_set_sxtwl_0d57379df002c83c(uintptr_t arg1, double arg2); +extern double _wrap_JieQiInfo_jd_get_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern void _wrap_JieQiInfo_jqIndex_set_sxtwl_0d57379df002c83c(uintptr_t arg1, char arg2); +extern char _wrap_JieQiInfo_jqIndex_get_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern uintptr_t _wrap_new_JieQiInfo_sxtwl_0d57379df002c83c(void); +extern void _wrap_delete_JieQiInfo_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern uintptr_t _wrap_fromSolar_sxtwl_0d57379df002c83c(swig_intgo arg1, char arg2, swig_intgo arg3); +extern uintptr_t _wrap_fromLunar__SWIG_0_sxtwl_0d57379df002c83c(swig_intgo arg1, char arg2, swig_intgo arg3, _Bool arg4); +extern uintptr_t _wrap_fromLunar__SWIG_1_sxtwl_0d57379df002c83c(swig_intgo arg1, char arg2, swig_intgo arg3); +extern uintptr_t _wrap_siZhu2Year_sxtwl_0d57379df002c83c(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, swig_intgo arg5, swig_intgo arg6); +extern uintptr_t _wrap_getShiGz__SWIG_0_sxtwl_0d57379df002c83c(char arg1, char arg2, _Bool arg3); +extern uintptr_t _wrap_getShiGz__SWIG_1_sxtwl_0d57379df002c83c(char arg1, char arg2); +extern char _wrap_getRunMonth_sxtwl_0d57379df002c83c(swig_intgo arg1); +extern char _wrap_getLunarMonthNum__SWIG_0_sxtwl_0d57379df002c83c(swig_intgo arg1, char arg2, _Bool arg3); +extern char _wrap_getLunarMonthNum__SWIG_1_sxtwl_0d57379df002c83c(swig_intgo arg1, char arg2); +extern uintptr_t _wrap_JD2DD_sxtwl_0d57379df002c83c(double arg1); +extern double _wrap_toJD_sxtwl_0d57379df002c83c(uintptr_t arg1); +extern uintptr_t _wrap_getJieQiByYear_sxtwl_0d57379df002c83c(swig_intgo arg1); +#undef intgo +*/ +import "C" + +import "unsafe" +import _ "runtime/cgo" +import "sync" + + +type _ unsafe.Pointer + + + +var Swig_escape_always_false bool +var Swig_escape_val interface{} + + +type _swig_fnptr *byte +type _swig_memberptr *byte + + +func getSwigcptr(v interface { Swigcptr() uintptr }) uintptr { + if v == nil { + return 0 + } + return v.Swigcptr() +} + + +type _ sync.Mutex + +//export cgo_panic__sxtwl_0d57379df002c83c +func cgo_panic__sxtwl_0d57379df002c83c(p *byte) { + s := (*[1024]byte)(unsafe.Pointer(p))[:] + for i, b := range s { + if b == 0 { + panic(string(s[:i])) + } + } + panic(string(s)) +} + +func Swig_free(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_Swig_free_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)) +} + +func Swig_malloc(arg1 int) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_Swig_malloc_sxtwl_0d57379df002c83c(C.swig_intgo(_swig_i_0))) + return swig_r +} + +type SwigcptrJDList uintptr + +func (p SwigcptrJDList) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrJDList) SwigIsJDList() { +} + +func NewJDList__SWIG_0() (_swig_ret JDList) { + var swig_r JDList + swig_r = (JDList)(SwigcptrJDList(C._wrap_new_JDList__SWIG_0_sxtwl_0d57379df002c83c())) + return swig_r +} + +func NewJDList__SWIG_1(arg1 int64) (_swig_ret JDList) { + var swig_r JDList + _swig_i_0 := arg1 + swig_r = (JDList)(SwigcptrJDList(C._wrap_new_JDList__SWIG_1_sxtwl_0d57379df002c83c(C.swig_type_1(_swig_i_0)))) + return swig_r +} + +func NewJDList__SWIG_2(arg1 JDList) (_swig_ret JDList) { + var swig_r JDList + _swig_i_0 := getSwigcptr(arg1) + swig_r = (JDList)(SwigcptrJDList(C._wrap_new_JDList__SWIG_2_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewJDList(a ...interface{}) JDList { + argc := len(a) + if argc == 0 { + return NewJDList__SWIG_0() + } + if argc == 1 { + if _, ok := a[0].(int64); !ok { + goto check_2 + } + return NewJDList__SWIG_1(a[0].(int64)) + } +check_2: + if argc == 1 { + return NewJDList__SWIG_2(a[0].(JDList)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrJDList) Size() (_swig_ret int64) { + var swig_r int64 + _swig_i_0 := arg1 + swig_r = (int64)(C._wrap_JDList_size_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrJDList) Capacity() (_swig_ret int64) { + var swig_r int64 + _swig_i_0 := arg1 + swig_r = (int64)(C._wrap_JDList_capacity_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrJDList) Reserve(arg2 int64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_JDList_reserve_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_type_4(_swig_i_1)) +} + +func (arg1 SwigcptrJDList) IsEmpty() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_JDList_isEmpty_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrJDList) Clear() { + _swig_i_0 := arg1 + C._wrap_JDList_clear_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrJDList) Add(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_JDList_add_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrJDList) Get(arg2 int) (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float64)(C._wrap_JDList_get_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrJDList) Set(arg2 int, arg3 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_JDList_set_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.double(_swig_i_2)) +} + +func DeleteJDList(arg1 JDList) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_JDList_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)) +} + +type JDList interface { + Swigcptr() uintptr + SwigIsJDList() + Size() (_swig_ret int64) + Capacity() (_swig_ret int64) + Reserve(arg2 int64) + IsEmpty() (_swig_ret bool) + Clear() + Add(arg2 float64) + Get(arg2 int) (_swig_ret float64) + Set(arg2 int, arg3 float64) +} + +type SwigcptrJQList uintptr + +func (p SwigcptrJQList) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrJQList) SwigIsJQList() { +} + +func NewJQList__SWIG_0() (_swig_ret JQList) { + var swig_r JQList + swig_r = (JQList)(SwigcptrJQList(C._wrap_new_JQList__SWIG_0_sxtwl_0d57379df002c83c())) + return swig_r +} + +func NewJQList__SWIG_1(arg1 int64) (_swig_ret JQList) { + var swig_r JQList + _swig_i_0 := arg1 + swig_r = (JQList)(SwigcptrJQList(C._wrap_new_JQList__SWIG_1_sxtwl_0d57379df002c83c(C.swig_type_5(_swig_i_0)))) + return swig_r +} + +func NewJQList__SWIG_2(arg1 JQList) (_swig_ret JQList) { + var swig_r JQList + _swig_i_0 := getSwigcptr(arg1) + swig_r = (JQList)(SwigcptrJQList(C._wrap_new_JQList__SWIG_2_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewJQList(a ...interface{}) JQList { + argc := len(a) + if argc == 0 { + return NewJQList__SWIG_0() + } + if argc == 1 { + if _, ok := a[0].(int64); !ok { + goto check_2 + } + return NewJQList__SWIG_1(a[0].(int64)) + } +check_2: + if argc == 1 { + return NewJQList__SWIG_2(a[0].(JQList)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrJQList) Size() (_swig_ret int64) { + var swig_r int64 + _swig_i_0 := arg1 + swig_r = (int64)(C._wrap_JQList_size_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrJQList) Capacity() (_swig_ret int64) { + var swig_r int64 + _swig_i_0 := arg1 + swig_r = (int64)(C._wrap_JQList_capacity_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrJQList) Reserve(arg2 int64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_JQList_reserve_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_type_8(_swig_i_1)) +} + +func (arg1 SwigcptrJQList) IsEmpty() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_JQList_isEmpty_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrJQList) Clear() { + _swig_i_0 := arg1 + C._wrap_JQList_clear_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrJQList) Add(arg2 JieQiInfo) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_JQList_add_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrJQList) Get(arg2 int) (_swig_ret JieQiInfo) { + var swig_r JieQiInfo + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (JieQiInfo)(SwigcptrJieQiInfo(C._wrap_JQList_get_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrJQList) Set(arg2 int, arg3 JieQiInfo) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_JQList_set_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func DeleteJQList(arg1 JQList) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_JQList_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)) +} + +type JQList interface { + Swigcptr() uintptr + SwigIsJQList() + Size() (_swig_ret int64) + Capacity() (_swig_ret int64) + Reserve(arg2 int64) + IsEmpty() (_swig_ret bool) + Clear() + Add(arg2 JieQiInfo) + Get(arg2 int) (_swig_ret JieQiInfo) + Set(arg2 int, arg3 JieQiInfo) +} + +const J2000 int = 2451545 +type SwigcptrTime uintptr + +func (p SwigcptrTime) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrTime) SwigIsTime() { +} + +func NewTime__SWIG_0() (_swig_ret Time) { + var swig_r Time + swig_r = (Time)(SwigcptrTime(C._wrap_new_Time__SWIG_0_sxtwl_0d57379df002c83c())) + return swig_r +} + +func NewTime__SWIG_1(arg1 int, arg2 int, arg3 int, arg4 float64, arg5 float64, arg6 float64) (_swig_ret Time) { + var swig_r Time + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + swig_r = (Time)(SwigcptrTime(C._wrap_new_Time__SWIG_1_sxtwl_0d57379df002c83c(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.double(_swig_i_3), C.double(_swig_i_4), C.double(_swig_i_5)))) + return swig_r +} + +func NewTime(a ...interface{}) Time { + argc := len(a) + if argc == 0 { + return NewTime__SWIG_0() + } + if argc == 6 { + return NewTime__SWIG_1(a[0].(int), a[1].(int), a[2].(int), a[3].(float64), a[4].(float64), a[5].(float64)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrTime) SetY(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_Y_set_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetY() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Time_Y_get_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetM(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_M_set_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetM() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Time_M_get_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetD(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_D_set_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetD() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Time_D_get_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetH(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_h_set_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetH() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_Time_h_get_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetS(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_s_set_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetS() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_Time_s_get_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) GetYear() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Time_getYear_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetYear(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_setYear_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrTime) SetMonth(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_setMonth_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetMonth() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Time_getMonth_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) GetDay() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Time_getDay_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetDay(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_setDay_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetHour() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_Time_getHour_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetHour(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_setHour_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetMin() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_Time_getMin_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetMour(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_setMour_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrTime) GetSec() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_Time_getSec_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrTime) SetSec(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_Time_setSec_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func DeleteTime(arg1 Time) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_Time_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)) +} + +type Time interface { + Swigcptr() uintptr + SwigIsTime() + SetY(arg2 int) + GetY() (_swig_ret int) + SetM(arg2 int) + GetM() (_swig_ret int) + SetD(arg2 int) + GetD() (_swig_ret int) + SetH(arg2 float64) + GetH() (_swig_ret float64) + SetS(arg2 float64) + GetS() (_swig_ret float64) + GetYear() (_swig_ret int) + SetYear(arg2 int) + SetMonth(arg2 int) + GetMonth() (_swig_ret int) + GetDay() (_swig_ret int) + SetDay(arg2 int) + GetHour() (_swig_ret float64) + SetHour(arg2 float64) + GetMin() (_swig_ret float64) + SetMour(arg2 float64) + GetSec() (_swig_ret float64) + SetSec(arg2 float64) +} + +type SwigcptrGZ uintptr + +func (p SwigcptrGZ) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrGZ) SwigIsGZ() { +} + +func NewGZ__SWIG_0() (_swig_ret GZ) { + var swig_r GZ + swig_r = (GZ)(SwigcptrGZ(C._wrap_new_GZ__SWIG_0_sxtwl_0d57379df002c83c())) + return swig_r +} + +func NewGZ__SWIG_1(arg1 byte, arg2 byte) (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (GZ)(SwigcptrGZ(C._wrap_new_GZ__SWIG_1_sxtwl_0d57379df002c83c(C.char(_swig_i_0), C.char(_swig_i_1)))) + return swig_r +} + +func NewGZ(a ...interface{}) GZ { + argc := len(a) + if argc == 0 { + return NewGZ__SWIG_0() + } + if argc == 2 { + return NewGZ__SWIG_1(a[0].(byte), a[1].(byte)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrGZ) SetTg(arg2 byte) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_GZ_tg_set_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.char(_swig_i_1)) +} + +func (arg1 SwigcptrGZ) GetTg() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_GZ_tg_get_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrGZ) SetDz(arg2 byte) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_GZ_dz_set_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.char(_swig_i_1)) +} + +func (arg1 SwigcptrGZ) GetDz() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_GZ_dz_get_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteGZ(arg1 GZ) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_GZ_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)) +} + +type GZ interface { + Swigcptr() uintptr + SwigIsGZ() + SetTg(arg2 byte) + GetTg() (_swig_ret byte) + SetDz(arg2 byte) + GetDz() (_swig_ret byte) +} + +type SwigcptrDay uintptr + +func (p SwigcptrDay) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrDay) SwigIsDay() { +} + +func DayFromSolar(arg1 int, arg2 byte, arg3 int) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (Day)(SwigcptrDay(C._wrap_Day_fromSolar_sxtwl_0d57379df002c83c(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func DayFromLunar__SWIG_0(arg1 int, arg2 byte, arg3 int, arg4 bool) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (Day)(SwigcptrDay(C._wrap_Day_fromLunar__SWIG_0_sxtwl_0d57379df002c83c(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C.swig_intgo(_swig_i_2), C._Bool(_swig_i_3)))) + return swig_r +} + +func DayFromLunar__SWIG_1(arg1 int, arg2 byte, arg3 int) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (Day)(SwigcptrDay(C._wrap_Day_fromLunar__SWIG_1_sxtwl_0d57379df002c83c(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func DayFromLunar(a ...interface{}) Day { + argc := len(a) + if argc == 3 { + return DayFromLunar__SWIG_1(a[0].(int), a[1].(byte), a[2].(int)) + } + if argc == 4 { + return DayFromLunar__SWIG_0(a[0].(int), a[1].(byte), a[2].(int), a[3].(bool)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrDay) After(arg2 int) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (Day)(SwigcptrDay(C._wrap_Day_after_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrDay) Before(arg2 int) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (Day)(SwigcptrDay(C._wrap_Day_before_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrDay) GetLunarDay() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Day_getLunarDay_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetLunarMonth() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_Day_getLunarMonth_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetLunarYear__SWIG_0(arg2 bool) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (int)(C._wrap_Day_getLunarYear__SWIG_0_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrDay) GetLunarYear__SWIG_1() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Day_getLunarYear__SWIG_1_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (p SwigcptrDay) GetLunarYear(a ...interface{}) int { + argc := len(a) + if argc == 0 { + return p.GetLunarYear__SWIG_1() + } + if argc == 1 { + return p.GetLunarYear__SWIG_0(a[0].(bool)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrDay) GetYearGZ__SWIG_0(arg2 bool) (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (GZ)(SwigcptrGZ(C._wrap_Day_getYearGZ__SWIG_0_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrDay) GetYearGZ__SWIG_1() (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + swig_r = (GZ)(SwigcptrGZ(C._wrap_Day_getYearGZ__SWIG_1_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrDay) GetYearGZ(a ...interface{}) GZ { + argc := len(a) + if argc == 0 { + return p.GetYearGZ__SWIG_1() + } + if argc == 1 { + return p.GetYearGZ__SWIG_0(a[0].(bool)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrDay) GetMonthGZ() (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + swig_r = (GZ)(SwigcptrGZ(C._wrap_Day_getMonthGZ_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrDay) GetDayGZ() (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + swig_r = (GZ)(SwigcptrGZ(C._wrap_Day_getDayGZ_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrDay) GetHourGZ__SWIG_0(arg2 byte, arg3 bool) (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (GZ)(SwigcptrGZ(C._wrap_Day_getHourGZ__SWIG_0_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.char(_swig_i_1), C._Bool(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrDay) GetHourGZ__SWIG_1(arg2 byte) (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (GZ)(SwigcptrGZ(C._wrap_Day_getHourGZ__SWIG_1_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.char(_swig_i_1)))) + return swig_r +} + +func (p SwigcptrDay) GetHourGZ(a ...interface{}) GZ { + argc := len(a) + if argc == 1 { + return p.GetHourGZ__SWIG_1(a[0].(byte)) + } + if argc == 2 { + return p.GetHourGZ__SWIG_0(a[0].(byte), a[1].(bool)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrDay) IsLunarLeap() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_Day_isLunarLeap_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetSolarYear() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Day_getSolarYear_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetSolarMonth() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_Day_getSolarMonth_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetSolarDay() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_Day_getSolarDay_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetWeek() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_Day_getWeek_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetWeekIndex() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_Day_getWeekIndex_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) HasJieQi() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_Day_hasJieQi_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetJieQi() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_Day_getJieQi_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetJieQiJD() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_Day_getJieQiJD_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrDay) GetConstellation() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_Day_getConstellation_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteDay(arg1 Day) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_Day_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)) +} + +type Day interface { + Swigcptr() uintptr + SwigIsDay() + After(arg2 int) (_swig_ret Day) + Before(arg2 int) (_swig_ret Day) + GetLunarDay() (_swig_ret int) + GetLunarMonth() (_swig_ret byte) + GetLunarYear(a ...interface{}) int + GetYearGZ(a ...interface{}) GZ + GetMonthGZ() (_swig_ret GZ) + GetDayGZ() (_swig_ret GZ) + GetHourGZ(a ...interface{}) GZ + IsLunarLeap() (_swig_ret bool) + GetSolarYear() (_swig_ret int) + GetSolarMonth() (_swig_ret byte) + GetSolarDay() (_swig_ret int) + GetWeek() (_swig_ret byte) + GetWeekIndex() (_swig_ret byte) + HasJieQi() (_swig_ret bool) + GetJieQi() (_swig_ret byte) + GetJieQiJD() (_swig_ret float64) + GetConstellation() (_swig_ret byte) +} + +type SwigcptrJieQiInfo uintptr + +func (p SwigcptrJieQiInfo) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrJieQiInfo) SwigIsJieQiInfo() { +} + +func (arg1 SwigcptrJieQiInfo) SetJd(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_JieQiInfo_jd_set_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrJieQiInfo) GetJd() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_JieQiInfo_jd_get_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrJieQiInfo) SetJqIndex(arg2 byte) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_JieQiInfo_jqIndex_set_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.char(_swig_i_1)) +} + +func (arg1 SwigcptrJieQiInfo) GetJqIndex() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_JieQiInfo_jqIndex_get_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewJieQiInfo() (_swig_ret JieQiInfo) { + var swig_r JieQiInfo + swig_r = (JieQiInfo)(SwigcptrJieQiInfo(C._wrap_new_JieQiInfo_sxtwl_0d57379df002c83c())) + return swig_r +} + +func DeleteJieQiInfo(arg1 JieQiInfo) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_JieQiInfo_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0)) +} + +type JieQiInfo interface { + Swigcptr() uintptr + SwigIsJieQiInfo() + SetJd(arg2 float64) + GetJd() (_swig_ret float64) + SetJqIndex(arg2 byte) + GetJqIndex() (_swig_ret byte) +} + +func FromSolar(arg1 int, arg2 byte, arg3 int) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (Day)(SwigcptrDay(C._wrap_fromSolar_sxtwl_0d57379df002c83c(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func FromLunar__SWIG_0(arg1 int, arg2 byte, arg3 int, arg4 bool) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (Day)(SwigcptrDay(C._wrap_fromLunar__SWIG_0_sxtwl_0d57379df002c83c(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C.swig_intgo(_swig_i_2), C._Bool(_swig_i_3)))) + return swig_r +} + +func FromLunar__SWIG_1(arg1 int, arg2 byte, arg3 int) (_swig_ret Day) { + var swig_r Day + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (Day)(SwigcptrDay(C._wrap_fromLunar__SWIG_1_sxtwl_0d57379df002c83c(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func FromLunar(a ...interface{}) Day { + argc := len(a) + if argc == 3 { + return FromLunar__SWIG_1(a[0].(int), a[1].(byte), a[2].(int)) + } + if argc == 4 { + return FromLunar__SWIG_0(a[0].(int), a[1].(byte), a[2].(int), a[3].(bool)) + } + panic("No match for overloaded function call") +} + +func SiZhu2Year(arg1 GZ, arg2 GZ, arg3 GZ, arg4 GZ, arg5 int, arg6 int) (_swig_ret JDList) { + var swig_r JDList + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + swig_r = (JDList)(SwigcptrJDList(C._wrap_siZhu2Year_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_intgo(_swig_i_4), C.swig_intgo(_swig_i_5)))) + return swig_r +} + +func GetShiGz__SWIG_0(arg1 byte, arg2 byte, arg3 bool) (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (GZ)(SwigcptrGZ(C._wrap_getShiGz__SWIG_0_sxtwl_0d57379df002c83c(C.char(_swig_i_0), C.char(_swig_i_1), C._Bool(_swig_i_2)))) + return swig_r +} + +func GetShiGz__SWIG_1(arg1 byte, arg2 byte) (_swig_ret GZ) { + var swig_r GZ + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (GZ)(SwigcptrGZ(C._wrap_getShiGz__SWIG_1_sxtwl_0d57379df002c83c(C.char(_swig_i_0), C.char(_swig_i_1)))) + return swig_r +} + +func GetShiGz(a ...interface{}) GZ { + argc := len(a) + if argc == 2 { + return GetShiGz__SWIG_1(a[0].(byte), a[1].(byte)) + } + if argc == 3 { + return GetShiGz__SWIG_0(a[0].(byte), a[1].(byte), a[2].(bool)) + } + panic("No match for overloaded function call") +} + +func GetRunMonth(arg1 int) (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_getRunMonth_sxtwl_0d57379df002c83c(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func GetLunarMonthNum__SWIG_0(arg1 int, arg2 byte, arg3 bool) (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (byte)(C._wrap_getLunarMonthNum__SWIG_0_sxtwl_0d57379df002c83c(C.swig_intgo(_swig_i_0), C.char(_swig_i_1), C._Bool(_swig_i_2))) + return swig_r +} + +func GetLunarMonthNum__SWIG_1(arg1 int, arg2 byte) (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (byte)(C._wrap_getLunarMonthNum__SWIG_1_sxtwl_0d57379df002c83c(C.swig_intgo(_swig_i_0), C.char(_swig_i_1))) + return swig_r +} + +func GetLunarMonthNum(a ...interface{}) byte { + argc := len(a) + if argc == 2 { + return GetLunarMonthNum__SWIG_1(a[0].(int), a[1].(byte)) + } + if argc == 3 { + return GetLunarMonthNum__SWIG_0(a[0].(int), a[1].(byte), a[2].(bool)) + } + panic("No match for overloaded function call") +} + +func JD2DD(arg1 float64) (_swig_ret Time) { + var swig_r Time + _swig_i_0 := arg1 + swig_r = (Time)(SwigcptrTime(C._wrap_JD2DD_sxtwl_0d57379df002c83c(C.double(_swig_i_0)))) + return swig_r +} + +func ToJD(arg1 Time) (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (float64)(C._wrap_toJD_sxtwl_0d57379df002c83c(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func GetJieQiByYear(arg1 int) (_swig_ret JQList) { + var swig_r JQList + _swig_i_0 := arg1 + swig_r = (JQList)(SwigcptrJQList(C._wrap_getJieQiByYear_sxtwl_0d57379df002c83c(C.swig_intgo(_swig_i_0)))) + return swig_r +} + + diff --git a/export/golang/sxtwl_wrap.cxx b/export/golang/sxtwl_wrap.cxx new file mode 100644 index 0000000..929f584 --- /dev/null +++ b/export/golang/sxtwl_wrap.cxx @@ -0,0 +1,1685 @@ +/* ---------------------------------------------------------------------------- + * 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. + * ----------------------------------------------------------------------------- */ + +// source: swig\sxtwl.i + + +extern +#ifdef __cplusplus + "C" +#endif + void cgo_panic__sxtwl_0d57379df002c83c(const char*); +static void _swig_gopanic(const char *p) { + cgo_panic__sxtwl_0d57379df002c83c(p); +} + + + +#define SWIG_VERSION 0x040101 +#define SWIGGO +#define SWIGMODULE sxtwl +/* ----------------------------------------------------------------------------- + * 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 + + +#include +#include +#include +#include +#include + + + +typedef int intgo; +typedef unsigned int uintgo; + + +# if !defined(__clang__) && (defined(__i386__) || defined(__x86_64__)) +# define SWIGSTRUCTPACKED __attribute__((__packed__, __gcc_struct__)) +# else +# define SWIGSTRUCTPACKED __attribute__((__packed__)) +# endif + + + +typedef struct { char *p; intgo n; } _gostring_; +typedef struct { void* array; intgo len; intgo cap; } _goslice_; + + + +#ifdef __cplusplus +#include +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigSmartPointer { + T *ptr; + SwigSmartPointer(T *p) : ptr(p) { } + ~SwigSmartPointer() { delete ptr; } + SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; } +#if __cplusplus >=201103L + SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; } + operator T&&() const { return std::move(*pointer.ptr); } +#else + operator T&() const { return *pointer.ptr; } +#endif + T *operator&() const { return pointer.ptr; } + static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); } +}; + +/* + * SwigValueInit() is a generic initialisation solution as the following approach: + * + * T c_result = T(); + * + * doesn't compile for all types for example: + * + * unsigned int c_result = unsigned int(); + */ +template T SwigValueInit() { + return T(); +} + +#if __cplusplus >=201103L +# define SWIG_STD_MOVE(OBJ) std::move(OBJ) +#else +# define SWIG_STD_MOVE(OBJ) OBJ +#endif + +#endif + + +static void Swig_free(void* p) { + free(p); +} + +static void* Swig_malloc(int c) { + return malloc(c); +} + + +#include "const.h" +#include "sxtwl.h" + + +#include // Use the C99 official header + + +#include +#include + + +#include + +SWIGINTERN std::vector< double >::const_reference std_vector_Sl_double_Sg__get(std::vector< double > *self,int i){ + int size = int(self->size()); + if (i>=0 && i *self,int i,std::vector< double >::value_type const &val){ + int size = int(self->size()); + if (i>=0 && i::const_reference std_vector_Sl_sxtwl_JieQiInfo_Sg__get(std::vector< sxtwl::JieQiInfo > *self,int i){ + int size = int(self->size()); + if (i>=0 && i *self,int i,std::vector< sxtwl::JieQiInfo >::value_type const &val){ + int size = int(self->size()); + if (i>=0 && i *_wrap_new_JDList__SWIG_0_sxtwl_0d57379df002c83c() { + std::vector< double > *result = 0 ; + std::vector< double > *_swig_go_result; + + + result = (std::vector< double > *)new std::vector< double >(); + *(std::vector< double > **)&_swig_go_result = (std::vector< double > *)result; + return _swig_go_result; +} + + +std::vector< double > *_wrap_new_JDList__SWIG_1_sxtwl_0d57379df002c83c(long long _swig_go_0) { + std::vector< double >::size_type arg1 ; + std::vector< double > *result = 0 ; + std::vector< double > *_swig_go_result; + + arg1 = (size_t)_swig_go_0; + + result = (std::vector< double > *)new std::vector< double >(arg1); + *(std::vector< double > **)&_swig_go_result = (std::vector< double > *)result; + return _swig_go_result; +} + + +std::vector< double > *_wrap_new_JDList__SWIG_2_sxtwl_0d57379df002c83c(std::vector< double > *_swig_go_0) { + std::vector< double > *arg1 = 0 ; + std::vector< double > *result = 0 ; + std::vector< double > *_swig_go_result; + + arg1 = *(std::vector< double > **)&_swig_go_0; + + result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1); + *(std::vector< double > **)&_swig_go_result = (std::vector< double > *)result; + return _swig_go_result; +} + + +long long _wrap_JDList_size_sxtwl_0d57379df002c83c(std::vector< double > *_swig_go_0) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type result; + long long _swig_go_result; + + arg1 = *(std::vector< double > **)&_swig_go_0; + + result = ((std::vector< double > const *)arg1)->size(); + _swig_go_result = result; + return _swig_go_result; +} + + +long long _wrap_JDList_capacity_sxtwl_0d57379df002c83c(std::vector< double > *_swig_go_0) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type result; + long long _swig_go_result; + + arg1 = *(std::vector< double > **)&_swig_go_0; + + result = ((std::vector< double > const *)arg1)->capacity(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_JDList_reserve_sxtwl_0d57379df002c83c(std::vector< double > *_swig_go_0, long long _swig_go_1) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type arg2 ; + + arg1 = *(std::vector< double > **)&_swig_go_0; + arg2 = (size_t)_swig_go_1; + + (arg1)->reserve(arg2); + +} + + +bool _wrap_JDList_isEmpty_sxtwl_0d57379df002c83c(std::vector< double > *_swig_go_0) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(std::vector< double > **)&_swig_go_0; + + result = (bool)((std::vector< double > const *)arg1)->empty(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_JDList_clear_sxtwl_0d57379df002c83c(std::vector< double > *_swig_go_0) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + + arg1 = *(std::vector< double > **)&_swig_go_0; + + (arg1)->clear(); + +} + + +void _wrap_JDList_add_sxtwl_0d57379df002c83c(std::vector< double > *_swig_go_0, double _swig_go_1) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::value_type *arg2 = 0 ; + + arg1 = *(std::vector< double > **)&_swig_go_0; + arg2 = (std::vector< double >::value_type *)&_swig_go_1; + + (arg1)->push_back((std::vector< double >::value_type const &)*arg2); + +} + + +double _wrap_JDList_get_sxtwl_0d57379df002c83c(std::vector< double > *_swig_go_0, intgo _swig_go_1) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + std::vector< double >::value_type *result = 0 ; + double _swig_go_result; + + arg1 = *(std::vector< double > **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + try { + result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__get(arg1,arg2); + } catch(std::out_of_range &_e) { + (void)_e; + _swig_gopanic("C++ std::out_of_range exception thrown"); + + } + _swig_go_result = (double)*result; + return _swig_go_result; +} + + +void _wrap_JDList_set_sxtwl_0d57379df002c83c(std::vector< double > *_swig_go_0, intgo _swig_go_1, double _swig_go_2) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + std::vector< double >::value_type *arg3 = 0 ; + + arg1 = *(std::vector< double > **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (std::vector< double >::value_type *)&_swig_go_2; + + try { + std_vector_Sl_double_Sg__set(arg1,arg2,(double const &)*arg3); + } catch(std::out_of_range &_e) { + (void)_e; + _swig_gopanic("C++ std::out_of_range exception thrown"); + + } + +} + + +void _wrap_delete_JDList_sxtwl_0d57379df002c83c(std::vector< double > *_swig_go_0) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + + arg1 = *(std::vector< double > **)&_swig_go_0; + + delete arg1; + +} + + +std::vector< sxtwl::JieQiInfo > *_wrap_new_JQList__SWIG_0_sxtwl_0d57379df002c83c() { + std::vector< sxtwl::JieQiInfo > *result = 0 ; + std::vector< sxtwl::JieQiInfo > *_swig_go_result; + + + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >(); + *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_result = (std::vector< sxtwl::JieQiInfo > *)result; + return _swig_go_result; +} + + +std::vector< sxtwl::JieQiInfo > *_wrap_new_JQList__SWIG_1_sxtwl_0d57379df002c83c(long long _swig_go_0) { + std::vector< sxtwl::JieQiInfo >::size_type arg1 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + std::vector< sxtwl::JieQiInfo > *_swig_go_result; + + arg1 = (size_t)_swig_go_0; + + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >(arg1); + *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_result = (std::vector< sxtwl::JieQiInfo > *)result; + return _swig_go_result; +} + + +std::vector< sxtwl::JieQiInfo > *_wrap_new_JQList__SWIG_2_sxtwl_0d57379df002c83c(std::vector< sxtwl::JieQiInfo > *_swig_go_0) { + std::vector< sxtwl::JieQiInfo > *arg1 = 0 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + std::vector< sxtwl::JieQiInfo > *_swig_go_result; + + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_0; + + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >((std::vector< sxtwl::JieQiInfo > const &)*arg1); + *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_result = (std::vector< sxtwl::JieQiInfo > *)result; + return _swig_go_result; +} + + +long long _wrap_JQList_size_sxtwl_0d57379df002c83c(std::vector< sxtwl::JieQiInfo > *_swig_go_0) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type result; + long long _swig_go_result; + + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_0; + + result = ((std::vector< sxtwl::JieQiInfo > const *)arg1)->size(); + _swig_go_result = result; + return _swig_go_result; +} + + +long long _wrap_JQList_capacity_sxtwl_0d57379df002c83c(std::vector< sxtwl::JieQiInfo > *_swig_go_0) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type result; + long long _swig_go_result; + + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_0; + + result = ((std::vector< sxtwl::JieQiInfo > const *)arg1)->capacity(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_JQList_reserve_sxtwl_0d57379df002c83c(std::vector< sxtwl::JieQiInfo > *_swig_go_0, long long _swig_go_1) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type arg2 ; + + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_0; + arg2 = (size_t)_swig_go_1; + + (arg1)->reserve(arg2); + +} + + +bool _wrap_JQList_isEmpty_sxtwl_0d57379df002c83c(std::vector< sxtwl::JieQiInfo > *_swig_go_0) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_0; + + result = (bool)((std::vector< sxtwl::JieQiInfo > const *)arg1)->empty(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_JQList_clear_sxtwl_0d57379df002c83c(std::vector< sxtwl::JieQiInfo > *_swig_go_0) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_0; + + (arg1)->clear(); + +} + + +void _wrap_JQList_add_sxtwl_0d57379df002c83c(std::vector< sxtwl::JieQiInfo > *_swig_go_0, sxtwl::JieQiInfo *_swig_go_1) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg2 = 0 ; + + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_0; + arg2 = *(std::vector< sxtwl::JieQiInfo >::value_type **)&_swig_go_1; + + (arg1)->push_back((std::vector< sxtwl::JieQiInfo >::value_type const &)*arg2); + +} + + +sxtwl::JieQiInfo *_wrap_JQList_get_sxtwl_0d57379df002c83c(std::vector< sxtwl::JieQiInfo > *_swig_go_0, intgo _swig_go_1) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + std::vector< sxtwl::JieQiInfo >::value_type *result = 0 ; + sxtwl::JieQiInfo *_swig_go_result; + + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + try { + result = (std::vector< sxtwl::JieQiInfo >::value_type *) &std_vector_Sl_sxtwl_JieQiInfo_Sg__get(arg1,arg2); + } catch(std::out_of_range &_e) { + (void)_e; + _swig_gopanic("C++ std::out_of_range exception thrown"); + + } + *(std::vector< sxtwl::JieQiInfo >::value_type **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_JQList_set_sxtwl_0d57379df002c83c(std::vector< sxtwl::JieQiInfo > *_swig_go_0, intgo _swig_go_1, sxtwl::JieQiInfo *_swig_go_2) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg3 = 0 ; + + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(std::vector< sxtwl::JieQiInfo >::value_type **)&_swig_go_2; + + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg__set(arg1,arg2,(sxtwl::JieQiInfo const &)*arg3); + } catch(std::out_of_range &_e) { + (void)_e; + _swig_gopanic("C++ std::out_of_range exception thrown"); + + } + +} + + +void _wrap_delete_JQList_sxtwl_0d57379df002c83c(std::vector< sxtwl::JieQiInfo > *_swig_go_0) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_0; + + delete arg1; + +} + + +Time *_wrap_new_Time__SWIG_0_sxtwl_0d57379df002c83c() { + Time *result = 0 ; + Time *_swig_go_result; + + + result = (Time *)new Time(); + *(Time **)&_swig_go_result = (Time *)result; + return _swig_go_result; +} + + +Time *_wrap_new_Time__SWIG_1_sxtwl_0d57379df002c83c(intgo _swig_go_0, intgo _swig_go_1, intgo _swig_go_2, double _swig_go_3, double _swig_go_4, double _swig_go_5) { + int arg1 ; + int arg2 ; + int arg3 ; + double arg4 ; + double arg5 ; + double arg6 ; + Time *result = 0 ; + Time *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (double)_swig_go_3; + arg5 = (double)_swig_go_4; + arg6 = (double)_swig_go_5; + + result = (Time *)new Time(arg1,arg2,arg3,arg4,arg5,arg6); + *(Time **)&_swig_go_result = (Time *)result; + return _swig_go_result; +} + + +void _wrap_Time_Y_set_sxtwl_0d57379df002c83c(Time *_swig_go_0, intgo _swig_go_1) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + arg1 = *(Time **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->Y = arg2; + +} + + +intgo _wrap_Time_Y_get_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = (Time *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(Time **)&_swig_go_0; + + result = (int) ((arg1)->Y); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_Time_M_set_sxtwl_0d57379df002c83c(Time *_swig_go_0, intgo _swig_go_1) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + arg1 = *(Time **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->M = arg2; + +} + + +intgo _wrap_Time_M_get_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = (Time *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(Time **)&_swig_go_0; + + result = (int) ((arg1)->M); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_Time_D_set_sxtwl_0d57379df002c83c(Time *_swig_go_0, intgo _swig_go_1) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + arg1 = *(Time **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->D = arg2; + +} + + +intgo _wrap_Time_D_get_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = (Time *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(Time **)&_swig_go_0; + + result = (int) ((arg1)->D); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_Time_h_set_sxtwl_0d57379df002c83c(Time *_swig_go_0, double _swig_go_1) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + arg1 = *(Time **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->h = arg2; + +} + + +double _wrap_Time_h_get_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = (Time *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(Time **)&_swig_go_0; + + result = (double) ((arg1)->h); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_Time_s_set_sxtwl_0d57379df002c83c(Time *_swig_go_0, double _swig_go_1) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + arg1 = *(Time **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->s = arg2; + +} + + +double _wrap_Time_s_get_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = (Time *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(Time **)&_swig_go_0; + + result = (double) ((arg1)->s); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_Time_getYear_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = (Time *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(Time **)&_swig_go_0; + + result = (int)(arg1)->getYear(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_Time_setYear_sxtwl_0d57379df002c83c(Time *_swig_go_0, intgo _swig_go_1) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + arg1 = *(Time **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setYear(arg2); + +} + + +void _wrap_Time_setMonth_sxtwl_0d57379df002c83c(Time *_swig_go_0, intgo _swig_go_1) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + arg1 = *(Time **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setMonth(arg2); + +} + + +intgo _wrap_Time_getMonth_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = (Time *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(Time **)&_swig_go_0; + + result = (int)(arg1)->getMonth(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_Time_getDay_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = (Time *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(Time **)&_swig_go_0; + + result = (int)(arg1)->getDay(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_Time_setDay_sxtwl_0d57379df002c83c(Time *_swig_go_0, intgo _swig_go_1) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + arg1 = *(Time **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setDay(arg2); + +} + + +double _wrap_Time_getHour_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = (Time *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(Time **)&_swig_go_0; + + result = (double)(arg1)->getHour(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_Time_setHour_sxtwl_0d57379df002c83c(Time *_swig_go_0, double _swig_go_1) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + arg1 = *(Time **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + (arg1)->setHour(arg2); + +} + + +double _wrap_Time_getMin_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = (Time *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(Time **)&_swig_go_0; + + result = (double)(arg1)->getMin(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_Time_setMour_sxtwl_0d57379df002c83c(Time *_swig_go_0, double _swig_go_1) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + arg1 = *(Time **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + (arg1)->setMour(arg2); + +} + + +double _wrap_Time_getSec_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = (Time *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(Time **)&_swig_go_0; + + result = (double)(arg1)->getSec(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_Time_setSec_sxtwl_0d57379df002c83c(Time *_swig_go_0, double _swig_go_1) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + arg1 = *(Time **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + (arg1)->setSec(arg2); + +} + + +void _wrap_delete_Time_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = (Time *) 0 ; + + arg1 = *(Time **)&_swig_go_0; + + delete arg1; + +} + + +GZ *_wrap_new_GZ__SWIG_0_sxtwl_0d57379df002c83c() { + GZ *result = 0 ; + GZ *_swig_go_result; + + + result = (GZ *)new GZ(); + *(GZ **)&_swig_go_result = (GZ *)result; + return _swig_go_result; +} + + +GZ *_wrap_new_GZ__SWIG_1_sxtwl_0d57379df002c83c(char _swig_go_0, char _swig_go_1) { + uint8_t arg1 ; + uint8_t arg2 ; + GZ *result = 0 ; + GZ *_swig_go_result; + + arg1 = (uint8_t)_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + + result = (GZ *)new GZ(arg1,arg2); + *(GZ **)&_swig_go_result = (GZ *)result; + return _swig_go_result; +} + + +void _wrap_GZ_tg_set_sxtwl_0d57379df002c83c(GZ *_swig_go_0, char _swig_go_1) { + GZ *arg1 = (GZ *) 0 ; + uint8_t arg2 ; + + arg1 = *(GZ **)&_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + + if (arg1) (arg1)->tg = arg2; + +} + + +char _wrap_GZ_tg_get_sxtwl_0d57379df002c83c(GZ *_swig_go_0) { + GZ *arg1 = (GZ *) 0 ; + uint8_t result; + char _swig_go_result; + + arg1 = *(GZ **)&_swig_go_0; + + result = (uint8_t) ((arg1)->tg); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_GZ_dz_set_sxtwl_0d57379df002c83c(GZ *_swig_go_0, char _swig_go_1) { + GZ *arg1 = (GZ *) 0 ; + uint8_t arg2 ; + + arg1 = *(GZ **)&_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + + if (arg1) (arg1)->dz = arg2; + +} + + +char _wrap_GZ_dz_get_sxtwl_0d57379df002c83c(GZ *_swig_go_0) { + GZ *arg1 = (GZ *) 0 ; + uint8_t result; + char _swig_go_result; + + arg1 = *(GZ **)&_swig_go_0; + + result = (uint8_t) ((arg1)->dz); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_GZ_sxtwl_0d57379df002c83c(GZ *_swig_go_0) { + GZ *arg1 = (GZ *) 0 ; + + arg1 = *(GZ **)&_swig_go_0; + + delete arg1; + +} + + +Day *_wrap_Day_fromSolar_sxtwl_0d57379df002c83c(intgo _swig_go_0, char _swig_go_1, intgo _swig_go_2) { + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + Day *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (Day *)Day::fromSolar(arg1,arg2,arg3); + *(Day **)&_swig_go_result = (Day *)result; + return _swig_go_result; +} + + +Day *_wrap_Day_fromLunar__SWIG_0_sxtwl_0d57379df002c83c(intgo _swig_go_0, char _swig_go_1, intgo _swig_go_2, bool _swig_go_3) { + int arg1 ; + uint8_t arg2 ; + int arg3 ; + bool arg4 ; + Day *result = 0 ; + Day *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (bool)_swig_go_3; + + result = (Day *)Day::fromLunar(arg1,arg2,arg3,arg4); + *(Day **)&_swig_go_result = (Day *)result; + return _swig_go_result; +} + + +Day *_wrap_Day_fromLunar__SWIG_1_sxtwl_0d57379df002c83c(intgo _swig_go_0, char _swig_go_1, intgo _swig_go_2) { + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + Day *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (Day *)Day::fromLunar(arg1,arg2,arg3); + *(Day **)&_swig_go_result = (Day *)result; + return _swig_go_result; +} + + +Day *_wrap_Day_after_sxtwl_0d57379df002c83c(Day *_swig_go_0, intgo _swig_go_1) { + Day *arg1 = (Day *) 0 ; + int arg2 ; + Day *result = 0 ; + Day *_swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (Day *)(arg1)->after(arg2); + *(Day **)&_swig_go_result = (Day *)result; + return _swig_go_result; +} + + +Day *_wrap_Day_before_sxtwl_0d57379df002c83c(Day *_swig_go_0, intgo _swig_go_1) { + Day *arg1 = (Day *) 0 ; + int arg2 ; + Day *result = 0 ; + Day *_swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (Day *)(arg1)->before(arg2); + *(Day **)&_swig_go_result = (Day *)result; + return _swig_go_result; +} + + +intgo _wrap_Day_getLunarDay_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (int)(arg1)->getLunarDay(); + _swig_go_result = result; + return _swig_go_result; +} + + +char _wrap_Day_getLunarMonth_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + uint8_t result; + char _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (uint8_t)(arg1)->getLunarMonth(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_Day_getLunarYear__SWIG_0_sxtwl_0d57379df002c83c(Day *_swig_go_0, bool _swig_go_1) { + Day *arg1 = (Day *) 0 ; + bool arg2 ; + int result; + intgo _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + result = (int)(arg1)->getLunarYear(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_Day_getLunarYear__SWIG_1_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (int)(arg1)->getLunarYear(); + _swig_go_result = result; + return _swig_go_result; +} + + +GZ *_wrap_Day_getYearGZ__SWIG_0_sxtwl_0d57379df002c83c(Day *_swig_go_0, bool _swig_go_1) { + Day *arg1 = (Day *) 0 ; + bool arg2 ; + GZ result; + GZ *_swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + result = (arg1)->getYearGZ(arg2); + *(GZ **)&_swig_go_result = new GZ(result); + return _swig_go_result; +} + + +GZ *_wrap_Day_getYearGZ__SWIG_1_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + GZ result; + GZ *_swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (arg1)->getYearGZ(); + *(GZ **)&_swig_go_result = new GZ(result); + return _swig_go_result; +} + + +GZ *_wrap_Day_getMonthGZ_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + GZ result; + GZ *_swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (arg1)->getMonthGZ(); + *(GZ **)&_swig_go_result = new GZ(result); + return _swig_go_result; +} + + +GZ *_wrap_Day_getDayGZ_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + GZ result; + GZ *_swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (arg1)->getDayGZ(); + *(GZ **)&_swig_go_result = new GZ(result); + return _swig_go_result; +} + + +GZ *_wrap_Day_getHourGZ__SWIG_0_sxtwl_0d57379df002c83c(Day *_swig_go_0, char _swig_go_1, bool _swig_go_2) { + Day *arg1 = (Day *) 0 ; + uint8_t arg2 ; + bool arg3 ; + GZ result; + GZ *_swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + arg3 = (bool)_swig_go_2; + + result = (arg1)->getHourGZ(arg2,arg3); + *(GZ **)&_swig_go_result = new GZ(result); + return _swig_go_result; +} + + +GZ *_wrap_Day_getHourGZ__SWIG_1_sxtwl_0d57379df002c83c(Day *_swig_go_0, char _swig_go_1) { + Day *arg1 = (Day *) 0 ; + uint8_t arg2 ; + GZ result; + GZ *_swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + + result = (arg1)->getHourGZ(arg2); + *(GZ **)&_swig_go_result = new GZ(result); + return _swig_go_result; +} + + +bool _wrap_Day_isLunarLeap_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (bool)(arg1)->isLunarLeap(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_Day_getSolarYear_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (int)(arg1)->getSolarYear(); + _swig_go_result = result; + return _swig_go_result; +} + + +char _wrap_Day_getSolarMonth_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + uint8_t result; + char _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (uint8_t)(arg1)->getSolarMonth(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_Day_getSolarDay_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (int)(arg1)->getSolarDay(); + _swig_go_result = result; + return _swig_go_result; +} + + +char _wrap_Day_getWeek_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + uint8_t result; + char _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (uint8_t)(arg1)->getWeek(); + _swig_go_result = result; + return _swig_go_result; +} + + +char _wrap_Day_getWeekIndex_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + uint8_t result; + char _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (uint8_t)(arg1)->getWeekIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_Day_hasJieQi_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (bool)(arg1)->hasJieQi(); + _swig_go_result = result; + return _swig_go_result; +} + + +char _wrap_Day_getJieQi_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + uint8_t result; + char _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (uint8_t)(arg1)->getJieQi(); + _swig_go_result = result; + return _swig_go_result; +} + + +double _wrap_Day_getJieQiJD_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (double)(arg1)->getJieQiJD(); + _swig_go_result = result; + return _swig_go_result; +} + + +char _wrap_Day_getConstellation_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + uint8_t result; + char _swig_go_result; + + arg1 = *(Day **)&_swig_go_0; + + result = (uint8_t)(arg1)->getConstellation(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_Day_sxtwl_0d57379df002c83c(Day *_swig_go_0) { + Day *arg1 = (Day *) 0 ; + + arg1 = *(Day **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_JieQiInfo_jd_set_sxtwl_0d57379df002c83c(sxtwl::JieQiInfo *_swig_go_0, double _swig_go_1) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + double arg2 ; + + arg1 = *(sxtwl::JieQiInfo **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->jd = arg2; + +} + + +double _wrap_JieQiInfo_jd_get_sxtwl_0d57379df002c83c(sxtwl::JieQiInfo *_swig_go_0) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(sxtwl::JieQiInfo **)&_swig_go_0; + + result = (double) ((arg1)->jd); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_JieQiInfo_jqIndex_set_sxtwl_0d57379df002c83c(sxtwl::JieQiInfo *_swig_go_0, char _swig_go_1) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + uint8_t arg2 ; + + arg1 = *(sxtwl::JieQiInfo **)&_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + + if (arg1) (arg1)->jqIndex = arg2; + +} + + +char _wrap_JieQiInfo_jqIndex_get_sxtwl_0d57379df002c83c(sxtwl::JieQiInfo *_swig_go_0) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + uint8_t result; + char _swig_go_result; + + arg1 = *(sxtwl::JieQiInfo **)&_swig_go_0; + + result = (uint8_t) ((arg1)->jqIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +sxtwl::JieQiInfo *_wrap_new_JieQiInfo_sxtwl_0d57379df002c83c() { + sxtwl::JieQiInfo *result = 0 ; + sxtwl::JieQiInfo *_swig_go_result; + + + result = (sxtwl::JieQiInfo *)new sxtwl::JieQiInfo(); + *(sxtwl::JieQiInfo **)&_swig_go_result = (sxtwl::JieQiInfo *)result; + return _swig_go_result; +} + + +void _wrap_delete_JieQiInfo_sxtwl_0d57379df002c83c(sxtwl::JieQiInfo *_swig_go_0) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + + arg1 = *(sxtwl::JieQiInfo **)&_swig_go_0; + + delete arg1; + +} + + +Day *_wrap_fromSolar_sxtwl_0d57379df002c83c(intgo _swig_go_0, char _swig_go_1, intgo _swig_go_2) { + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + Day *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (Day *)sxtwl::fromSolar(arg1,arg2,arg3); + *(Day **)&_swig_go_result = (Day *)result; + return _swig_go_result; +} + + +Day *_wrap_fromLunar__SWIG_0_sxtwl_0d57379df002c83c(intgo _swig_go_0, char _swig_go_1, intgo _swig_go_2, bool _swig_go_3) { + int arg1 ; + uint8_t arg2 ; + int arg3 ; + bool arg4 ; + Day *result = 0 ; + Day *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (bool)_swig_go_3; + + result = (Day *)sxtwl::fromLunar(arg1,arg2,arg3,arg4); + *(Day **)&_swig_go_result = (Day *)result; + return _swig_go_result; +} + + +Day *_wrap_fromLunar__SWIG_1_sxtwl_0d57379df002c83c(intgo _swig_go_0, char _swig_go_1, intgo _swig_go_2) { + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + Day *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (Day *)sxtwl::fromLunar(arg1,arg2,arg3); + *(Day **)&_swig_go_result = (Day *)result; + return _swig_go_result; +} + + +std::vector< double > *_wrap_siZhu2Year_sxtwl_0d57379df002c83c(GZ *_swig_go_0, GZ *_swig_go_1, GZ *_swig_go_2, GZ *_swig_go_3, intgo _swig_go_4, intgo _swig_go_5) { + GZ arg1 ; + GZ arg2 ; + GZ arg3 ; + GZ arg4 ; + int arg5 ; + int arg6 ; + GZ *argp1 ; + GZ *argp2 ; + GZ *argp3 ; + GZ *argp4 ; + std::vector< double > result; + std::vector< double > *_swig_go_result; + + + argp1 = (GZ *)_swig_go_0; + if (argp1 == NULL) { + _swig_gopanic("Attempt to dereference null GZ"); + } + arg1 = (GZ)*argp1; + + + argp2 = (GZ *)_swig_go_1; + if (argp2 == NULL) { + _swig_gopanic("Attempt to dereference null GZ"); + } + arg2 = (GZ)*argp2; + + + argp3 = (GZ *)_swig_go_2; + if (argp3 == NULL) { + _swig_gopanic("Attempt to dereference null GZ"); + } + arg3 = (GZ)*argp3; + + + argp4 = (GZ *)_swig_go_3; + if (argp4 == NULL) { + _swig_gopanic("Attempt to dereference null GZ"); + } + arg4 = (GZ)*argp4; + + arg5 = (int)_swig_go_4; + arg6 = (int)_swig_go_5; + + result = sxtwl::siZhu2Year(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,arg6); + *(std::vector< double > **)&_swig_go_result = new std::vector< double >(result); + return _swig_go_result; +} + + +GZ *_wrap_getShiGz__SWIG_0_sxtwl_0d57379df002c83c(char _swig_go_0, char _swig_go_1, bool _swig_go_2) { + uint8_t arg1 ; + uint8_t arg2 ; + bool arg3 ; + GZ result; + GZ *_swig_go_result; + + arg1 = (uint8_t)_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + arg3 = (bool)_swig_go_2; + + result = sxtwl::getShiGz(arg1,arg2,arg3); + *(GZ **)&_swig_go_result = new GZ(result); + return _swig_go_result; +} + + +GZ *_wrap_getShiGz__SWIG_1_sxtwl_0d57379df002c83c(char _swig_go_0, char _swig_go_1) { + uint8_t arg1 ; + uint8_t arg2 ; + GZ result; + GZ *_swig_go_result; + + arg1 = (uint8_t)_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + + result = sxtwl::getShiGz(arg1,arg2); + *(GZ **)&_swig_go_result = new GZ(result); + return _swig_go_result; +} + + +char _wrap_getRunMonth_sxtwl_0d57379df002c83c(intgo _swig_go_0) { + int arg1 ; + uint8_t result; + char _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (uint8_t)sxtwl::getRunMonth(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +char _wrap_getLunarMonthNum__SWIG_0_sxtwl_0d57379df002c83c(intgo _swig_go_0, char _swig_go_1, bool _swig_go_2) { + int arg1 ; + uint8_t arg2 ; + bool arg3 ; + uint8_t result; + char _swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + arg3 = (bool)_swig_go_2; + + result = (uint8_t)sxtwl::getLunarMonthNum(arg1,arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +char _wrap_getLunarMonthNum__SWIG_1_sxtwl_0d57379df002c83c(intgo _swig_go_0, char _swig_go_1) { + int arg1 ; + uint8_t arg2 ; + uint8_t result; + char _swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (uint8_t)_swig_go_1; + + result = (uint8_t)sxtwl::getLunarMonthNum(arg1,arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +Time *_wrap_JD2DD_sxtwl_0d57379df002c83c(double _swig_go_0) { + double arg1 ; + Time result; + Time *_swig_go_result; + + arg1 = (double)_swig_go_0; + + result = sxtwl::JD2DD(arg1); + *(Time **)&_swig_go_result = new Time(result); + return _swig_go_result; +} + + +double _wrap_toJD_sxtwl_0d57379df002c83c(Time *_swig_go_0) { + Time *arg1 = 0 ; + double result; + double _swig_go_result; + + arg1 = *(Time **)&_swig_go_0; + + result = (double)sxtwl::toJD(*arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +std::vector< sxtwl::JieQiInfo > *_wrap_getJieQiByYear_sxtwl_0d57379df002c83c(intgo _swig_go_0) { + int arg1 ; + std::vector< sxtwl::JieQiInfo > result; + std::vector< sxtwl::JieQiInfo > *_swig_go_result; + + arg1 = (int)_swig_go_0; + + result = sxtwl::getJieQiByYear(arg1); + *(std::vector< sxtwl::JieQiInfo > **)&_swig_go_result = new std::vector< sxtwl::JieQiInfo >(result); + return _swig_go_result; +} + + +#ifdef __cplusplus +} +#endif + diff --git a/export/java/Day.java b/export/java/Day.java new file mode 100644 index 0000000..5ef5e4b --- /dev/null +++ b/export/java/Day.java @@ -0,0 +1,156 @@ +/* ---------------------------------------------------------------------------- + * 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. + * ----------------------------------------------------------------------------- */ + +package com.seantone.sxtwl; + +public class Day { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected Day(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(Day obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(Day obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + sxtwlJNI.delete_Day(swigCPtr); + } + swigCPtr = 0; + } + } + + public static Day fromSolar(int _year, short _month, int _day) { + long cPtr = sxtwlJNI.Day_fromSolar(_year, _month, _day); + return (cPtr == 0) ? null : new Day(cPtr, false); + } + + public static Day fromLunar(int year, short month, int day, boolean isRun) { + long cPtr = sxtwlJNI.Day_fromLunar__SWIG_0(year, month, day, isRun); + return (cPtr == 0) ? null : new Day(cPtr, false); + } + + public static Day fromLunar(int year, short month, int day) { + long cPtr = sxtwlJNI.Day_fromLunar__SWIG_1(year, month, day); + return (cPtr == 0) ? null : new Day(cPtr, false); + } + + public Day after(int day) { + long cPtr = sxtwlJNI.Day_after(swigCPtr, this, day); + return (cPtr == 0) ? null : new Day(cPtr, false); + } + + public Day before(int day) { + long cPtr = sxtwlJNI.Day_before(swigCPtr, this, day); + return (cPtr == 0) ? null : new Day(cPtr, false); + } + + public int getLunarDay() { + return sxtwlJNI.Day_getLunarDay(swigCPtr, this); + } + + public short getLunarMonth() { + return sxtwlJNI.Day_getLunarMonth(swigCPtr, this); + } + + public int getLunarYear(boolean chineseNewYearBoundary) { + return sxtwlJNI.Day_getLunarYear__SWIG_0(swigCPtr, this, chineseNewYearBoundary); + } + + public int getLunarYear() { + return sxtwlJNI.Day_getLunarYear__SWIG_1(swigCPtr, this); + } + + public GZ getYearGZ(boolean chineseNewYearBoundary) { + return new GZ(sxtwlJNI.Day_getYearGZ__SWIG_0(swigCPtr, this, chineseNewYearBoundary), true); + } + + public GZ getYearGZ() { + return new GZ(sxtwlJNI.Day_getYearGZ__SWIG_1(swigCPtr, this), true); + } + + public GZ getMonthGZ() { + return new GZ(sxtwlJNI.Day_getMonthGZ(swigCPtr, this), true); + } + + public GZ getDayGZ() { + return new GZ(sxtwlJNI.Day_getDayGZ(swigCPtr, this), true); + } + + public GZ getHourGZ(short hour, boolean isZaoWanZiShi) { + return new GZ(sxtwlJNI.Day_getHourGZ__SWIG_0(swigCPtr, this, hour, isZaoWanZiShi), true); + } + + public GZ getHourGZ(short hour) { + return new GZ(sxtwlJNI.Day_getHourGZ__SWIG_1(swigCPtr, this, hour), true); + } + + public boolean isLunarLeap() { + return sxtwlJNI.Day_isLunarLeap(swigCPtr, this); + } + + public int getSolarYear() { + return sxtwlJNI.Day_getSolarYear(swigCPtr, this); + } + + public short getSolarMonth() { + return sxtwlJNI.Day_getSolarMonth(swigCPtr, this); + } + + public int getSolarDay() { + return sxtwlJNI.Day_getSolarDay(swigCPtr, this); + } + + public short getWeek() { + return sxtwlJNI.Day_getWeek(swigCPtr, this); + } + + public short getWeekIndex() { + return sxtwlJNI.Day_getWeekIndex(swigCPtr, this); + } + + public boolean hasJieQi() { + return sxtwlJNI.Day_hasJieQi(swigCPtr, this); + } + + public short getJieQi() { + return sxtwlJNI.Day_getJieQi(swigCPtr, this); + } + + public double getJieQiJD() { + return sxtwlJNI.Day_getJieQiJD(swigCPtr, this); + } + + public short getConstellation() { + return sxtwlJNI.Day_getConstellation(swigCPtr, this); + } + +} diff --git a/export/java/GZ.java b/export/java/GZ.java new file mode 100644 index 0000000..0b0b46c --- /dev/null +++ b/export/java/GZ.java @@ -0,0 +1,75 @@ +/* ---------------------------------------------------------------------------- + * 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. + * ----------------------------------------------------------------------------- */ + +package com.seantone.sxtwl; + +public class GZ { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected GZ(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(GZ obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(GZ obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + sxtwlJNI.delete_GZ(swigCPtr); + } + swigCPtr = 0; + } + } + + public GZ() { + this(sxtwlJNI.new_GZ__SWIG_0(), true); + } + + public GZ(short tg, short dz) { + this(sxtwlJNI.new_GZ__SWIG_1(tg, dz), true); + } + + public void setTg(short value) { + sxtwlJNI.GZ_tg_set(swigCPtr, this, value); + } + + public short getTg() { + return sxtwlJNI.GZ_tg_get(swigCPtr, this); + } + + public void setDz(short value) { + sxtwlJNI.GZ_dz_set(swigCPtr, this, value); + } + + public short getDz() { + return sxtwlJNI.GZ_dz_get(swigCPtr, this); + } + +} diff --git a/export/java/JDList.java b/export/java/JDList.java new file mode 100644 index 0000000..ef91529 --- /dev/null +++ b/export/java/JDList.java @@ -0,0 +1,156 @@ +/* ---------------------------------------------------------------------------- + * 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. + * ----------------------------------------------------------------------------- */ + +package com.seantone.sxtwl; + +public class JDList extends java.util.AbstractList implements java.util.RandomAccess { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected JDList(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(JDList obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(JDList obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + sxtwlJNI.delete_JDList(swigCPtr); + } + swigCPtr = 0; + } + } + + public JDList(double[] initialElements) { + this(); + reserve(initialElements.length); + + for (double element : initialElements) { + add(element); + } + } + + public JDList(Iterable initialElements) { + this(); + for (double element : initialElements) { + add(element); + } + } + + public Double get(int index) { + return doGet(index); + } + + public Double set(int index, Double e) { + return doSet(index, e); + } + + public boolean add(Double e) { + modCount++; + doAdd(e); + return true; + } + + public void add(int index, Double e) { + modCount++; + doAdd(index, e); + } + + public Double remove(int index) { + modCount++; + return doRemove(index); + } + + protected void removeRange(int fromIndex, int toIndex) { + modCount++; + doRemoveRange(fromIndex, toIndex); + } + + public int size() { + return doSize(); + } + + public JDList() { + this(sxtwlJNI.new_JDList__SWIG_0(), true); + } + + public JDList(JDList other) { + this(sxtwlJNI.new_JDList__SWIG_1(JDList.getCPtr(other), other), true); + } + + public long capacity() { + return sxtwlJNI.JDList_capacity(swigCPtr, this); + } + + public void reserve(long n) { + sxtwlJNI.JDList_reserve(swigCPtr, this, n); + } + + public boolean isEmpty() { + return sxtwlJNI.JDList_isEmpty(swigCPtr, this); + } + + public void clear() { + sxtwlJNI.JDList_clear(swigCPtr, this); + } + + public JDList(int count, double value) { + this(sxtwlJNI.new_JDList__SWIG_2(count, value), true); + } + + private int doSize() { + return sxtwlJNI.JDList_doSize(swigCPtr, this); + } + + private void doAdd(double x) { + sxtwlJNI.JDList_doAdd__SWIG_0(swigCPtr, this, x); + } + + private void doAdd(int index, double x) { + sxtwlJNI.JDList_doAdd__SWIG_1(swigCPtr, this, index, x); + } + + private double doRemove(int index) { + return sxtwlJNI.JDList_doRemove(swigCPtr, this, index); + } + + private double doGet(int index) { + return sxtwlJNI.JDList_doGet(swigCPtr, this, index); + } + + private double doSet(int index, double val) { + return sxtwlJNI.JDList_doSet(swigCPtr, this, index, val); + } + + private void doRemoveRange(int fromIndex, int toIndex) { + sxtwlJNI.JDList_doRemoveRange(swigCPtr, this, fromIndex, toIndex); + } + +} diff --git a/export/java/JQList.java b/export/java/JQList.java new file mode 100644 index 0000000..42b3be6 --- /dev/null +++ b/export/java/JQList.java @@ -0,0 +1,156 @@ +/* ---------------------------------------------------------------------------- + * 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. + * ----------------------------------------------------------------------------- */ + +package com.seantone.sxtwl; + +public class JQList extends java.util.AbstractList implements java.util.RandomAccess { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected JQList(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(JQList obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(JQList obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + sxtwlJNI.delete_JQList(swigCPtr); + } + swigCPtr = 0; + } + } + + public JQList(JieQiInfo[] initialElements) { + this(); + reserve(initialElements.length); + + for (JieQiInfo element : initialElements) { + add(element); + } + } + + public JQList(Iterable initialElements) { + this(); + for (JieQiInfo element : initialElements) { + add(element); + } + } + + public JieQiInfo get(int index) { + return doGet(index); + } + + public JieQiInfo set(int index, JieQiInfo e) { + return doSet(index, e); + } + + public boolean add(JieQiInfo e) { + modCount++; + doAdd(e); + return true; + } + + public void add(int index, JieQiInfo e) { + modCount++; + doAdd(index, e); + } + + public JieQiInfo remove(int index) { + modCount++; + return doRemove(index); + } + + protected void removeRange(int fromIndex, int toIndex) { + modCount++; + doRemoveRange(fromIndex, toIndex); + } + + public int size() { + return doSize(); + } + + public JQList() { + this(sxtwlJNI.new_JQList__SWIG_0(), true); + } + + public JQList(JQList other) { + this(sxtwlJNI.new_JQList__SWIG_1(JQList.getCPtr(other), other), true); + } + + public long capacity() { + return sxtwlJNI.JQList_capacity(swigCPtr, this); + } + + public void reserve(long n) { + sxtwlJNI.JQList_reserve(swigCPtr, this, n); + } + + public boolean isEmpty() { + return sxtwlJNI.JQList_isEmpty(swigCPtr, this); + } + + public void clear() { + sxtwlJNI.JQList_clear(swigCPtr, this); + } + + public JQList(int count, JieQiInfo value) { + this(sxtwlJNI.new_JQList__SWIG_2(count, JieQiInfo.getCPtr(value), value), true); + } + + private int doSize() { + return sxtwlJNI.JQList_doSize(swigCPtr, this); + } + + private void doAdd(JieQiInfo x) { + sxtwlJNI.JQList_doAdd__SWIG_0(swigCPtr, this, JieQiInfo.getCPtr(x), x); + } + + private void doAdd(int index, JieQiInfo x) { + sxtwlJNI.JQList_doAdd__SWIG_1(swigCPtr, this, index, JieQiInfo.getCPtr(x), x); + } + + private JieQiInfo doRemove(int index) { + return new JieQiInfo(sxtwlJNI.JQList_doRemove(swigCPtr, this, index), true); + } + + private JieQiInfo doGet(int index) { + return new JieQiInfo(sxtwlJNI.JQList_doGet(swigCPtr, this, index), false); + } + + private JieQiInfo doSet(int index, JieQiInfo val) { + return new JieQiInfo(sxtwlJNI.JQList_doSet(swigCPtr, this, index, JieQiInfo.getCPtr(val), val), true); + } + + private void doRemoveRange(int fromIndex, int toIndex) { + sxtwlJNI.JQList_doRemoveRange(swigCPtr, this, fromIndex, toIndex); + } + +} diff --git a/export/java/JieQiInfo.java b/export/java/JieQiInfo.java new file mode 100644 index 0000000..1038e27 --- /dev/null +++ b/export/java/JieQiInfo.java @@ -0,0 +1,71 @@ +/* ---------------------------------------------------------------------------- + * 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. + * ----------------------------------------------------------------------------- */ + +package com.seantone.sxtwl; + +public class JieQiInfo { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected JieQiInfo(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(JieQiInfo obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(JieQiInfo obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + sxtwlJNI.delete_JieQiInfo(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setJd(double value) { + sxtwlJNI.JieQiInfo_jd_set(swigCPtr, this, value); + } + + public double getJd() { + return sxtwlJNI.JieQiInfo_jd_get(swigCPtr, this); + } + + public void setJqIndex(short value) { + sxtwlJNI.JieQiInfo_jqIndex_set(swigCPtr, this, value); + } + + public short getJqIndex() { + return sxtwlJNI.JieQiInfo_jqIndex_get(swigCPtr, this); + } + + public JieQiInfo() { + this(sxtwlJNI.new_JieQiInfo(), true); + } + +} diff --git a/export/java/Time.java b/export/java/Time.java new file mode 100644 index 0000000..e9b5e77 --- /dev/null +++ b/export/java/Time.java @@ -0,0 +1,155 @@ +/* ---------------------------------------------------------------------------- + * 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. + * ----------------------------------------------------------------------------- */ + +package com.seantone.sxtwl; + +public class Time { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected Time(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(Time obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(Time obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + sxtwlJNI.delete_Time(swigCPtr); + } + swigCPtr = 0; + } + } + + public Time() { + this(sxtwlJNI.new_Time__SWIG_0(), true); + } + + public Time(int year, int month, int day, double hour, double min, double sec) { + this(sxtwlJNI.new_Time__SWIG_1(year, month, day, hour, min, sec), true); + } + + public void setY(int value) { + sxtwlJNI.Time_Y_set(swigCPtr, this, value); + } + + public int getY() { + return sxtwlJNI.Time_Y_get(swigCPtr, this); + } + + public void setM(int value) { + sxtwlJNI.Time_M_set(swigCPtr, this, value); + } + + public int getM() { + return sxtwlJNI.Time_M_get(swigCPtr, this); + } + + public void setD(int value) { + sxtwlJNI.Time_D_set(swigCPtr, this, value); + } + + public int getD() { + return sxtwlJNI.Time_D_get(swigCPtr, this); + } + + public void setH(double value) { + sxtwlJNI.Time_h_set(swigCPtr, this, value); + } + + public double getH() { + return sxtwlJNI.Time_h_get(swigCPtr, this); + } + + public void setM(double value) { + sxtwlJNI.Time_m_set(swigCPtr, this, value); + } + + public double getM() { + return sxtwlJNI.Time_m_get(swigCPtr, this); + } + + public void setS(double value) { + sxtwlJNI.Time_s_set(swigCPtr, this, value); + } + + public double getS() { + return sxtwlJNI.Time_s_get(swigCPtr, this); + } + + public int getYear() { + return sxtwlJNI.Time_getYear(swigCPtr, this); + } + + public void setYear(int year) { + sxtwlJNI.Time_setYear(swigCPtr, this, year); + } + + public void setMonth(int month) { + sxtwlJNI.Time_setMonth(swigCPtr, this, month); + } + + public int getMonth() { + return sxtwlJNI.Time_getMonth(swigCPtr, this); + } + + public int getDay() { + return sxtwlJNI.Time_getDay(swigCPtr, this); + } + + public void setDay(int day) { + sxtwlJNI.Time_setDay(swigCPtr, this, day); + } + + public double getHour() { + return sxtwlJNI.Time_getHour(swigCPtr, this); + } + + public void setHour(double hour) { + sxtwlJNI.Time_setHour(swigCPtr, this, hour); + } + + public double getMin() { + return sxtwlJNI.Time_getMin(swigCPtr, this); + } + + public void setMour(double min) { + sxtwlJNI.Time_setMour(swigCPtr, this, min); + } + + public double getSec() { + return sxtwlJNI.Time_getSec(swigCPtr, this); + } + + public void setSec(double sec) { + sxtwlJNI.Time_setSec(swigCPtr, this, sec); + } + +} diff --git a/export/java/sxtwl.java b/export/java/sxtwl.java new file mode 100644 index 0000000..78c0ea3 --- /dev/null +++ b/export/java/sxtwl.java @@ -0,0 +1,63 @@ +/* ---------------------------------------------------------------------------- + * 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. + * ----------------------------------------------------------------------------- */ + +package com.seantone.sxtwl; + +public class sxtwl implements sxtwlConstants { + public static Day fromSolar(int year, short month, int day) { + long cPtr = sxtwlJNI.fromSolar(year, month, day); + return (cPtr == 0) ? null : new Day(cPtr, false); + } + + public static Day fromLunar(int year, short month, int day, boolean isRun) { + long cPtr = sxtwlJNI.fromLunar__SWIG_0(year, month, day, isRun); + return (cPtr == 0) ? null : new Day(cPtr, false); + } + + public static Day fromLunar(int year, short month, int day) { + long cPtr = sxtwlJNI.fromLunar__SWIG_1(year, month, day); + return (cPtr == 0) ? null : new Day(cPtr, false); + } + + public static JDList siZhu2Year(GZ year, GZ yue, GZ ri, GZ shi, int fromYear, int toYear) { + return new JDList(sxtwlJNI.siZhu2Year(GZ.getCPtr(year), year, GZ.getCPtr(yue), yue, GZ.getCPtr(ri), ri, GZ.getCPtr(shi), shi, fromYear, toYear), true); + } + + public static GZ getShiGz(short dayTg, short hour, boolean isZaoWanZiShi) { + return new GZ(sxtwlJNI.getShiGz__SWIG_0(dayTg, hour, isZaoWanZiShi), true); + } + + public static GZ getShiGz(short dayTg, short hour) { + return new GZ(sxtwlJNI.getShiGz__SWIG_1(dayTg, hour), true); + } + + public static short getRunMonth(int By) { + return sxtwlJNI.getRunMonth(By); + } + + public static short getLunarMonthNum(int By, short month, boolean isRun) { + return sxtwlJNI.getLunarMonthNum__SWIG_0(By, month, isRun); + } + + public static short getLunarMonthNum(int By, short month) { + return sxtwlJNI.getLunarMonthNum__SWIG_1(By, month); + } + + public static Time JD2DD(double jd) { + return new Time(sxtwlJNI.JD2DD(jd), true); + } + + public static double toJD(Time time) { + return sxtwlJNI.toJD(Time.getCPtr(time), time); + } + + public static JQList getJieQiByYear(int year) { + return new JQList(sxtwlJNI.getJieQiByYear(year), true); + } + +} diff --git a/export/java/sxtwlConstants.java b/export/java/sxtwlConstants.java new file mode 100644 index 0000000..241dba8 --- /dev/null +++ b/export/java/sxtwlConstants.java @@ -0,0 +1,13 @@ +/* ---------------------------------------------------------------------------- + * 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. + * ----------------------------------------------------------------------------- */ + +package com.seantone.sxtwl; + +public interface sxtwlConstants { + public final static int J2000 = sxtwlJNI.J2000_get(); +} diff --git a/export/java/sxtwlJNI.java b/export/java/sxtwlJNI.java new file mode 100644 index 0000000..acf0cc3 --- /dev/null +++ b/export/java/sxtwlJNI.java @@ -0,0 +1,121 @@ +/* ---------------------------------------------------------------------------- + * 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. + * ----------------------------------------------------------------------------- */ + +package com.seantone.sxtwl; + +public class sxtwlJNI { + public final static native long new_JDList__SWIG_0(); + public final static native long new_JDList__SWIG_1(long jarg1, JDList jarg1_); + public final static native long JDList_capacity(long jarg1, JDList jarg1_); + public final static native void JDList_reserve(long jarg1, JDList jarg1_, long jarg2); + public final static native boolean JDList_isEmpty(long jarg1, JDList jarg1_); + public final static native void JDList_clear(long jarg1, JDList jarg1_); + public final static native long new_JDList__SWIG_2(int jarg1, double jarg2); + public final static native int JDList_doSize(long jarg1, JDList jarg1_); + public final static native void JDList_doAdd__SWIG_0(long jarg1, JDList jarg1_, double jarg2); + public final static native void JDList_doAdd__SWIG_1(long jarg1, JDList jarg1_, int jarg2, double jarg3); + public final static native double JDList_doRemove(long jarg1, JDList jarg1_, int jarg2); + public final static native double JDList_doGet(long jarg1, JDList jarg1_, int jarg2); + public final static native double JDList_doSet(long jarg1, JDList jarg1_, int jarg2, double jarg3); + public final static native void JDList_doRemoveRange(long jarg1, JDList jarg1_, int jarg2, int jarg3); + public final static native void delete_JDList(long jarg1); + public final static native long new_JQList__SWIG_0(); + public final static native long new_JQList__SWIG_1(long jarg1, JQList jarg1_); + public final static native long JQList_capacity(long jarg1, JQList jarg1_); + public final static native void JQList_reserve(long jarg1, JQList jarg1_, long jarg2); + public final static native boolean JQList_isEmpty(long jarg1, JQList jarg1_); + public final static native void JQList_clear(long jarg1, JQList jarg1_); + public final static native long new_JQList__SWIG_2(int jarg1, long jarg2, JieQiInfo jarg2_); + public final static native int JQList_doSize(long jarg1, JQList jarg1_); + public final static native void JQList_doAdd__SWIG_0(long jarg1, JQList jarg1_, long jarg2, JieQiInfo jarg2_); + public final static native void JQList_doAdd__SWIG_1(long jarg1, JQList jarg1_, int jarg2, long jarg3, JieQiInfo jarg3_); + public final static native long JQList_doRemove(long jarg1, JQList jarg1_, int jarg2); + public final static native long JQList_doGet(long jarg1, JQList jarg1_, int jarg2); + public final static native long JQList_doSet(long jarg1, JQList jarg1_, int jarg2, long jarg3, JieQiInfo jarg3_); + public final static native void JQList_doRemoveRange(long jarg1, JQList jarg1_, int jarg2, int jarg3); + public final static native void delete_JQList(long jarg1); + public final static native int J2000_get(); + public final static native long new_Time__SWIG_0(); + public final static native long new_Time__SWIG_1(int jarg1, int jarg2, int jarg3, double jarg4, double jarg5, double jarg6); + public final static native void Time_Y_set(long jarg1, Time jarg1_, int jarg2); + public final static native int Time_Y_get(long jarg1, Time jarg1_); + public final static native void Time_M_set(long jarg1, Time jarg1_, int jarg2); + public final static native int Time_M_get(long jarg1, Time jarg1_); + public final static native void Time_D_set(long jarg1, Time jarg1_, int jarg2); + public final static native int Time_D_get(long jarg1, Time jarg1_); + public final static native void Time_h_set(long jarg1, Time jarg1_, double jarg2); + public final static native double Time_h_get(long jarg1, Time jarg1_); + public final static native void Time_m_set(long jarg1, Time jarg1_, double jarg2); + public final static native double Time_m_get(long jarg1, Time jarg1_); + public final static native void Time_s_set(long jarg1, Time jarg1_, double jarg2); + public final static native double Time_s_get(long jarg1, Time jarg1_); + public final static native int Time_getYear(long jarg1, Time jarg1_); + public final static native void Time_setYear(long jarg1, Time jarg1_, int jarg2); + public final static native void Time_setMonth(long jarg1, Time jarg1_, int jarg2); + public final static native int Time_getMonth(long jarg1, Time jarg1_); + public final static native int Time_getDay(long jarg1, Time jarg1_); + public final static native void Time_setDay(long jarg1, Time jarg1_, int jarg2); + public final static native double Time_getHour(long jarg1, Time jarg1_); + public final static native void Time_setHour(long jarg1, Time jarg1_, double jarg2); + public final static native double Time_getMin(long jarg1, Time jarg1_); + public final static native void Time_setMour(long jarg1, Time jarg1_, double jarg2); + public final static native double Time_getSec(long jarg1, Time jarg1_); + public final static native void Time_setSec(long jarg1, Time jarg1_, double jarg2); + public final static native void delete_Time(long jarg1); + public final static native long new_GZ__SWIG_0(); + public final static native long new_GZ__SWIG_1(short jarg1, short jarg2); + public final static native void GZ_tg_set(long jarg1, GZ jarg1_, short jarg2); + public final static native short GZ_tg_get(long jarg1, GZ jarg1_); + public final static native void GZ_dz_set(long jarg1, GZ jarg1_, short jarg2); + public final static native short GZ_dz_get(long jarg1, GZ jarg1_); + public final static native void delete_GZ(long jarg1); + public final static native long Day_fromSolar(int jarg1, short jarg2, int jarg3); + public final static native long Day_fromLunar__SWIG_0(int jarg1, short jarg2, int jarg3, boolean jarg4); + public final static native long Day_fromLunar__SWIG_1(int jarg1, short jarg2, int jarg3); + public final static native long Day_after(long jarg1, Day jarg1_, int jarg2); + public final static native long Day_before(long jarg1, Day jarg1_, int jarg2); + public final static native int Day_getLunarDay(long jarg1, Day jarg1_); + public final static native short Day_getLunarMonth(long jarg1, Day jarg1_); + public final static native int Day_getLunarYear__SWIG_0(long jarg1, Day jarg1_, boolean jarg2); + public final static native int Day_getLunarYear__SWIG_1(long jarg1, Day jarg1_); + public final static native long Day_getYearGZ__SWIG_0(long jarg1, Day jarg1_, boolean jarg2); + public final static native long Day_getYearGZ__SWIG_1(long jarg1, Day jarg1_); + public final static native long Day_getMonthGZ(long jarg1, Day jarg1_); + public final static native long Day_getDayGZ(long jarg1, Day jarg1_); + public final static native long Day_getHourGZ__SWIG_0(long jarg1, Day jarg1_, short jarg2, boolean jarg3); + public final static native long Day_getHourGZ__SWIG_1(long jarg1, Day jarg1_, short jarg2); + public final static native boolean Day_isLunarLeap(long jarg1, Day jarg1_); + public final static native int Day_getSolarYear(long jarg1, Day jarg1_); + public final static native short Day_getSolarMonth(long jarg1, Day jarg1_); + public final static native int Day_getSolarDay(long jarg1, Day jarg1_); + public final static native short Day_getWeek(long jarg1, Day jarg1_); + public final static native short Day_getWeekIndex(long jarg1, Day jarg1_); + public final static native boolean Day_hasJieQi(long jarg1, Day jarg1_); + public final static native short Day_getJieQi(long jarg1, Day jarg1_); + public final static native double Day_getJieQiJD(long jarg1, Day jarg1_); + public final static native short Day_getConstellation(long jarg1, Day jarg1_); + public final static native void delete_Day(long jarg1); + public final static native void JieQiInfo_jd_set(long jarg1, JieQiInfo jarg1_, double jarg2); + public final static native double JieQiInfo_jd_get(long jarg1, JieQiInfo jarg1_); + public final static native void JieQiInfo_jqIndex_set(long jarg1, JieQiInfo jarg1_, short jarg2); + public final static native short JieQiInfo_jqIndex_get(long jarg1, JieQiInfo jarg1_); + public final static native long new_JieQiInfo(); + public final static native void delete_JieQiInfo(long jarg1); + public final static native long fromSolar(int jarg1, short jarg2, int jarg3); + public final static native long fromLunar__SWIG_0(int jarg1, short jarg2, int jarg3, boolean jarg4); + public final static native long fromLunar__SWIG_1(int jarg1, short jarg2, int jarg3); + public final static native long siZhu2Year(long jarg1, GZ jarg1_, long jarg2, GZ jarg2_, long jarg3, GZ jarg3_, long jarg4, GZ jarg4_, int jarg5, int jarg6); + public final static native long getShiGz__SWIG_0(short jarg1, short jarg2, boolean jarg3); + public final static native long getShiGz__SWIG_1(short jarg1, short jarg2); + public final static native short getRunMonth(int jarg1); + public final static native short getLunarMonthNum__SWIG_0(int jarg1, short jarg2, boolean jarg3); + public final static native short getLunarMonthNum__SWIG_1(int jarg1, short jarg2); + public final static native long JD2DD(double jarg1); + public final static native double toJD(long jarg1, Time jarg1_); + public final static native long getJieQiByYear(int jarg1); +} diff --git a/export/java/sxtwl_wrap.cxx b/export/java/sxtwl_wrap.cxx new file mode 100644 index 0000000..dfa48bf --- /dev/null +++ b/export/java/sxtwl_wrap.cxx @@ -0,0 +1,2156 @@ +/* ---------------------------------------------------------------------------- + * 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 SWIGJAVA + +/* ----------------------------------------------------------------------------- + * 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 + + +#include +#include +#include + + +/* Support for throwing Java exceptions */ +typedef enum { + SWIG_JavaOutOfMemoryError = 1, + SWIG_JavaIOException, + SWIG_JavaRuntimeException, + SWIG_JavaIndexOutOfBoundsException, + SWIG_JavaArithmeticException, + SWIG_JavaIllegalArgumentException, + SWIG_JavaNullPointerException, + SWIG_JavaDirectorPureVirtual, + SWIG_JavaUnknownError, + SWIG_JavaIllegalStateException, +} SWIG_JavaExceptionCodes; + +typedef struct { + SWIG_JavaExceptionCodes code; + const char *java_exception; +} SWIG_JavaExceptions_t; + + +static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) { + jclass excep; + static const SWIG_JavaExceptions_t java_exceptions[] = { + { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" }, + { SWIG_JavaIOException, "java/io/IOException" }, + { SWIG_JavaRuntimeException, "java/lang/RuntimeException" }, + { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" }, + { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" }, + { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" }, + { SWIG_JavaNullPointerException, "java/lang/NullPointerException" }, + { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" }, + { SWIG_JavaUnknownError, "java/lang/UnknownError" }, + { SWIG_JavaIllegalStateException, "java/lang/IllegalStateException" }, + { (SWIG_JavaExceptionCodes)0, "java/lang/UnknownError" } + }; + const SWIG_JavaExceptions_t *except_ptr = java_exceptions; + + while (except_ptr->code != code && except_ptr->code) + except_ptr++; + + jenv->ExceptionClear(); + excep = jenv->FindClass(except_ptr->java_exception); + if (excep) + jenv->ThrowNew(excep, msg); +} + + +/* Contract support */ + +#define SWIG_contract_assert(nullreturn, expr, msg) do { if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } } while (0) + + +#ifdef __cplusplus +#include +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigSmartPointer { + T *ptr; + SwigSmartPointer(T *p) : ptr(p) { } + ~SwigSmartPointer() { delete ptr; } + SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; } +#if __cplusplus >=201103L + SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; } + operator T&&() const { return std::move(*pointer.ptr); } +#else + operator T&() const { return *pointer.ptr; } +#endif + T *operator&() const { return pointer.ptr; } + static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); } +}; + +/* + * SwigValueInit() is a generic initialisation solution as the following approach: + * + * T c_result = T(); + * + * doesn't compile for all types for example: + * + * unsigned int c_result = unsigned int(); + */ +template T SwigValueInit() { + return T(); +} + +#if __cplusplus >=201103L +# define SWIG_STD_MOVE(OBJ) std::move(OBJ) +#else +# define SWIG_STD_MOVE(OBJ) OBJ +#endif + +#endif + + +#include "const.h" +#include "sxtwl.h" + + +#include // Use the C99 official header + + +#include +#include + + +#include +#include + + +#include + + +/* Check for overflow converting to Java int (always signed 32-bit) from (unsigned variable-bit) size_t */ +SWIGINTERN jint SWIG_JavaIntFromSize_t(size_t size) { + static const jint JINT_MAX = 0x7FFFFFFF; + return (size > (size_t)JINT_MAX) ? -1 : (jint)size; +} + + +SWIGINTERN jint SWIG_VectorSize(size_t size) { + jint sz = SWIG_JavaIntFromSize_t(size); + if (sz == -1) + throw std::out_of_range("vector size is too large to fit into a Java int"); + return sz; +} + +SWIGINTERN std::vector< double > *new_std_vector_Sl_double_Sg___SWIG_2(jint count,double const &value){ + if (count < 0) + throw std::out_of_range("vector count must be positive"); + return new std::vector< double >(static_cast::size_type>(count), value); + } +SWIGINTERN jint std_vector_Sl_double_Sg__doSize(std::vector< double > const *self){ + return SWIG_VectorSize(self->size()); + } +SWIGINTERN void std_vector_Sl_double_Sg__doAdd__SWIG_0(std::vector< double > *self,std::vector< double >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN void std_vector_Sl_double_Sg__doAdd__SWIG_1(std::vector< double > *self,jint index,std::vector< double >::value_type const &x){ + jint size = static_cast(self->size()); + if (0 <= index && index <= size) { + self->insert(self->begin() + index, x); + } else { + throw std::out_of_range("vector index out of range"); + } + } +SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__doRemove(std::vector< double > *self,jint index){ + jint size = static_cast(self->size()); + if (0 <= index && index < size) { + double const old_value = (*self)[index]; + self->erase(self->begin() + index); + return old_value; + } else { + throw std::out_of_range("vector index out of range"); + } + } +SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg__doGet(std::vector< double > *self,jint index){ + jint size = static_cast(self->size()); + if (index >= 0 && index < size) + return (*self)[index]; + else + throw std::out_of_range("vector index out of range"); + } +SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__doSet(std::vector< double > *self,jint index,std::vector< double >::value_type const &val){ + jint size = static_cast(self->size()); + if (index >= 0 && index < size) { + double const old_value = (*self)[index]; + (*self)[index] = val; + return old_value; + } + else + throw std::out_of_range("vector index out of range"); + } +SWIGINTERN void std_vector_Sl_double_Sg__doRemoveRange(std::vector< double > *self,jint fromIndex,jint toIndex){ + jint size = static_cast(self->size()); + if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) { + self->erase(self->begin() + fromIndex, self->begin() + toIndex); + } else { + throw std::out_of_range("vector index out of range"); + } + } +SWIGINTERN std::vector< sxtwl::JieQiInfo > *new_std_vector_Sl_sxtwl_JieQiInfo_Sg___SWIG_2(jint count,sxtwl::JieQiInfo const &value){ + if (count < 0) + throw std::out_of_range("vector count must be positive"); + return new std::vector< sxtwl::JieQiInfo >(static_cast::size_type>(count), value); + } +SWIGINTERN jint std_vector_Sl_sxtwl_JieQiInfo_Sg__doSize(std::vector< sxtwl::JieQiInfo > const *self){ + return SWIG_VectorSize(self->size()); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__doAdd__SWIG_0(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__doAdd__SWIG_1(std::vector< sxtwl::JieQiInfo > *self,jint index,std::vector< sxtwl::JieQiInfo >::value_type const &x){ + jint size = static_cast(self->size()); + if (0 <= index && index <= size) { + self->insert(self->begin() + index, x); + } else { + throw std::out_of_range("vector index out of range"); + } + } +SWIGINTERN std::vector< sxtwl::JieQiInfo >::value_type std_vector_Sl_sxtwl_JieQiInfo_Sg__doRemove(std::vector< sxtwl::JieQiInfo > *self,jint index){ + jint size = static_cast(self->size()); + if (0 <= index && index < size) { + sxtwl::JieQiInfo const old_value = (*self)[index]; + self->erase(self->begin() + index); + return old_value; + } else { + throw std::out_of_range("vector index out of range"); + } + } +SWIGINTERN std::vector< sxtwl::JieQiInfo >::value_type const &std_vector_Sl_sxtwl_JieQiInfo_Sg__doGet(std::vector< sxtwl::JieQiInfo > *self,jint index){ + jint size = static_cast(self->size()); + if (index >= 0 && index < size) + return (*self)[index]; + else + throw std::out_of_range("vector index out of range"); + } +SWIGINTERN std::vector< sxtwl::JieQiInfo >::value_type std_vector_Sl_sxtwl_JieQiInfo_Sg__doSet(std::vector< sxtwl::JieQiInfo > *self,jint index,std::vector< sxtwl::JieQiInfo >::value_type const &val){ + jint size = static_cast(self->size()); + if (index >= 0 && index < size) { + sxtwl::JieQiInfo const old_value = (*self)[index]; + (*self)[index] = val; + return old_value; + } + else + throw std::out_of_range("vector index out of range"); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__doRemoveRange(std::vector< sxtwl::JieQiInfo > *self,jint fromIndex,jint toIndex){ + jint size = static_cast(self->size()); + if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) { + self->erase(self->begin() + fromIndex, self->begin() + toIndex); + } else { + throw std::out_of_range("vector index out of range"); + } + } + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_new_1JDList_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + std::vector< double > *result = 0 ; + + (void)jenv; + (void)jcls; + result = (std::vector< double > *)new std::vector< double >(); + *(std::vector< double > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_new_1JDList_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + std::vector< double > *arg1 = 0 ; + std::vector< double > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< double > **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< double > const & is null"); + return 0; + } + result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1); + *(std::vector< double > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JDList_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< double > **)&jarg1; + result = ((std::vector< double > const *)arg1)->capacity(); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JDList_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< double > **)&jarg1; + arg2 = (std::vector< double >::size_type)jarg2; + try { + (arg1)->reserve(arg2); + } catch(std::length_error &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT jboolean JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JDList_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< double > **)&jarg1; + result = (bool)((std::vector< double > const *)arg1)->empty(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JDList_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< double > **)&jarg1; + (arg1)->clear(); +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_new_1JDList_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jdouble jarg2) { + jlong jresult = 0 ; + jint arg1 ; + double *arg2 = 0 ; + double temp2 ; + std::vector< double > *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = jarg1; + temp2 = (double)jarg2; + arg2 = &temp2; + try { + result = (std::vector< double > *)new_std_vector_Sl_double_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(double const &)*arg2); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + *(std::vector< double > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JDList_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + jint result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< double > **)&jarg1; + try { + result = std_vector_Sl_double_Sg__doSize((std::vector< double > const *)arg1); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JDList_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::value_type *arg2 = 0 ; + std::vector< double >::value_type temp2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< double > **)&jarg1; + temp2 = (std::vector< double >::value_type)jarg2; + arg2 = &temp2; + std_vector_Sl_double_Sg__doAdd__SWIG_0(arg1,(double const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JDList_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdouble jarg3) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + jint arg2 ; + std::vector< double >::value_type *arg3 = 0 ; + std::vector< double >::value_type temp3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< double > **)&jarg1; + arg2 = jarg2; + temp3 = (std::vector< double >::value_type)jarg3; + arg3 = &temp3; + try { + std_vector_Sl_double_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(double const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT jdouble JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JDList_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jdouble jresult = 0 ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + jint arg2 ; + std::vector< double >::value_type result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< double > **)&jarg1; + arg2 = jarg2; + try { + result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JDList_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jdouble jresult = 0 ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + jint arg2 ; + std::vector< double >::value_type *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< double > **)&jarg1; + arg2 = jarg2; + try { + result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__doGet(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = (jdouble)*result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JDList_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdouble jarg3) { + jdouble jresult = 0 ; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + jint arg2 ; + std::vector< double >::value_type *arg3 = 0 ; + std::vector< double >::value_type temp3 ; + std::vector< double >::value_type result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< double > **)&jarg1; + arg2 = jarg2; + temp3 = (std::vector< double >::value_type)jarg3; + arg3 = &temp3; + try { + result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(double const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JDList_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + jint arg2 ; + jint arg3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< double > **)&jarg1; + arg2 = jarg2; + arg3 = jarg3; + try { + std_vector_Sl_double_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_delete_1JDList(JNIEnv *jenv, jclass jcls, jlong jarg1) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(std::vector< double > **)&jarg1; + delete arg1; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_new_1JQList_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + (void)jenv; + (void)jcls; + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >(); + *(std::vector< sxtwl::JieQiInfo > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_new_1JQList_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + std::vector< sxtwl::JieQiInfo > *arg1 = 0 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< sxtwl::JieQiInfo > const & is null"); + return 0; + } + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >((std::vector< sxtwl::JieQiInfo > const &)*arg1); + *(std::vector< sxtwl::JieQiInfo > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JQList_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + result = ((std::vector< sxtwl::JieQiInfo > const *)arg1)->capacity(); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JQList_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + arg2 = (std::vector< sxtwl::JieQiInfo >::size_type)jarg2; + try { + (arg1)->reserve(arg2); + } catch(std::length_error &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT jboolean JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JQList_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + result = (bool)((std::vector< sxtwl::JieQiInfo > const *)arg1)->empty(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JQList_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + (arg1)->clear(); +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_new_1JQList_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) { + jlong jresult = 0 ; + jint arg1 ; + sxtwl::JieQiInfo *arg2 = 0 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg2_; + arg1 = jarg1; + arg2 = *(sxtwl::JieQiInfo **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "sxtwl::JieQiInfo const & is null"); + return 0; + } + try { + result = (std::vector< sxtwl::JieQiInfo > *)new_std_vector_Sl_sxtwl_JieQiInfo_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(sxtwl::JieQiInfo const &)*arg2); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + *(std::vector< sxtwl::JieQiInfo > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JQList_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + jint result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + try { + result = std_vector_Sl_sxtwl_JieQiInfo_Sg__doSize((std::vector< sxtwl::JieQiInfo > const *)arg1); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JQList_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + arg2 = *(std::vector< sxtwl::JieQiInfo >::value_type **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< sxtwl::JieQiInfo >::value_type const & is null"); + return ; + } + std_vector_Sl_sxtwl_JieQiInfo_Sg__doAdd__SWIG_0(arg1,(sxtwl::JieQiInfo const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JQList_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + jint arg2 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg3 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + arg2 = jarg2; + arg3 = *(std::vector< sxtwl::JieQiInfo >::value_type **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< sxtwl::JieQiInfo >::value_type const & is null"); + return ; + } + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(sxtwl::JieQiInfo const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JQList_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jlong jresult = 0 ; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + jint arg2 ; + std::vector< sxtwl::JieQiInfo >::value_type result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + arg2 = jarg2; + try { + result = std_vector_Sl_sxtwl_JieQiInfo_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + *(std::vector< sxtwl::JieQiInfo >::value_type **)&jresult = new std::vector< sxtwl::JieQiInfo >::value_type(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JQList_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jlong jresult = 0 ; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + jint arg2 ; + std::vector< sxtwl::JieQiInfo >::value_type *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + arg2 = jarg2; + try { + result = (std::vector< sxtwl::JieQiInfo >::value_type *) &std_vector_Sl_sxtwl_JieQiInfo_Sg__doGet(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + *(std::vector< sxtwl::JieQiInfo >::value_type **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JQList_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) { + jlong jresult = 0 ; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + jint arg2 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg3 = 0 ; + std::vector< sxtwl::JieQiInfo >::value_type result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + arg2 = jarg2; + arg3 = *(std::vector< sxtwl::JieQiInfo >::value_type **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< sxtwl::JieQiInfo >::value_type const & is null"); + return 0; + } + try { + result = std_vector_Sl_sxtwl_JieQiInfo_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(sxtwl::JieQiInfo const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + *(std::vector< sxtwl::JieQiInfo >::value_type **)&jresult = new std::vector< sxtwl::JieQiInfo >::value_type(result); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JQList_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + jint arg2 ; + jint arg3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + arg2 = jarg2; + arg3 = jarg3; + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_delete_1JQList(JNIEnv *jenv, jclass jcls, jlong jarg1) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(std::vector< sxtwl::JieQiInfo > **)&jarg1; + delete arg1; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_J2000_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(2451545); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_new_1Time_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + Time *result = 0 ; + + (void)jenv; + (void)jcls; + result = (Time *)new Time(); + *(Time **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_new_1Time_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jdouble jarg4, jdouble jarg5, jdouble jarg6) { + jlong jresult = 0 ; + int arg1 ; + int arg2 ; + int arg3 ; + double arg4 ; + double arg5 ; + double arg6 ; + Time *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + arg4 = (double)jarg4; + arg5 = (double)jarg5; + arg6 = (double)jarg6; + result = (Time *)new Time(arg1,arg2,arg3,arg4,arg5,arg6); + *(Time **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1Y_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->Y = arg2; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1Y_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + Time *arg1 = (Time *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + result = (int) ((arg1)->Y); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1M_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->M = arg2; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1M_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + Time *arg1 = (Time *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + result = (int) ((arg1)->M); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1D_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->D = arg2; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1D_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + Time *arg1 = (Time *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + result = (int) ((arg1)->D); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1h_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->h = arg2; +} + + +SWIGEXPORT jdouble JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1h_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + Time *arg1 = (Time *) 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + result = (double) ((arg1)->h); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1m_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->m = arg2; +} + + +SWIGEXPORT jdouble JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1m_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + Time *arg1 = (Time *) 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + result = (double) ((arg1)->m); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1s_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->s = arg2; +} + + +SWIGEXPORT jdouble JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1s_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + Time *arg1 = (Time *) 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + result = (double) ((arg1)->s); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1getYear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + Time *arg1 = (Time *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + result = (int)(arg1)->getYear(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1setYear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + arg2 = (int)jarg2; + (arg1)->setYear(arg2); +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1setMonth(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + arg2 = (int)jarg2; + (arg1)->setMonth(arg2); +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1getMonth(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + Time *arg1 = (Time *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + result = (int)(arg1)->getMonth(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1getDay(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + Time *arg1 = (Time *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + result = (int)(arg1)->getDay(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1setDay(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + arg2 = (int)jarg2; + (arg1)->setDay(arg2); +} + + +SWIGEXPORT jdouble JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1getHour(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + Time *arg1 = (Time *) 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + result = (double)(arg1)->getHour(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1setHour(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + arg2 = (double)jarg2; + (arg1)->setHour(arg2); +} + + +SWIGEXPORT jdouble JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1getMin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + Time *arg1 = (Time *) 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + result = (double)(arg1)->getMin(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1setMour(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + arg2 = (double)jarg2; + (arg1)->setMour(arg2); +} + + +SWIGEXPORT jdouble JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1getSec(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + Time *arg1 = (Time *) 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + result = (double)(arg1)->getSec(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Time_1setSec(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + arg2 = (double)jarg2; + (arg1)->setSec(arg2); +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_delete_1Time(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Time *arg1 = (Time *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Time **)&jarg1; + delete arg1; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_new_1GZ_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + GZ *result = 0 ; + + (void)jenv; + (void)jcls; + result = (GZ *)new GZ(); + *(GZ **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_new_1GZ_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jshort jarg1, jshort jarg2) { + jlong jresult = 0 ; + uint8_t arg1 ; + uint8_t arg2 ; + GZ *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (uint8_t)jarg1; + arg2 = (uint8_t)jarg2; + result = (GZ *)new GZ(arg1,arg2); + *(GZ **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_GZ_1tg_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) { + GZ *arg1 = (GZ *) 0 ; + uint8_t arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(GZ **)&jarg1; + arg2 = (uint8_t)jarg2; + if (arg1) (arg1)->tg = arg2; +} + + +SWIGEXPORT jshort JNICALL Java_com_seantone_sxtwl_sxtwlJNI_GZ_1tg_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jshort jresult = 0 ; + GZ *arg1 = (GZ *) 0 ; + uint8_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(GZ **)&jarg1; + result = (uint8_t) ((arg1)->tg); + jresult = (jshort)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_GZ_1dz_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) { + GZ *arg1 = (GZ *) 0 ; + uint8_t arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(GZ **)&jarg1; + arg2 = (uint8_t)jarg2; + if (arg1) (arg1)->dz = arg2; +} + + +SWIGEXPORT jshort JNICALL Java_com_seantone_sxtwl_sxtwlJNI_GZ_1dz_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jshort jresult = 0 ; + GZ *arg1 = (GZ *) 0 ; + uint8_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(GZ **)&jarg1; + result = (uint8_t) ((arg1)->dz); + jresult = (jshort)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_delete_1GZ(JNIEnv *jenv, jclass jcls, jlong jarg1) { + GZ *arg1 = (GZ *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(GZ **)&jarg1; + delete arg1; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1fromSolar(JNIEnv *jenv, jclass jcls, jint jarg1, jshort jarg2, jint jarg3) { + jlong jresult = 0 ; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = (int)jarg3; + result = (Day *)Day::fromSolar(arg1,arg2,arg3); + *(Day **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1fromLunar_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jint jarg1, jshort jarg2, jint jarg3, jboolean jarg4) { + jlong jresult = 0 ; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + bool arg4 ; + Day *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = (int)jarg3; + arg4 = jarg4 ? true : false; + result = (Day *)Day::fromLunar(arg1,arg2,arg3,arg4); + *(Day **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1fromLunar_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1, jshort jarg2, jint jarg3) { + jlong jresult = 0 ; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = (int)jarg3; + result = (Day *)Day::fromLunar(arg1,arg2,arg3); + *(Day **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1after(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jlong jresult = 0 ; + Day *arg1 = (Day *) 0 ; + int arg2 ; + Day *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + arg2 = (int)jarg2; + result = (Day *)(arg1)->after(arg2); + *(Day **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1before(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jlong jresult = 0 ; + Day *arg1 = (Day *) 0 ; + int arg2 ; + Day *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + arg2 = (int)jarg2; + result = (Day *)(arg1)->before(arg2); + *(Day **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getLunarDay(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + Day *arg1 = (Day *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (int)(arg1)->getLunarDay(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jshort JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getLunarMonth(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jshort jresult = 0 ; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (uint8_t)(arg1)->getLunarMonth(); + jresult = (jshort)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getLunarYear_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + jint jresult = 0 ; + Day *arg1 = (Day *) 0 ; + bool arg2 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + arg2 = jarg2 ? true : false; + result = (int)(arg1)->getLunarYear(arg2); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getLunarYear_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + Day *arg1 = (Day *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (int)(arg1)->getLunarYear(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getYearGZ_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + jlong jresult = 0 ; + Day *arg1 = (Day *) 0 ; + bool arg2 ; + GZ result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + arg2 = jarg2 ? true : false; + result = (arg1)->getYearGZ(arg2); + *(GZ **)&jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getYearGZ_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + Day *arg1 = (Day *) 0 ; + GZ result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (arg1)->getYearGZ(); + *(GZ **)&jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getMonthGZ(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + Day *arg1 = (Day *) 0 ; + GZ result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (arg1)->getMonthGZ(); + *(GZ **)&jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getDayGZ(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + Day *arg1 = (Day *) 0 ; + GZ result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (arg1)->getDayGZ(); + *(GZ **)&jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getHourGZ_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2, jboolean jarg3) { + jlong jresult = 0 ; + Day *arg1 = (Day *) 0 ; + uint8_t arg2 ; + bool arg3 ; + GZ result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + arg2 = (uint8_t)jarg2; + arg3 = jarg3 ? true : false; + result = (arg1)->getHourGZ(arg2,arg3); + *(GZ **)&jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getHourGZ_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) { + jlong jresult = 0 ; + Day *arg1 = (Day *) 0 ; + uint8_t arg2 ; + GZ result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + arg2 = (uint8_t)jarg2; + result = (arg1)->getHourGZ(arg2); + *(GZ **)&jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1isLunarLeap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + Day *arg1 = (Day *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (bool)(arg1)->isLunarLeap(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getSolarYear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + Day *arg1 = (Day *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (int)(arg1)->getSolarYear(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jshort JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getSolarMonth(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jshort jresult = 0 ; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (uint8_t)(arg1)->getSolarMonth(); + jresult = (jshort)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getSolarDay(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + Day *arg1 = (Day *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (int)(arg1)->getSolarDay(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jshort JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getWeek(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jshort jresult = 0 ; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (uint8_t)(arg1)->getWeek(); + jresult = (jshort)result; + return jresult; +} + + +SWIGEXPORT jshort JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getWeekIndex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jshort jresult = 0 ; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (uint8_t)(arg1)->getWeekIndex(); + jresult = (jshort)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1hasJieQi(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + Day *arg1 = (Day *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (bool)(arg1)->hasJieQi(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jshort JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getJieQi(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jshort jresult = 0 ; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (uint8_t)(arg1)->getJieQi(); + jresult = (jshort)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getJieQiJD(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + Day *arg1 = (Day *) 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (double)(arg1)->getJieQiJD(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jshort JNICALL Java_com_seantone_sxtwl_sxtwlJNI_Day_1getConstellation(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jshort jresult = 0 ; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Day **)&jarg1; + result = (uint8_t)(arg1)->getConstellation(); + jresult = (jshort)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_delete_1Day(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Day *arg1 = (Day *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Day **)&jarg1; + delete arg1; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JieQiInfo_1jd_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + double arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(sxtwl::JieQiInfo **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->jd = arg2; +} + + +SWIGEXPORT jdouble JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JieQiInfo_1jd_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(sxtwl::JieQiInfo **)&jarg1; + result = (double) ((arg1)->jd); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JieQiInfo_1jqIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + uint8_t arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(sxtwl::JieQiInfo **)&jarg1; + arg2 = (uint8_t)jarg2; + if (arg1) (arg1)->jqIndex = arg2; +} + + +SWIGEXPORT jshort JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JieQiInfo_1jqIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jshort jresult = 0 ; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + uint8_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(sxtwl::JieQiInfo **)&jarg1; + result = (uint8_t) ((arg1)->jqIndex); + jresult = (jshort)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_new_1JieQiInfo(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + sxtwl::JieQiInfo *result = 0 ; + + (void)jenv; + (void)jcls; + result = (sxtwl::JieQiInfo *)new sxtwl::JieQiInfo(); + *(sxtwl::JieQiInfo **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_seantone_sxtwl_sxtwlJNI_delete_1JieQiInfo(JNIEnv *jenv, jclass jcls, jlong jarg1) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(sxtwl::JieQiInfo **)&jarg1; + delete arg1; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_fromSolar(JNIEnv *jenv, jclass jcls, jint jarg1, jshort jarg2, jint jarg3) { + jlong jresult = 0 ; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = (int)jarg3; + result = (Day *)sxtwl::fromSolar(arg1,arg2,arg3); + *(Day **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_fromLunar_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jint jarg1, jshort jarg2, jint jarg3, jboolean jarg4) { + jlong jresult = 0 ; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + bool arg4 ; + Day *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = (int)jarg3; + arg4 = jarg4 ? true : false; + result = (Day *)sxtwl::fromLunar(arg1,arg2,arg3,arg4); + *(Day **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_fromLunar_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1, jshort jarg2, jint jarg3) { + jlong jresult = 0 ; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = (int)jarg3; + result = (Day *)sxtwl::fromLunar(arg1,arg2,arg3); + *(Day **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_siZhu2Year(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jint jarg5, jint jarg6) { + jlong jresult = 0 ; + GZ arg1 ; + GZ arg2 ; + GZ arg3 ; + GZ arg4 ; + int arg5 ; + int arg6 ; + GZ *argp1 ; + GZ *argp2 ; + GZ *argp3 ; + GZ *argp4 ; + std::vector< double > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + (void)jarg3_; + (void)jarg4_; + argp1 = *(GZ **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null GZ"); + return 0; + } + arg1 = *argp1; + argp2 = *(GZ **)&jarg2; + if (!argp2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null GZ"); + return 0; + } + arg2 = *argp2; + argp3 = *(GZ **)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null GZ"); + return 0; + } + arg3 = *argp3; + argp4 = *(GZ **)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null GZ"); + return 0; + } + arg4 = *argp4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + result = sxtwl::siZhu2Year(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,arg6); + *(std::vector< double > **)&jresult = new std::vector< double >(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_getShiGz_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jshort jarg1, jshort jarg2, jboolean jarg3) { + jlong jresult = 0 ; + uint8_t arg1 ; + uint8_t arg2 ; + bool arg3 ; + GZ result; + + (void)jenv; + (void)jcls; + arg1 = (uint8_t)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = jarg3 ? true : false; + result = sxtwl::getShiGz(arg1,arg2,arg3); + *(GZ **)&jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_getShiGz_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jshort jarg1, jshort jarg2) { + jlong jresult = 0 ; + uint8_t arg1 ; + uint8_t arg2 ; + GZ result; + + (void)jenv; + (void)jcls; + arg1 = (uint8_t)jarg1; + arg2 = (uint8_t)jarg2; + result = sxtwl::getShiGz(arg1,arg2); + *(GZ **)&jresult = new GZ(result); + return jresult; +} + + +SWIGEXPORT jshort JNICALL Java_com_seantone_sxtwl_sxtwlJNI_getRunMonth(JNIEnv *jenv, jclass jcls, jint jarg1) { + jshort jresult = 0 ; + int arg1 ; + uint8_t result; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (uint8_t)sxtwl::getRunMonth(arg1); + jresult = (jshort)result; + return jresult; +} + + +SWIGEXPORT jshort JNICALL Java_com_seantone_sxtwl_sxtwlJNI_getLunarMonthNum_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jint jarg1, jshort jarg2, jboolean jarg3) { + jshort jresult = 0 ; + int arg1 ; + uint8_t arg2 ; + bool arg3 ; + uint8_t result; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + arg3 = jarg3 ? true : false; + result = (uint8_t)sxtwl::getLunarMonthNum(arg1,arg2,arg3); + jresult = (jshort)result; + return jresult; +} + + +SWIGEXPORT jshort JNICALL Java_com_seantone_sxtwl_sxtwlJNI_getLunarMonthNum_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1, jshort jarg2) { + jshort jresult = 0 ; + int arg1 ; + uint8_t arg2 ; + uint8_t result; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + arg2 = (uint8_t)jarg2; + result = (uint8_t)sxtwl::getLunarMonthNum(arg1,arg2); + jresult = (jshort)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_JD2DD(JNIEnv *jenv, jclass jcls, jdouble jarg1) { + jlong jresult = 0 ; + double arg1 ; + Time result; + + (void)jenv; + (void)jcls; + arg1 = (double)jarg1; + result = sxtwl::JD2DD(arg1); + *(Time **)&jresult = new Time(result); + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_com_seantone_sxtwl_sxtwlJNI_toJD(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + Time *arg1 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(Time **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Time & is null"); + return 0; + } + result = (double)sxtwl::toJD(*arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_seantone_sxtwl_sxtwlJNI_getJieQiByYear(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + std::vector< sxtwl::JieQiInfo > result; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = sxtwl::getJieQiByYear(arg1); + *(std::vector< sxtwl::JieQiInfo > **)&jresult = new std::vector< sxtwl::JieQiInfo >(result); + return jresult; +} + + +#ifdef __cplusplus +} +#endif + diff --git a/export/lua/sxtwl_wrap.cxx b/export/lua/sxtwl_wrap.cxx new file mode 100644 index 0000000..f8de5e0 --- /dev/null +++ b/export/lua/sxtwl_wrap.cxx @@ -0,0 +1,7122 @@ +/* ---------------------------------------------------------------------------- + * 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 SWIGLUA +#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA +#define SWIG_LUA_MODULE_GLOBAL + +/* ----------------------------------------------------------------------------- + * 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 + +/* ----------------------------------------------------------------------------- + * 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 + + +/* ----------------------------------------------------------------------------- + * luarun.swg + * + * This file contains the runtime support for Lua modules + * and includes code for managing global variables and pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "lua.h" +#include "lauxlib.h" +#include /* for malloc */ +#include /* for a few sanity tests */ + +/* ----------------------------------------------------------------------------- + * Lua flavors + * ----------------------------------------------------------------------------- */ + +#define SWIG_LUA_FLAVOR_LUA 1 +#define SWIG_LUA_FLAVOR_ELUA 2 +#define SWIG_LUA_FLAVOR_ELUAC 3 + +#if !defined(SWIG_LUA_TARGET) +# error SWIG_LUA_TARGET not defined +#endif + +#if defined(SWIG_LUA_ELUA_EMULATE) + +struct swig_elua_entry; + +typedef struct swig_elua_key { + int type; + union { + const char* strkey; + lua_Number numkey; + } key; +} swig_elua_key; + +typedef struct swig_elua_val { + int type; + union { + lua_Number number; + const struct swig_elua_entry *table; + const char *string; + lua_CFunction function; + struct { + char member; + long lvalue; + void *pvalue; + swig_type_info **ptype; + } userdata; + } value; +} swig_elua_val; + +typedef struct swig_elua_entry { + swig_elua_key key; + swig_elua_val value; +} swig_elua_entry; + +#define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} } +#define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} } +#define LNILKEY {LUA_TNIL, {.strkey = 0} } + +#define LNUMVAL(x) {LUA_TNUMBER, {.number = x} } +#define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} } +#define LROVAL(x) {LUA_TTABLE, {.table = x} } +#define LNILVAL {LUA_TNIL, {.string = 0} } +#define LSTRVAL(x) {LUA_TSTRING, {.string = x} } + +#define LUA_REG_TYPE swig_elua_entry + +#define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable" + +#define lua_pushrotable(L,p)\ + lua_newtable(L);\ + assert(p);\ + SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p)); + +#define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\ + LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } } + +#define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\ + LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } } +#endif + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) +# define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C) +# define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C) +# define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C) +# define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C) + /* Those two types of constants are not supported in elua */ + +#ifndef SWIG_LUA_CONSTTAB_POINTER +#warning eLua does not support pointers as constants. By default, nil will be used as value +#define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL +#endif + +#ifndef SWIG_LUA_CONSTTAB_BINARY +#warning eLua does not support pointers to member as constants. By default, nil will be used as value +#define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL +#endif +#else /* SWIG_LUA_FLAVOR_LUA */ +# define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0 +# define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0 +# define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0 +# define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0 +# define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\ + SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D +# define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\ + SWIG_LUA_BINARY, (char *)B, S, 0, (void *)C, &D +#endif + +#ifndef SWIG_LUA_ELUA_EMULATE +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) +# define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING} +# define LSTRVAL LRO_STRVAL +#endif +#endif /* SWIG_LUA_ELUA_EMULATE*/ + +#ifndef SWIG_LUA_ELUA_EMULATE +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) + +#ifndef MIN_OPT_LEVEL +#define MIN_OPT_LEVEL 2 +#endif + +#include "lrodefs.h" +#include "lrotable.h" +#endif +#endif /* SWIG_LUA_ELUA_EMULATE*/ +/* ----------------------------------------------------------------------------- + * compatibility defines + * ----------------------------------------------------------------------------- */ + +/* History of Lua C API length functions: In Lua 5.0 (and before?) + there was "lua_strlen". In Lua 5.1, this was renamed "lua_objlen", + but a compatibility define of "lua_strlen" was added. In Lua 5.2, + this function was again renamed, to "lua_rawlen" (to emphasize that + it doesn't call the "__len" metamethod), and the compatibility + define of lua_strlen was removed. All SWIG uses have been updated + to "lua_rawlen", and we add our own defines of that here for older + versions of Lua. */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 +# define lua_rawlen lua_strlen +#elif LUA_VERSION_NUM == 501 +# define lua_rawlen lua_objlen +#endif + + +/* lua_pushglobaltable is the recommended "future-proof" way to get + the global table for Lua 5.2 and later. Here we define + lua_pushglobaltable ourselves for Lua versions before 5.2. */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 +# define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX) +#endif + +/* lua_absindex was introduced in Lua 5.2 */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 +# define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1) +#endif + +/* lua_rawsetp was introduced in Lua 5.2 */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 +#define lua_rawsetp(L,index,ptr)\ + lua_pushlightuserdata(L,(void*)(ptr));\ + lua_insert(L,-2);\ + lua_rawset(L,index); + +#define lua_rawgetp(L,index,ptr)\ + lua_pushlightuserdata(L,(void*)(ptr));\ + lua_rawget(L,index); + +#endif + +/* -------------------------------------------------------------------------- + * Helper functions for error handling + * -------------------------------------------------------------------------- */ + +/* Push the string STR on the Lua stack, like lua_pushstring, but + prefixed with the location of the innermost Lua call-point + (as formatted by luaL_where). */ +SWIGRUNTIME void +SWIG_Lua_pusherrstring (lua_State *L, const char *str) +{ + luaL_where (L, 1); + lua_pushstring (L, str); + lua_concat (L, 2); +} + +/* Push a formatted string generated from FMT and following args on + the Lua stack, like lua_pushfstring, but prefixed with the + location of the innermost Lua call-point (as formatted by luaL_where). */ +SWIGRUNTIME void +SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...) +{ + va_list argp; + va_start(argp, fmt); + luaL_where(L, 1); + lua_pushvfstring(L, fmt, argp); + va_end(argp); + lua_concat(L, 2); +} + + +/* ----------------------------------------------------------------------------- + * global swig types + * ----------------------------------------------------------------------------- */ +/* Constant table */ +#define SWIG_LUA_INT 1 +#define SWIG_LUA_FLOAT 2 +#define SWIG_LUA_STRING 3 +#define SWIG_LUA_POINTER 4 +#define SWIG_LUA_BINARY 5 +#define SWIG_LUA_CHAR 6 + +/* Structure for variable linking table */ +typedef struct { + const char *name; + lua_CFunction get; + lua_CFunction set; +} swig_lua_var_info; + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) +typedef const LUA_REG_TYPE swig_lua_method; +typedef const LUA_REG_TYPE swig_lua_const_info; +#else /* Normal lua */ +typedef luaL_Reg swig_lua_method; + +/* Constant information structure */ +typedef struct { + int type; + char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_lua_const_info; + +#endif + +typedef struct { + const char *name; + lua_CFunction getmethod; + lua_CFunction setmethod; +} swig_lua_attribute; + + +struct swig_lua_class; +/* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */ +typedef struct swig_lua_namespace { + const char *name; + swig_lua_method *ns_methods; + swig_lua_attribute *ns_attributes; + swig_lua_const_info *ns_constants; + struct swig_lua_class **ns_classes; + struct swig_lua_namespace **ns_namespaces; +} swig_lua_namespace; + +typedef struct swig_lua_class { + const char *name; /* Name that this class has in Lua */ + const char *fqname; /* Fully qualified name - Scope + class name */ + swig_type_info **type; + lua_CFunction constructor; + void (*destructor)(void *); + swig_lua_method *methods; + swig_lua_attribute *attributes; + swig_lua_namespace *cls_static; + swig_lua_method *metatable; /* 0 for -eluac */ + struct swig_lua_class **bases; + const char **base_names; +} swig_lua_class; + +/* this is the struct for wrapping all pointers in SwigLua +*/ +typedef struct { + swig_type_info *type; + int own; /* 1 if owned & must be destroyed */ + void *ptr; +} swig_lua_userdata; + +/* this is the struct for wrapping arbitrary packed binary data +(currently it is only used for member function pointers) +the data ordering is similar to swig_lua_userdata, but it is currently not possible +to tell the two structures apart within SWIG, other than by looking at the type +*/ +typedef struct { + swig_type_info *type; + int own; /* 1 if owned & must be destroyed */ + char data[1]; /* arbitrary amount of data */ +} swig_lua_rawdata; + +/* Common SWIG API */ +#define SWIG_NewPointerObj(L, ptr, type, owner) SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner) +#define SWIG_ConvertPtr(L,idx, ptr, type, flags) SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags) +#define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname) SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname) +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(L, idx, ptr, sz, ty) SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty) +#define SWIG_NewMemberObj(L, ptr, sz, type) SWIG_Lua_NewPackedObj(L, ptr, sz, type) + +/* Runtime API */ +#define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata)) +#define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer) +#define SWIG_MODULE_CLIENTDATA_TYPE lua_State* + +/* Contract support */ +#define SWIG_contract_assert(expr, msg) \ + do { if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } } while (0) + + +/* helper #defines */ +#define SWIG_fail {goto fail;} +#define SWIG_fail_arg(func_name,argnum,type) \ + {SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\ + func_name,argnum,type,SWIG_Lua_typename(L,argnum));\ + goto fail;} +#define SWIG_fail_ptr(func_name,argnum,type) \ + SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*") +#define SWIG_check_num_args(func_name,a,b) \ + if (lua_gettop(L)b) \ + {SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\ + goto fail;} + + +#define SWIG_Lua_get_table(L,n) \ + (lua_pushstring(L, n), lua_rawget(L,-2)) + +#define SWIG_Lua_add_function(L,n,f) \ + (lua_pushstring(L, n), \ + lua_pushcfunction(L, f), \ + lua_rawset(L,-3)) + +#define SWIG_Lua_add_boolean(L,n,b) \ + (lua_pushstring(L, n), \ + lua_pushboolean(L, b), \ + lua_rawset(L,-3)) + +/* special helper for allowing 'nil' for usertypes */ +#define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I)) + +#ifdef __cplusplus +/* Special helper for member function pointers +it gets the address, casts it, then dereferences it */ +/*#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a))) */ +#endif + +/* storing/access of swig_module_info */ +SWIGRUNTIME swig_module_info * +SWIG_Lua_GetModule(lua_State *L) { + swig_module_info *ret = 0; + lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); + lua_rawget(L,LUA_REGISTRYINDEX); + if (lua_islightuserdata(L,-1)) + ret=(swig_module_info*)lua_touserdata(L,-1); + lua_pop(L,1); /* tidy */ + return ret; +} + +SWIGRUNTIME void +SWIG_Lua_SetModule(lua_State *L, swig_module_info *module) { + /* add this all into the Lua registry: */ + lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); + lua_pushlightuserdata(L,(void*)module); + lua_rawset(L,LUA_REGISTRYINDEX); +} + +/* ----------------------------------------------------------------------------- + * global variable support code: modules + * ----------------------------------------------------------------------------- */ + +/* this function is called when trying to set an immutable. +default action is to print an error. +This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */ +SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L) +{ +/* there should be 1 param passed in: the new value */ +#ifndef SWIGLUA_IGNORE_SET_IMMUTABLE + lua_pop(L,1); /* remove it */ + luaL_error(L,"This variable is immutable"); +#endif + return 0; /* should not return anything */ +} + +#ifdef SWIG_LUA_ELUA_EMULATE + +SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own); +SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type); +static int swig_lua_elua_emulate_unique_key; + +/* This function emulates eLua rotables behaviour. It loads a rotable definition into the usual lua table. */ +SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table) +{ + int i, table_parsed, parsed_tables_array, target_table; + assert(lua_istable(L,-1)); + target_table = lua_gettop(L); + /* Get the registry where we put all parsed tables to avoid loops */ + lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key); + if(lua_isnil(L,-1)) { + lua_pop(L,1); + lua_newtable(L); + lua_pushvalue(L,-1); + lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key)); + } + parsed_tables_array = lua_gettop(L); + lua_pushvalue(L,target_table); + lua_rawsetp(L, parsed_tables_array, table); + table_parsed = 0; + const int SWIGUNUSED pairs_start = lua_gettop(L); + for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++) + { + const swig_elua_entry *entry = table + i; + int is_metatable = 0; + switch(entry->key.type) { + case LUA_TSTRING: + lua_pushstring(L,entry->key.key.strkey); + if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0) + is_metatable = 1; + break; + case LUA_TNUMBER: + lua_pushnumber(L,entry->key.key.numkey); + break; + case LUA_TNIL: + lua_pushnil(L); + break; + default: + assert(0); + } + switch(entry->value.type) { + case LUA_TSTRING: + lua_pushstring(L,entry->value.value.string); + break; + case LUA_TNUMBER: + lua_pushnumber(L,entry->value.value.number); + break; + case LUA_TFUNCTION: + lua_pushcfunction(L,entry->value.value.function); + break; + case LUA_TTABLE: + lua_rawgetp(L,parsed_tables_array, entry->value.value.table); + table_parsed = !lua_isnil(L,-1); + if(!table_parsed) { + lua_pop(L,1); /*remove nil */ + lua_newtable(L); + SWIG_Lua_elua_emulate_register(L,entry->value.value.table); + } + if(is_metatable) { + assert(lua_istable(L,-1)); + lua_pushvalue(L,-1); + lua_setmetatable(L,target_table); + } + + break; + case LUA_TUSERDATA: + if(entry->value.value.userdata.member) + SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue, + entry->value.value.userdata.lvalue, + *(entry->value.value.userdata.ptype)); + else + SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue, + *(entry->value.value.userdata.ptype),0); + break; + case LUA_TNIL: + lua_pushnil(L); + break; + default: + assert(0); + } + assert(lua_gettop(L) == pairs_start + 2); + lua_rawset(L,target_table); + } + lua_pop(L,1); /* Removing parsed tables storage */ + assert(lua_gettop(L) == target_table); +} + +SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L) +{ + lua_pushnil(L); + lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key); +} + +SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L); + +SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L) +{ + SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1); + SWIG_Lua_get_class_registry(L); + lua_getfield(L,-1,"lua_getmetatable"); + lua_remove(L,-2); /* remove the registry*/ + assert(!lua_isnil(L,-1)); + lua_pushvalue(L,1); + assert(lua_gettop(L) == 3); /* object | function | object again */ + lua_call(L,1,1); + if(!lua_isnil(L,-1)) /*There is an ordinary metatable */ + return 1; + /*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/ + assert(lua_gettop(L) == 2); + if(lua_istable(L,-2)) { + lua_pop(L,1); /*remove the nil*/ + lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY); + } + assert(lua_gettop(L) == 2); + return 1; + +fail: + lua_error(L); + return 0; +} + +SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L) +{ + SWIG_Lua_get_class_registry(L); + lua_pushglobaltable(L); + lua_pushstring(L,"lua_getmetatable"); + lua_getfield(L,-2,"getmetatable"); + assert(!lua_isnil(L,-1)); + lua_rawset(L,-4); + lua_pushstring(L, "getmetatable"); + lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable); + lua_rawset(L,-3); + lua_pop(L,2); + +} +/* END OF REMOVE */ + +#endif +/* ----------------------------------------------------------------------------- + * global variable support code: namespaces and modules (which are the same thing) + * ----------------------------------------------------------------------------- */ + +SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L) +{ +/* there should be 2 params passed in + (1) table (not the meta table) + (2) string name of the attribute +*/ + assert(lua_istable(L,-2)); /* just in case */ + lua_getmetatable(L,-2); + assert(lua_istable(L,-1)); + SWIG_Lua_get_table(L,".get"); /* find the .get table */ + assert(lua_istable(L,-1)); + /* look for the key in the .get table */ + lua_pushvalue(L,2); /* key */ + lua_rawget(L,-2); + lua_remove(L,-2); /* stack tidy, remove .get table */ + if (lua_iscfunction(L,-1)) + { /* found it so call the fn & return its value */ + lua_call(L,0,1); /* 1 value in (userdata),1 out (result) */ + lua_remove(L,-2); /* stack tidy, remove metatable */ + return 1; + } + lua_pop(L,1); /* remove whatever was there */ + /* ok, so try the .fn table */ + SWIG_Lua_get_table(L,".fn"); /* find the .get table */ + assert(lua_istable(L,-1)); /* just in case */ + lua_pushvalue(L,2); /* key */ + lua_rawget(L,-2); /* look for the fn */ + lua_remove(L,-2); /* stack tidy, remove .fn table */ + if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */ + { /* found it so return the fn & let lua call it */ + lua_remove(L,-2); /* stack tidy, remove metatable */ + return 1; + } + lua_pop(L,1); /* remove whatever was there */ + return 0; +} + +SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L) +{ +/* there should be 3 params passed in + (1) table (not the meta table) + (2) string name of the attribute + (3) any for the new value +*/ + + assert(lua_istable(L,1)); + lua_getmetatable(L,1); /* get the meta table */ + assert(lua_istable(L,-1)); + + SWIG_Lua_get_table(L,".set"); /* find the .set table */ + if (lua_istable(L,-1)) + { + /* look for the key in the .set table */ + lua_pushvalue(L,2); /* key */ + lua_rawget(L,-2); + if (lua_iscfunction(L,-1)) + { /* found it so call the fn & return its value */ + lua_pushvalue(L,3); /* value */ + lua_call(L,1,0); + return 0; + } + lua_pop(L,1); /* remove the value */ + } + lua_pop(L,1); /* remove the value .set table */ + lua_pop(L,1); /* remote metatable */ + lua_rawset(L,-3); + return 0; +} + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */ +SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */ +SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */ +SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss); + +/* helper function - register namespace methods and attributes into namespace */ +SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns) +{ + int i; + /* There must be namespace table (not metatable) at the top of the stack */ + assert(lua_istable(L,-1)); + SWIG_Lua_InstallConstants(L, ns->ns_constants); + + /* add methods to the namespace/module table */ + for(i=0;ns->ns_methods[i].name;i++){ + SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func); + } + lua_getmetatable(L,-1); + + /* add fns */ + for(i=0;ns->ns_attributes[i].name;i++){ + SWIG_Lua_add_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod); + } + + /* clear stack - remove metatble */ + lua_pop(L,1); + return 0; +} + +/* Register all classes in the namespace */ +SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns) +{ + swig_lua_class **classes; + + /* There must be a module/namespace table at the top of the stack */ + assert(lua_istable(L,-1)); + + classes = ns->ns_classes; + + if( classes != 0 ) { + while(*classes != 0) { + SWIG_Lua_class_register(L, *classes); + classes++; + } + } +} + +/* Helper function. Creates namespace table and adds it to module table + if 'reg' is true, then will register namespace table to parent one (must be on top of the stack + when function is called). + Function always returns newly registered table on top of the stack. +*/ +SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg) +{ + swig_lua_namespace **sub_namespace; + /* 1 argument - table on the top of the stack */ + const int SWIGUNUSED begin = lua_gettop(L); + assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */ + lua_checkstack(L,5); + lua_newtable(L); /* namespace itself */ + lua_newtable(L); /* metatable for namespace */ + + /* add a table called ".get" */ + lua_pushstring(L,".get"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".set" */ + lua_pushstring(L,".set"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".fn" */ + lua_pushstring(L,".fn"); + lua_newtable(L); + lua_rawset(L,-3); + + /* add accessor fns for using the .get,.set&.fn */ + SWIG_Lua_add_function(L,"__index",SWIG_Lua_namespace_get); + SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set); + + lua_setmetatable(L,-2); /* set metatable */ + + /* Register all functions, variables etc */ + SWIG_Lua_add_namespace_details(L,ns); + /* Register classes */ + SWIG_Lua_add_namespace_classes(L,ns); + + sub_namespace = ns->ns_namespaces; + if( sub_namespace != 0) { + while(*sub_namespace != 0) { + SWIG_Lua_namespace_register(L, *sub_namespace, 1); + lua_pop(L,1); /* removing sub-namespace table */ + sub_namespace++; + } + } + + if (reg) { + lua_pushstring(L,ns->name); + lua_pushvalue(L,-2); + lua_rawset(L,-4); /* add namespace to module table */ + } + assert(lua_gettop(L) == begin+1); +} +#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */ + +/* ----------------------------------------------------------------------------- + * global variable support code: classes + * ----------------------------------------------------------------------------- */ + +SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname); + +typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret); + +SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info * SWIGUNUSED swig_type, + int first_arg, swig_lua_base_iterator_func func, int *const ret) +{ + /* first_arg - position of the object in stack. Everything that is above are arguments + * and is passed to every evocation of the func */ + int last_arg = lua_gettop(L);/* position of last argument */ + int original_metatable = last_arg + 1; + size_t bases_count; + int result = SWIG_ERROR; + int bases_table; + (void)swig_type; + lua_getmetatable(L,first_arg); + + /* initialise base search */ +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + SWIG_Lua_get_table(L,".bases"); + assert(lua_istable(L,-1)); + bases_count = lua_rawlen(L,-1); + bases_table = lua_gettop(L); +#else + /* In elua .bases table doesn't exist. Use table from swig_lua_class */ + (void)bases_table; + assert(swig_type!=0); + swig_module_info *module=SWIG_GetModule(L); + swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases; + const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names; + bases_count = 0; + for(;base_names[bases_count]; + bases_count++);/* get length of bases */ +#endif + + if(ret) + *ret = 0; + if(bases_count>0) + { + int to_remove; + size_t i; + int j; + int subcall_last_arg; + int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */ + int valid = 1; + swig_type_info *base_swig_type = 0; + for(j=first_arg;j<=last_arg;j++) + lua_pushvalue(L,j); + subcall_last_arg = lua_gettop(L); + + /* Trick: temporarily replacing original metatable with metatable for base class and call getter */ + for(i=0;ifqname); + base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]); + assert(base_swig_type != 0); + } +#endif + + if(!valid) + continue; + assert(lua_isuserdata(L, subcall_first_arg)); + assert(lua_istable(L,-1)); + lua_setmetatable(L,subcall_first_arg); /* Set new metatable */ + assert(lua_gettop(L) == subcall_last_arg); + result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */ + if(result != SWIG_ERROR) { + break; + } + } + /* Restore original metatable */ + lua_pushvalue(L,original_metatable); + lua_setmetatable(L,first_arg); + /* Clear - remove everything between last_arg and subcall_last_arg including */ + to_remove = subcall_last_arg - last_arg; + for(j=0;jtype; + result = SWIG_Lua_class_do_get(L,type,1,&ret); + if(result == SWIG_OK) + return ret; + + result = SWIG_Lua_class_do_get_item(L,type,1,&ret); + if(result == SWIG_OK) + return ret; + + return 0; +} + +/* helper for the class.set method, performs the lookup of class attributes + * It returns error code. Number of function return values is passed inside 'ret' + */ +SWIGINTERN int SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret) +{ +/* there should be 3 params passed in + (1) table (not the meta table) + (2) string name of the attribute + (3) any for the new value + */ + + int bases_search_result; + int substack_start = lua_gettop(L) - 3; + lua_checkstack(L,5); + assert(lua_isuserdata(L,substack_start+1)); /* just in case */ + lua_getmetatable(L,substack_start+1); /* get the meta table */ + assert(lua_istable(L,-1)); /* just in case */ + if(ret) + *ret = 0; /* it is setter - number of return values is always 0 */ + + SWIG_Lua_get_table(L,".set"); /* find the .set table */ + if (lua_istable(L,-1)) + { + /* look for the key in the .set table */ + lua_pushvalue(L,substack_start+2); /* key */ + lua_rawget(L,-2); + lua_remove(L,-2); /* tidy stack, remove .set table */ + if (lua_iscfunction(L,-1)) + { /* found it so call the fn & return its value */ + lua_pushvalue(L,substack_start+1); /* userdata */ + lua_pushvalue(L,substack_start+3); /* value */ + lua_call(L,2,0); + lua_remove(L,substack_start+4); /*remove metatable*/ + return SWIG_OK; + } + lua_pop(L,1); /* remove the value */ + } else { + lua_pop(L,1); /* remove the answer for .set table request*/ + } + /* NEW: looks for the __setitem() fn + this is a user provided set fn */ + SWIG_Lua_get_table(L,"__setitem"); /* find the fn */ + if (lua_iscfunction(L,-1)) /* if it's there */ + { /* found it so call the fn & return its value */ + lua_pushvalue(L,substack_start+1); /* the userdata */ + lua_pushvalue(L,substack_start+2); /* the parameter */ + lua_pushvalue(L,substack_start+3); /* the value */ + lua_call(L,3,0); /* 3 values in ,0 out */ + lua_remove(L,-2); /* stack tidy, remove metatable */ + return SWIG_OK; + } + lua_pop(L,1); /* remove value */ + + lua_pop(L,1); /* remove metatable */ + /* Search among bases */ + bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret); + if(ret) + assert(*ret == 0); + assert(lua_gettop(L) == substack_start + 3); + return bases_search_result; +} + +/* This is the actual method exported to Lua. It calls SWIG_Lua_class_do_set and correctly + * handles return values. + */ +SWIGINTERN int SWIG_Lua_class_set(lua_State *L) +{ +/* There should be 3 params passed in + (1) table (not the meta table) + (2) string name of the attribute + (3) any for the new value + */ + int ret = 0; + int result; + swig_lua_userdata *usr; + swig_type_info *type; + assert(lua_isuserdata(L,1)); + usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ + type = usr->type; + result = SWIG_Lua_class_do_set(L,type,1,&ret); + if(result != SWIG_OK) { + SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method."); + lua_error(L); + } else { + assert(ret==0); + } + return 0; +} + +/* the class.destruct method called by the interpreter */ +SWIGINTERN int SWIG_Lua_class_destruct(lua_State *L) +{ +/* there should be 1 params passed in + (1) userdata (not the meta table) */ + swig_lua_userdata *usr; + swig_lua_class *clss; + assert(lua_isuserdata(L,-1)); /* just in case */ + usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ + /* if must be destroyed & has a destructor */ + if (usr->own) /* if must be destroyed */ + { + clss=(swig_lua_class*)usr->type->clientdata; /* get the class */ + if (clss && clss->destructor) /* there is a destroy fn */ + { + clss->destructor(usr->ptr); /* bye bye */ + } + } + return 0; +} + +/* the class.__tostring method called by the interpreter and print */ +SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L) +{ +/* there should be 1 param passed in + (1) userdata (not the metatable) */ + swig_lua_userdata* userData; + assert(lua_isuserdata(L,1)); /* just in case */ + userData = (swig_lua_userdata*)lua_touserdata(L,1); /* get the userdata address */ + + lua_pushfstring(L, "", userData->type->str, userData->ptr); + return 1; +} + +/* to manually disown some userdata */ +SWIGINTERN int SWIG_Lua_class_disown(lua_State *L) +{ +/* there should be 1 params passed in + (1) userdata (not the meta table) */ + swig_lua_userdata *usr; + assert(lua_isuserdata(L,-1)); /* just in case */ + usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ + + usr->own = 0; /* clear our ownership */ + return 0; +} + +/* lua callable function to compare userdata's value +the issue is that two userdata may point to the same thing +but to lua, they are different objects */ +SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L) +{ + int result; + swig_lua_userdata *usr1,*usr2; + if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2)) /* just in case */ + return 0; /* nil reply */ + usr1=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ + usr2=(swig_lua_userdata*)lua_touserdata(L,2); /* get data */ + /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/ + result=(usr1->ptr==usr2->ptr); + lua_pushboolean(L,result); + return 1; +} + +/* populate table at the top of the stack with metamethods that ought to be inherited */ +SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L) +{ + SWIG_Lua_add_boolean(L, "__add", 1); + SWIG_Lua_add_boolean(L, "__sub", 1); + SWIG_Lua_add_boolean(L, "__mul", 1); + SWIG_Lua_add_boolean(L, "__div", 1); + SWIG_Lua_add_boolean(L, "__mod", 1); + SWIG_Lua_add_boolean(L, "__pow", 1); + SWIG_Lua_add_boolean(L, "__unm", 1); + SWIG_Lua_add_boolean(L, "__len", 1 ); + SWIG_Lua_add_boolean(L, "__concat", 1 ); + SWIG_Lua_add_boolean(L, "__eq", 1); + SWIG_Lua_add_boolean(L, "__lt", 1); + SWIG_Lua_add_boolean(L, "__le", 1); + SWIG_Lua_add_boolean(L, "__call", 1); + SWIG_Lua_add_boolean(L, "__tostring", 1); + SWIG_Lua_add_boolean(L, "__gc", 0); +} + +/* creates the swig registry */ +SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L) +{ + /* create main SWIG registry table */ + lua_pushstring(L,"SWIG"); + lua_newtable(L); + /* populate it with some predefined data */ + + /* .library table. Placeholder */ + lua_pushstring(L,".library"); + lua_newtable(L); + { + /* list of metamethods that class inherits from its bases */ + lua_pushstring(L,"inheritable_metamethods"); + lua_newtable(L); + /* populate with list of metamethods */ + SWIG_Lua_populate_inheritable_metamethods(L); + lua_rawset(L,-3); + } + lua_rawset(L,-3); + + lua_rawset(L,LUA_REGISTRYINDEX); +} + +/* gets the swig registry (or creates it) */ +SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L) +{ + /* add this all into the swig registry: */ + lua_pushstring(L,"SWIG"); + lua_rawget(L,LUA_REGISTRYINDEX); /* get the registry */ + if (!lua_istable(L,-1)) /* not there */ + { /* must be first time, so add it */ + lua_pop(L,1); /* remove the result */ + SWIG_Lua_create_class_registry(L); + /* then get it */ + lua_pushstring(L,"SWIG"); + lua_rawget(L,LUA_REGISTRYINDEX); + } +} + +SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L) +{ + SWIG_Lua_get_class_registry(L); + lua_pushstring(L, ".library"); + lua_rawget(L,-2); + assert( !lua_isnil(L,-1) ); + lua_pushstring(L, "inheritable_metamethods"); + lua_rawget(L,-2); + + /* Remove class registry and library table */ + lua_remove(L,-2); + lua_remove(L,-2); +} + +/* Helper function to get the classes metatable from the register */ +SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname) +{ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,cname); /* get the name */ + lua_rawget(L,-2); /* get it */ + lua_remove(L,-2); /* tidy up (remove registry) */ +} + +/* Set up the base classes pointers. +Each class structure has a list of pointers to the base class structures. +This function fills them. +It cannot be done at compile time, as this will not work with hireachies +spread over more than one swig file. +Therefore it must be done at runtime, querying the SWIG type system. +*/ +SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss) +{ + int i=0; + swig_module_info *module=SWIG_GetModule(L); + for(i=0;clss->base_names[i];i++) + { + if (clss->bases[i]==0) /* not found yet */ + { + /* lookup and cache the base class */ + swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]); + if (info) clss->bases[i] = (swig_lua_class *) info->clientdata; + } + } +} + +#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) +/* Merges two tables */ +SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source) +{ + /* iterating */ + lua_pushnil(L); + while (lua_next(L,source) != 0) { + /* -1 - value, -2 - index */ + /* have to copy to assign */ + lua_pushvalue(L,-2); /* copy of index */ + lua_pushvalue(L,-2); /* copy of value */ + lua_rawset(L, target); + lua_pop(L,1); + /* only key is left */ + } +} + +/* Merges two tables with given name. original - index of target metatable, base - index of source metatable */ +SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base) +{ + /* push original[name], then base[name] */ + lua_pushstring(L,name); + lua_rawget(L,original); + int original_table = lua_gettop(L); + lua_pushstring(L,name); + lua_rawget(L,base); + int base_table = lua_gettop(L); + SWIG_Lua_merge_tables_by_index(L, original_table, base_table); + /* clearing stack */ + lua_pop(L,2); +} + +/* Function takes all symbols from base and adds it to derived class. It's just a helper. */ +SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls) +{ + /* There is one parameter - original, i.e. 'derived' class metatable */ + assert(lua_istable(L,-1)); + int original = lua_gettop(L); + SWIG_Lua_get_class_metatable(L,base_cls->fqname); + int base = lua_gettop(L); + SWIG_Lua_merge_tables(L, ".fn", original, base ); + SWIG_Lua_merge_tables(L, ".set", original, base ); + SWIG_Lua_merge_tables(L, ".get", original, base ); + lua_pop(L,1); +} + +/* Function squashes all symbols from 'clss' bases into itself */ +SWIGINTERN void SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss) +{ + int i; + SWIG_Lua_get_class_metatable(L,clss->fqname); + for(i=0;clss->base_names[i];i++) + { + if (clss->bases[i]==0) /* Somehow it's not found. Skip it */ + continue; + /* Thing is: all bases are already registered. Thus they have already executed + * this function. So we just need to squash them into us, because their bases + * are already squashed into them. No need for recursion here! + */ + SWIG_Lua_class_squash_base(L, clss->bases[i]); + } + lua_pop(L,1); /*tidy stack*/ +} +#endif + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */ +/* helper add a variable to a registered class */ +SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn) +{ + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_get_table(L,".get"); /* find the .get table */ + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_add_function(L,name,getFn); + lua_pop(L,1); /* tidy stack (remove table) */ + if (setFn) + { + SWIG_Lua_get_table(L,".set"); /* find the .set table */ + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_add_function(L,name,setFn); + lua_pop(L,1); /* tidy stack (remove table) */ + } +} + +/* helper to recursively add class static details (static attributes, operations and constants) */ +SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss) +{ + int i = 0; + /* The class namespace table must be on the top of the stack */ + assert(lua_istable(L,-1)); + /* call all the base classes first: we can then override these later: */ + for(i=0;clss->bases[i];i++) + { + SWIG_Lua_add_class_static_details(L,clss->bases[i]); + } + + SWIG_Lua_add_namespace_details(L, clss->cls_static); +} + +SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss); /* forward declaration */ + +/* helper to recursively add class details (attributes & operations) */ +SWIGINTERN void SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss) +{ + int i; + size_t bases_count = 0; + /* Add bases to .bases table */ + SWIG_Lua_get_table(L,".bases"); + assert(lua_istable(L,-1)); /* just in case */ + for(i=0;clss->bases[i];i++) + { + SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname); + /* Base class must be already registered */ + assert(lua_istable(L,-1)); + lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */ + bases_count++; + } + assert(lua_rawlen(L,-1) == bases_count); + lua_pop(L,1); /* remove .bases table */ + /* add attributes */ + for(i=0;clss->attributes[i].name;i++){ + SWIG_Lua_add_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod); + } + /* add methods to the metatable */ + SWIG_Lua_get_table(L,".fn"); /* find the .fn table */ + assert(lua_istable(L,-1)); /* just in case */ + for(i=0;clss->methods[i].name;i++){ + SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func); + } + lua_pop(L,1); /* tidy stack (remove table) */ + /* add operator overloads + This adds methods from metatable array to metatable. Can mess up garbage + collectind if someone defines __gc method + */ + if(clss->metatable) { + for(i=0;clss->metatable[i].name;i++) { + SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func); + } + } + +#if !defined(SWIG_LUA_SQUASH_BASES) + /* Adding metamethods that are defined in base classes. If bases were squashed + * then it is obviously unnecessary + */ + SWIG_Lua_add_class_user_metamethods(L, clss); +#endif +} + +/* Helpers to add user defined class metamedhods - __add, __sub etc. The helpers are needed + for the following issue: Lua runtime checks for metamethod existence with rawget function + ignoring our SWIG-provided __index and __newindex functions. Thus our inheritance-aware method + search algorithm doesn't work in such case. (Not to say that Lua runtime queries metamethod directly + in metatable and not in object). + Current solution is this: if somewhere in hierarchy metamethod __x is defined, then all descendants + are automatically given a special proxy __x that calls the real __x method. + Obvious idea - to copy __x instead of creating __x-proxy is wrong because if someone changes __x in runtime, + those changes must be reflected in all descendants. +*/ + +SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration*/ + +/* The real function that resolves a metamethod. + * Function searches given class and all its bases (recursively) for first instance of something that is + * not equal to SWIG_Lua_resolve_metamethod. (Almost always this 'something' is actual metamethod implementation + * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the + * answer. + * Returns 1 if found, 0 otherwise. + * clss is class which metatable we will search for method + * metamethod_name_idx is index in L where metamethod name (as string) lies + * skip_check allows skipping searching metamethod in the given class and immediately going to searching in bases. skip_check + * is not carried to subsequent recursive calls - false is always passed. It is set to true only at first call from + * SWIG_Lua_resolve_metamethod + * */ +SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx, + int skip_check) +{ + /* This function is called recursively */ + int result = 0; + int i = 0; + + if (!skip_check) { + SWIG_Lua_get_class_metatable(L, clss->fqname); + lua_pushvalue(L, metamethod_name_idx); + lua_rawget(L,-2); + /* If this is cfunction and it is equal to SWIG_Lua_resolve_metamethod then + * this isn't the function we are looking for :) + * lua_tocfunction will return NULL if not cfunction + */ + if (!lua_isnil(L,-1) && lua_tocfunction(L,-1) != SWIG_Lua_resolve_metamethod ) { + lua_remove(L,-2); /* removing class metatable */ + return 1; + } + lua_pop(L,2); /* remove class metatable and query result */ + } + + /* Forwarding calls to bases */ + for(i=0;clss->bases[i];i++) + { + result = SWIG_Lua_do_resolve_metamethod(L, clss->bases[i], metamethod_name_idx, 0); + if (result) + break; + } + + return result; +} + +/* The proxy function for metamethod. All parameters are passed as cclosure. Searches for actual method + * and calls it */ +SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L) +{ + int numargs; + int metamethod_name_idx; + const swig_lua_class* clss; + int result; + + lua_checkstack(L,5); + numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */ + + /* Get upvalues from closure */ + lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/ + metamethod_name_idx = lua_gettop(L); + + lua_pushvalue(L, lua_upvalueindex(2)); + clss = (const swig_lua_class*)(lua_touserdata(L,-1)); + lua_pop(L,1); /* remove lightuserdata with clss from stack */ + + /* Actual work */ + result = SWIG_Lua_do_resolve_metamethod(L, clss, metamethod_name_idx, 1); + if (!result) { + SWIG_Lua_pushferrstring(L,"The metamethod proxy is set, but it failed to find actual metamethod. Memory corruption is most likely explanation."); + lua_error(L); + return 0; + } + + lua_remove(L,-2); /* remove metamethod key */ + lua_insert(L,1); /* move function to correct position */ + lua_call(L, numargs, LUA_MULTRET); + return lua_gettop(L); /* return all results */ +} + + +/* If given metamethod must be present in given class, then creates appropriate proxy + * Returns 1 if successfully added, 0 if not added because no base class has it, -1 + * if method is defined in the class metatable itself + */ +SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index) +{ + int key_index; + int success = 0; + int i = 0; + + /* metamethod name - on the top of the stack */ + assert(lua_isstring(L,-1)); + + key_index = lua_gettop(L); + + /* Check whether method is already defined in metatable */ + lua_pushvalue(L,key_index); /* copy of the key */ + lua_gettable(L,metatable_index); + if( !lua_isnil(L,-1) ) { + lua_pop(L,1); + return -1; + } + lua_pop(L,1); + + /* Iterating over immediate bases */ + for(i=0;clss->bases[i];i++) + { + const swig_lua_class *base = clss->bases[i]; + SWIG_Lua_get_class_metatable(L, base->fqname); + lua_pushvalue(L, key_index); + lua_rawget(L, -2); + if( !lua_isnil(L,-1) ) { + lua_pushvalue(L, key_index); + + /* Add proxy function */ + lua_pushvalue(L, key_index); /* first closure value is function name */ + lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */ + lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2); + + lua_rawset(L, metatable_index); + success = 1; + } + lua_pop(L,1); /* remove function or nil */ + lua_pop(L,1); /* remove base class metatable */ + + if( success ) + break; + } + + return success; +} + +SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss) +{ + int metatable_index; + int metamethods_info_index; + int tostring_undefined; + int eq_undefined = 0; + + SWIG_Lua_get_class_metatable(L, clss->fqname); + metatable_index = lua_gettop(L); + SWIG_Lua_get_inheritable_metamethods(L); + assert(lua_istable(L,-1)); + metamethods_info_index = lua_gettop(L); + lua_pushnil(L); /* first key */ + while(lua_next(L, metamethods_info_index) != 0 ) { + /* key at index -2, value at index -1 */ + const int is_inheritable = lua_toboolean(L,-2); + lua_pop(L,1); /* remove value - we don't need it anymore */ + + if(is_inheritable) { /* if metamethod is inheritable */ + SWIG_Lua_add_class_user_metamethod(L,clss,metatable_index); + } + } + + lua_pop(L,1); /* remove inheritable metamethods table */ + + /* Special handling for __tostring method */ + lua_pushstring(L, "__tostring"); + lua_pushvalue(L,-1); + lua_rawget(L,metatable_index); + tostring_undefined = lua_isnil(L,-1); + lua_pop(L,1); + if( tostring_undefined ) { + lua_pushcfunction(L, SWIG_Lua_class_tostring); + lua_rawset(L, metatable_index); + } else { + lua_pop(L,1); /* remove copy of the key */ + } + + /* Special handling for __eq method */ + lua_pushstring(L, "__eq"); + lua_pushvalue(L,-1); + lua_rawget(L,metatable_index); + eq_undefined = lua_isnil(L,-1); + lua_pop(L,1); + if( eq_undefined ) { + lua_pushcfunction(L, SWIG_Lua_class_equal); + lua_rawset(L, metatable_index); + } else { + lua_pop(L,1); /* remove copy of the key */ + } + /* Warning: __index and __newindex are SWIG-defined. For user-defined operator[] + * a __getitem/__setitem method should be defined + */ + lua_pop(L,1); /* pop class metatable */ +} + +/* Register class static methods,attributes etc as well as constructor proxy */ +SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss) +{ + const int SWIGUNUSED begin = lua_gettop(L); + lua_checkstack(L,5); /* just in case */ + assert(lua_istable(L,-1)); /* just in case */ + assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */ + + SWIG_Lua_namespace_register(L,clss->cls_static, 1); + + assert(lua_istable(L,-1)); /* just in case */ + + /* add its constructor to module with the name of the class + so you can do MyClass(...) as well as new_MyClass(...) + BUT only if a constructor is defined + (this overcomes the problem of pure virtual classes without constructors)*/ + if (clss->constructor) + { + lua_getmetatable(L,-1); + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_add_function(L,"__call", clss->constructor); + lua_pop(L,1); + } + + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_add_class_static_details(L, clss); + + /* clear stack */ + lua_pop(L,1); + assert( lua_gettop(L) == begin ); +} + +/* Performs the instance (non-static) class registration process. Metatable for class is created + * and added to the class registry. + */ +SWIGINTERN void SWIG_Lua_class_register_instance(lua_State *L,swig_lua_class *clss) +{ + const int SWIGUNUSED begin = lua_gettop(L); + int i; + /* if name already there (class is already registered) then do nothing */ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,clss->fqname); /* get the name */ + lua_rawget(L,-2); + if(!lua_isnil(L,-1)) { + lua_pop(L,2); + assert(lua_gettop(L)==begin); + return; + } + lua_pop(L,2); /* tidy stack */ + /* Recursively initialize all bases */ + for(i=0;clss->bases[i];i++) + { + SWIG_Lua_class_register_instance(L,clss->bases[i]); + } + /* Again, get registry and push name */ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,clss->fqname); /* get the name */ + lua_newtable(L); /* create the metatable */ +#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + /* If squashing is requested, then merges all bases metatable into this one. + * It would get us all special methods: __getitem, __add etc. + * This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away + */ + { + int new_metatable_index = lua_absindex(L,-1); + for(i=0;clss->bases[i];i++) + { + int base_metatable; + SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname); + base_metatable = lua_absindex(L,-1); + SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable); + lua_pop(L,1); + } + } + /* And now we will overwrite all incorrectly set data */ +#endif + /* add string of class name called ".type" */ + lua_pushstring(L,".type"); + lua_pushstring(L,clss->fqname); + lua_rawset(L,-3); + /* add a table called bases */ + lua_pushstring(L,".bases"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".get" */ + lua_pushstring(L,".get"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".set" */ + lua_pushstring(L,".set"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".fn" */ + lua_pushstring(L,".fn"); + lua_newtable(L); + /* add manual disown method */ + SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown); + lua_rawset(L,-3); + /* add accessor fns for using the .get,.set&.fn */ + SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get); + SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set); + SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct); + /* add it */ + lua_rawset(L,-3); /* metatable into registry */ + lua_pop(L,1); /* tidy stack (remove registry) */ + assert(lua_gettop(L) == begin); + +#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + /* Now merge all symbols from .fn, .set, .get etc from bases to our tables */ + SWIG_Lua_class_squash_bases(L,clss); +#endif + SWIG_Lua_get_class_metatable(L,clss->fqname); + SWIG_Lua_add_class_instance_details(L,clss); /* recursive adding of details (atts & ops) */ + lua_pop(L,1); /* tidy stack (remove class metatable) */ + assert( lua_gettop(L) == begin ); +} + +SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss) +{ + int SWIGUNUSED begin; + assert(lua_istable(L,-1)); /* This is a table (module or namespace) where classes will be added */ + SWIG_Lua_class_register_instance(L,clss); + SWIG_Lua_class_register_static(L,clss); + + /* Add links from static part to instance part and vice versa */ + /* [SWIG registry] [Module] + * "MyClass" ----> [MyClass metatable] <===== "MyClass" -+> [static part] + * ".get" ----> ... | | getmetatable()----| + * ".set" ----> ... | | | + * ".static" --------------)----------------/ [static part metatable] + * | ".get" --> ... + * | ".set" --> .... + * |=============================== ".instance" + */ + begin = lua_gettop(L); + lua_pushstring(L,clss->cls_static->name); + lua_rawget(L,-2); /* get class static table */ + assert(lua_istable(L,-1)); + lua_getmetatable(L,-1); + assert(lua_istable(L,-1)); /* get class static metatable */ + lua_pushstring(L,".instance"); /* prepare key */ + + SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */ + assert(lua_istable(L,-1)); + lua_pushstring(L,".static"); /* prepare key */ + lua_pushvalue(L, -4); /* push static class TABLE */ + assert(lua_istable(L,-1)); + lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */ + lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */ + lua_pop(L,2); + assert(lua_gettop(L) == begin); +} +#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */ + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) +SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss) +{ + const int SWIGUNUSED begin = lua_gettop(L); + int i; + /* if name already there (class is already registered) then do nothing */ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,clss->fqname); /* get the name */ + lua_rawget(L,-2); + if(!lua_isnil(L,-1)) { + lua_pop(L,2); + assert(lua_gettop(L)==begin); + return; + } + lua_pop(L,2); /* tidy stack */ + /* Recursively initialize all bases */ + for(i=0;clss->bases[i];i++) + { + SWIG_Lua_elua_class_register_instance(L,clss->bases[i]); + } + /* Again, get registry and push name */ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,clss->fqname); /* get the name */ + assert(clss->metatable); + lua_pushrotable(L, (void*)(clss->metatable)); /* create the metatable */ + lua_rawset(L,-3); + lua_pop(L,1); + assert(lua_gettop(L) == begin); +} +#endif /* elua && eluac */ + +/* ----------------------------------------------------------------------------- + * Class/structure conversion fns + * ----------------------------------------------------------------------------- */ + +/* helper to add metatable to new lua object */ +SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L,swig_type_info *type) +{ + if (type->clientdata) /* there is clientdata: so add the metatable */ + { + SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname); + if (lua_istable(L,-1)) + { + lua_setmetatable(L,-2); + } + else + { + lua_pop(L,1); + } + } +} + +/* pushes a new object into the lua stack */ +SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own) +{ + swig_lua_userdata *usr; + if (!ptr){ + lua_pushnil(L); + return; + } + usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata)); /* get data */ + usr->ptr=ptr; /* set the ptr */ + usr->type=type; + usr->own=own; +#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) + SWIG_Lua_AddMetatable(L,type); /* add metatable */ +#endif +} + +/* takes a object from the lua stack & converts it into an object of the correct type + (if possible) */ +SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags) +{ + int ret = SWIG_ERROR; + swig_lua_userdata *usr; + swig_cast_info *cast; + /* special case: lua nil => NULL pointer */ + if (lua_isnil(L,index)) + { + *ptr=0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + if (lua_islightuserdata(L,index)) + { + *ptr=lua_touserdata(L,index); + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */ + if (usr) + { + if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !usr->own) + { + return SWIG_ERROR_RELEASE_NOT_OWNED; + } + if (flags & SWIG_POINTER_DISOWN) /* must disown the object */ + { + usr->own = 0; + } + if (!type) /* special cast void*, no casting fn */ + { + *ptr=usr->ptr; + ret = SWIG_OK; + } + else + { + cast=SWIG_TypeCheck(usr->type->name,type); /* performs normal type checking */ + if (cast) + { + int newmemory = 0; + *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + ret = SWIG_OK; + } + } + if ((ret == SWIG_OK) && (flags & SWIG_POINTER_CLEAR)) + { + usr->ptr = 0; + } + } + return ret; +} + +SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags, + int argnum,const char *func_name){ + void *result = 0; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){ + luaL_error (L,"Error in %s, expected a %s at argument number %d\n", + func_name,(type && type->str)?type->str:"void*",argnum); + } + return result; +} + +/* pushes a packed userdata. user for member fn pointers only */ +SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type) +{ + swig_lua_rawdata *raw; + assert(ptr); /* not acceptable to pass in a NULL value */ + raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size); /* alloc data */ + raw->type=type; + raw->own=0; + memcpy(raw->data,ptr,size); /* copy the data */ + SWIG_Lua_AddMetatable(L,type); /* add metatable */ +} + +/* converts a packed userdata. user for member fn pointers only */ +SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type) +{ + swig_lua_rawdata *raw; + raw=(swig_lua_rawdata*)lua_touserdata(L,index); /* get data */ + if (!raw) return SWIG_ERROR; /* error */ + if (type==0 || type==raw->type) /* void* or identical type */ + { + memcpy(ptr,raw->data,size); /* copy it */ + return SWIG_OK; /* ok */ + } + return SWIG_ERROR; /* error */ +} + +/* a function to get the typestring of a piece of data */ +SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp) +{ + swig_lua_userdata *usr; + if (lua_isuserdata(L,tp)) + { + usr=(swig_lua_userdata*)lua_touserdata(L,tp); /* get data */ + if (usr && usr->type && usr->type->str) + return usr->type->str; + return "userdata (unknown type)"; + } + return lua_typename(L,lua_type(L,tp)); +} + +/* lua callable function to get the userdata's type */ +SWIGRUNTIME int SWIG_Lua_type(lua_State *L) +{ + lua_pushstring(L,SWIG_Lua_typename(L,1)); + return 1; +} + +/* ----------------------------------------------------------------------------- + * global variable support code: class/struct typemap functions + * ----------------------------------------------------------------------------- */ + +#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) +/* Install Constants */ +SWIGINTERN void +SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) { + int i; + for (i = 0; constants[i].type; i++) { + switch(constants[i].type) { + case SWIG_LUA_INT: + lua_pushstring(L,constants[i].name); + lua_pushinteger(L,(lua_Integer)constants[i].lvalue); + lua_rawset(L,-3); + break; + case SWIG_LUA_FLOAT: + lua_pushstring(L,constants[i].name); + lua_pushnumber(L,(lua_Number)constants[i].dvalue); + lua_rawset(L,-3); + break; + case SWIG_LUA_CHAR: + lua_pushstring(L,constants[i].name); + { + char c = (char)constants[i].lvalue; + lua_pushlstring(L,&c,1); + } + lua_rawset(L,-3); + break; + case SWIG_LUA_STRING: + lua_pushstring(L,constants[i].name); + lua_pushstring(L,(char *) constants[i].pvalue); + lua_rawset(L,-3); + break; + case SWIG_LUA_POINTER: + lua_pushstring(L,constants[i].name); + SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0); + lua_rawset(L,-3); + break; + case SWIG_LUA_BINARY: + lua_pushstring(L,constants[i].name); + SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype); + lua_rawset(L,-3); + break; + default: + break; + } + } +} +#endif + +/* ----------------------------------------------------------------------------- + * executing lua code from within the wrapper + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */ +#define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S) +#endif +/* Executes a C string in Lua which is a really simple way of calling lua from C +Unfortunately lua keeps changing its APIs, so we need a conditional compile +In lua 5.0.X it's lua_dostring() +In lua 5.1.X it's luaL_dostring() +*/ +SWIGINTERN int +SWIG_Lua_dostring(lua_State *L, const char *str) { + int ok,top; + if (str==0 || str[0]==0) return 0; /* nothing to do */ + top=lua_gettop(L); /* save stack */ +#if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501)) + ok=luaL_dostring(L,str); /* looks like this is lua 5.1.X or later, good */ +#else + ok=lua_dostring(L,str); /* might be lua 5.0.x, using lua_dostring */ +#endif + if (ok!=0) { + SWIG_DOSTRING_FAIL(lua_tostring(L,-1)); + } + lua_settop(L,top); /* restore the stack */ + return ok; +} + +#ifdef __cplusplus +} +#endif + +/* ------------------------------ end luarun.swg ------------------------------ */ + +/* 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 + + + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_Day swig_types[0] +#define SWIGTYPE_p_GZ swig_types[1] +#define SWIGTYPE_p_Time swig_types[2] +#define SWIGTYPE_p_difference_type swig_types[3] +#define SWIGTYPE_p_int swig_types[4] +#define SWIGTYPE_p_long_long swig_types[5] +#define SWIGTYPE_p_short swig_types[6] +#define SWIGTYPE_p_signed_char swig_types[7] +#define SWIGTYPE_p_size_type swig_types[8] +#define SWIGTYPE_p_std__string swig_types[9] +#define SWIGTYPE_p_std__vectorT_double_t swig_types[10] +#define SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t swig_types[11] +#define SWIGTYPE_p_sxtwl__JieQiInfo swig_types[12] +#define SWIGTYPE_p_unsigned_char swig_types[13] +#define SWIGTYPE_p_unsigned_int swig_types[14] +#define SWIGTYPE_p_unsigned_long_long swig_types[15] +#define SWIGTYPE_p_unsigned_short swig_types[16] +#define SWIGTYPE_p_value_type 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) -------- */ + +#define SWIG_name "sxtwl" +#define SWIG_init luaopen_sxtwl +#define SWIG_init_user luaopen_sxtwl_user + +#define SWIG_LUACODE luaopen_sxtwl_luacode + +#ifdef __cplusplus +#include +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigSmartPointer { + T *ptr; + SwigSmartPointer(T *p) : ptr(p) { } + ~SwigSmartPointer() { delete ptr; } + SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; } +#if __cplusplus >=201103L + SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; } + operator T&&() const { return std::move(*pointer.ptr); } +#else + operator T&() const { return *pointer.ptr; } +#endif + T *operator&() const { return pointer.ptr; } + static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); } +}; + +/* + * SwigValueInit() is a generic initialisation solution as the following approach: + * + * T c_result = T(); + * + * doesn't compile for all types for example: + * + * unsigned int c_result = unsigned int(); + */ +template T SwigValueInit() { + return T(); +} + +#if __cplusplus >=201103L +# define SWIG_STD_MOVE(OBJ) std::move(OBJ) +#else +# define SWIG_STD_MOVE(OBJ) OBJ +#endif + +#endif + + +namespace swig { +typedef struct{} LANGUAGE_OBJ; +} + + +#include "const.h" +#include "sxtwl.h" + + +#include // Use the C99 official header + + +#include + + +#include +#include + + +#define SWIG_exception(a,b)\ +{ lua_pushfstring(L,"%s:%s",#a,b);SWIG_fail; } + + +#include +#include + + +#include + + +SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) { + int ret = lua_isstring(L, idx); + if (!ret) + ret = lua_isnil(L, idx); + return ret; +} + +SWIGINTERN double std_vector_Sl_double_Sg____getitem__(std::vector< double > *self,unsigned int idx){ + if (idx>=self->size()) + throw std::out_of_range("in vector::__getitem__()"); + return (*self)[idx]; + } +SWIGINTERN void std_vector_Sl_double_Sg____setitem__(std::vector< double > *self,unsigned int idx,double val){ + if (idx>=self->size()) + throw std::out_of_range("in vector::__setitem__()"); + (*self)[idx]=val; + } +SWIGINTERN sxtwl::JieQiInfo std_vector_Sl_sxtwl_JieQiInfo_Sg____getitem__(std::vector< sxtwl::JieQiInfo > *self,unsigned int idx){ + if (idx>=self->size()) + throw std::out_of_range("in vector::__getitem__()"); + return (*self)[idx]; + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg____setitem__(std::vector< sxtwl::JieQiInfo > *self,unsigned int idx,sxtwl::JieQiInfo val){ + if (idx>=self->size()) + throw std::out_of_range("in vector::__setitem__()"); + (*self)[idx]=val; + } +#ifdef __cplusplus +extern "C" { +#endif +static int _wrap_new_string__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + std::string *result = 0 ; + + SWIG_check_num_args("std::string::string",0,0) + result = (std::string *)new std::string(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_string__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + std::string *result = 0 ; + + SWIG_check_num_args("std::string::string",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::string::string",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (std::string *)new std::string((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_string(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_string__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_new_string__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_string'\n" + " Possible C/C++ prototypes are:\n" + " std::string::string()\n" + " std::string::string(char const *)\n"); + lua_error(L);return 0; +} + + +static int _wrap_string_size(lua_State* L) { + { + int SWIG_arg = 0; + std::string *arg1 = (std::string *) 0 ; + unsigned int result; + + SWIG_check_num_args("std::string::size",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::size",1,"std::string const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_size",1,SWIGTYPE_p_std__string); + } + + result = (unsigned int)((std::string const *)arg1)->size(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_string_length(lua_State* L) { + { + int SWIG_arg = 0; + std::string *arg1 = (std::string *) 0 ; + unsigned int result; + + SWIG_check_num_args("std::string::length",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::length",1,"std::string const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_length",1,SWIGTYPE_p_std__string); + } + + result = (unsigned int)((std::string const *)arg1)->length(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_string_empty(lua_State* L) { + { + int SWIG_arg = 0; + std::string *arg1 = (std::string *) 0 ; + bool result; + + SWIG_check_num_args("std::string::empty",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::empty",1,"std::string const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_empty",1,SWIGTYPE_p_std__string); + } + + result = (bool)((std::string const *)arg1)->empty(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_string_c_str(lua_State* L) { + { + int SWIG_arg = 0; + std::string *arg1 = (std::string *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("std::string::c_str",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::c_str",1,"std::string const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_c_str",1,SWIGTYPE_p_std__string); + } + + result = (char *)((std::string const *)arg1)->c_str(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_string_data(lua_State* L) { + { + int SWIG_arg = 0; + std::string *arg1 = (std::string *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("std::string::data",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::data",1,"std::string const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_data",1,SWIGTYPE_p_std__string); + } + + result = (char *)((std::string const *)arg1)->data(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_string_assign(lua_State* L) { + { + int SWIG_arg = 0; + std::string *arg1 = (std::string *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("std::string::assign",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::assign",1,"std::string *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("std::string::assign",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_assign",1,SWIGTYPE_p_std__string); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->assign((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_string(void *obj) { +std::string *arg1 = (std::string *) obj; +delete arg1; +} +static int _proxy__wrap_new_string(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_string); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_string_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_string_methods[]= { + { "size", _wrap_string_size}, + { "length", _wrap_string_length}, + { "empty", _wrap_string_empty}, + { "c_str", _wrap_string_c_str}, + { "data", _wrap_string_data}, + { "assign", _wrap_string_assign}, + {0,0} +}; +static swig_lua_method swig_string_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_string_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_string_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_string_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_string_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_string_Sf_SwigStatic = { + "string", + swig_string_Sf_SwigStatic_methods, + swig_string_Sf_SwigStatic_attributes, + swig_string_Sf_SwigStatic_constants, + swig_string_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_string_bases[] = {0}; +static const char *swig_string_base_names[] = {0}; +static swig_lua_class _wrap_class_string = { "string", "string", &SWIGTYPE_p_std__string,_proxy__wrap_new_string, swig_delete_string, swig_string_methods, swig_string_attributes, &swig_string_Sf_SwigStatic, swig_string_meta, swig_string_bases, swig_string_base_names }; + +static int _wrap_new_JDList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< double > *result = 0 ; + + SWIG_check_num_args("std::vector< double >::vector",0,0) + result = (std::vector< double > *)new std::vector< double >(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_double_t,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_JDList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + unsigned int arg1 ; + std::vector< double > *result = 0 ; + + SWIG_check_num_args("std::vector< double >::vector",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< double >::vector",1,"unsigned int"); + SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative"); + arg1 = (unsigned int)lua_tonumber(L, 1); + result = (std::vector< double > *)new std::vector< double >(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_double_t,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_JDList__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< double > *arg1 = 0 ; + std::vector< double > *result = 0 ; + + SWIG_check_num_args("std::vector< double >::vector",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< double >::vector",1,"std::vector< double > const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_double_t,0))){ + SWIG_fail_ptr("new_JDList",1,SWIGTYPE_p_std__vectorT_double_t); + } + + result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_double_t,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_JDList__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + unsigned int arg1 ; + double arg2 ; + std::vector< double > *result = 0 ; + + SWIG_check_num_args("std::vector< double >::vector",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< double >::vector",1,"unsigned int"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< double >::vector",2,"double"); + SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative"); + arg1 = (unsigned int)lua_tonumber(L, 1); + arg2 = (double)lua_tonumber(L, 2); + result = (std::vector< double > *)new std::vector< double >(arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_double_t,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_JDList(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_JDList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_JDList__SWIG_2(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + return _wrap_new_JDList__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_new_JDList__SWIG_3(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_JDList'\n" + " Possible C/C++ prototypes are:\n" + " std::vector< double >::vector()\n" + " std::vector< double >::vector(unsigned int)\n" + " std::vector< double >::vector(std::vector< double > const &)\n" + " std::vector< double >::vector(unsigned int,double)\n"); + lua_error(L);return 0; +} + + +static int _wrap_JDList_size(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + unsigned int result; + + SWIG_check_num_args("std::vector< double >::size",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< double >::size",1,"std::vector< double > const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_double_t,0))){ + SWIG_fail_ptr("JDList_size",1,SWIGTYPE_p_std__vectorT_double_t); + } + + result = (unsigned int)((std::vector< double > const *)arg1)->size(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JDList_max_size(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + unsigned int result; + + SWIG_check_num_args("std::vector< double >::max_size",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< double >::max_size",1,"std::vector< double > const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_double_t,0))){ + SWIG_fail_ptr("JDList_max_size",1,SWIGTYPE_p_std__vectorT_double_t); + } + + result = (unsigned int)((std::vector< double > const *)arg1)->max_size(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JDList_empty(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + bool result; + + SWIG_check_num_args("std::vector< double >::empty",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< double >::empty",1,"std::vector< double > const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_double_t,0))){ + SWIG_fail_ptr("JDList_empty",1,SWIGTYPE_p_std__vectorT_double_t); + } + + result = (bool)((std::vector< double > const *)arg1)->empty(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JDList_clear(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + + SWIG_check_num_args("std::vector< double >::clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< double >::clear",1,"std::vector< double > *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_double_t,0))){ + SWIG_fail_ptr("JDList_clear",1,SWIGTYPE_p_std__vectorT_double_t); + } + + (arg1)->clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JDList_push_back(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + double arg2 ; + + SWIG_check_num_args("std::vector< double >::push_back",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< double >::push_back",1,"std::vector< double > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< double >::push_back",2,"double"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_double_t,0))){ + SWIG_fail_ptr("JDList_push_back",1,SWIGTYPE_p_std__vectorT_double_t); + } + + arg2 = (double)lua_tonumber(L, 2); + (arg1)->push_back(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JDList_pop_back(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + + SWIG_check_num_args("std::vector< double >::pop_back",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< double >::pop_back",1,"std::vector< double > *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_double_t,0))){ + SWIG_fail_ptr("JDList_pop_back",1,SWIGTYPE_p_std__vectorT_double_t); + } + + (arg1)->pop_back(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JDList_front(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + double result; + + SWIG_check_num_args("std::vector< double >::front",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< double >::front",1,"std::vector< double > const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_double_t,0))){ + SWIG_fail_ptr("JDList_front",1,SWIGTYPE_p_std__vectorT_double_t); + } + + result = (double)((std::vector< double > const *)arg1)->front(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JDList_back(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + double result; + + SWIG_check_num_args("std::vector< double >::back",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< double >::back",1,"std::vector< double > const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_double_t,0))){ + SWIG_fail_ptr("JDList_back",1,SWIGTYPE_p_std__vectorT_double_t); + } + + result = (double)((std::vector< double > const *)arg1)->back(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JDList___getitem(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + unsigned int arg2 ; + double result; + + SWIG_check_num_args("std::vector< double >::__getitem__",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< double >::__getitem__",1,"std::vector< double > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< double >::__getitem__",2,"unsigned int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_double_t,0))){ + SWIG_fail_ptr("JDList___getitem",1,SWIGTYPE_p_std__vectorT_double_t); + } + + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (unsigned int)lua_tonumber(L, 2); + try { + result = (double)std_vector_Sl_double_Sg____getitem__(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception(SWIG_IndexError, (&_e)->what()); + } + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JDList___setitem(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + unsigned int arg2 ; + double arg3 ; + + SWIG_check_num_args("std::vector< double >::__setitem__",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< double >::__setitem__",1,"std::vector< double > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< double >::__setitem__",2,"unsigned int"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("std::vector< double >::__setitem__",3,"double"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_double_t,0))){ + SWIG_fail_ptr("JDList___setitem",1,SWIGTYPE_p_std__vectorT_double_t); + } + + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (unsigned int)lua_tonumber(L, 2); + arg3 = (double)lua_tonumber(L, 3); + try { + std_vector_Sl_double_Sg____setitem__(arg1,arg2,arg3); + } catch(std::out_of_range &_e) { + SWIG_exception(SWIG_IndexError, (&_e)->what()); + } + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_JDList(void *obj) { +std::vector< double > *arg1 = (std::vector< double > *) obj; +delete arg1; +} +static int _proxy__wrap_new_JDList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_JDList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_JDList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_JDList_methods[]= { + { "size", _wrap_JDList_size}, + { "max_size", _wrap_JDList_max_size}, + { "empty", _wrap_JDList_empty}, + { "clear", _wrap_JDList_clear}, + { "push_back", _wrap_JDList_push_back}, + { "pop_back", _wrap_JDList_pop_back}, + { "front", _wrap_JDList_front}, + { "back", _wrap_JDList_back}, + { "__getitem", _wrap_JDList___getitem}, + { "__setitem", _wrap_JDList___setitem}, + {0,0} +}; +static swig_lua_method swig_JDList_meta[] = { + { "__getitem", _wrap_JDList___getitem}, + { "__setitem", _wrap_JDList___setitem}, + {0,0} +}; + +static swig_lua_attribute swig_JDList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_JDList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_JDList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_JDList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_JDList_Sf_SwigStatic = { + "JDList", + swig_JDList_Sf_SwigStatic_methods, + swig_JDList_Sf_SwigStatic_attributes, + swig_JDList_Sf_SwigStatic_constants, + swig_JDList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_JDList_bases[] = {0}; +static const char *swig_JDList_base_names[] = {0}; +static swig_lua_class _wrap_class_JDList = { "JDList", "JDList", &SWIGTYPE_p_std__vectorT_double_t,_proxy__wrap_new_JDList, swig_delete_JDList, swig_JDList_methods, swig_JDList_attributes, &swig_JDList_Sf_SwigStatic, swig_JDList_meta, swig_JDList_bases, swig_JDList_base_names }; + +static int _wrap_new_JQList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::vector",0,0) + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_JQList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + unsigned int arg1 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::vector",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::vector",1,"unsigned int"); + SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative"); + arg1 = (unsigned int)lua_tonumber(L, 1); + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_JQList__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = 0 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::vector",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::vector",1,"std::vector< sxtwl::JieQiInfo > const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,0))){ + SWIG_fail_ptr("new_JQList",1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t); + } + + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >((std::vector< sxtwl::JieQiInfo > const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_JQList__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + unsigned int arg1 ; + sxtwl::JieQiInfo arg2 ; + sxtwl::JieQiInfo *argp2 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::vector",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::vector",1,"unsigned int"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::vector",2,"sxtwl::JieQiInfo"); + SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative"); + arg1 = (unsigned int)lua_tonumber(L, 1); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_sxtwl__JieQiInfo,0))){ + SWIG_fail_ptr("new_JQList",2,SWIGTYPE_p_sxtwl__JieQiInfo); + } + arg2 = *argp2; + + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >(arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_JQList(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_JQList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_JQList__SWIG_2(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + return _wrap_new_JQList__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_sxtwl__JieQiInfo, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_JQList__SWIG_3(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_JQList'\n" + " Possible C/C++ prototypes are:\n" + " std::vector< sxtwl::JieQiInfo >::vector()\n" + " std::vector< sxtwl::JieQiInfo >::vector(unsigned int)\n" + " std::vector< sxtwl::JieQiInfo >::vector(std::vector< sxtwl::JieQiInfo > const &)\n" + " std::vector< sxtwl::JieQiInfo >::vector(unsigned int,sxtwl::JieQiInfo)\n"); + lua_error(L);return 0; +} + + +static int _wrap_JQList_size(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + unsigned int result; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::size",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::size",1,"std::vector< sxtwl::JieQiInfo > const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,0))){ + SWIG_fail_ptr("JQList_size",1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t); + } + + result = (unsigned int)((std::vector< sxtwl::JieQiInfo > const *)arg1)->size(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JQList_max_size(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + unsigned int result; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::max_size",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::max_size",1,"std::vector< sxtwl::JieQiInfo > const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,0))){ + SWIG_fail_ptr("JQList_max_size",1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t); + } + + result = (unsigned int)((std::vector< sxtwl::JieQiInfo > const *)arg1)->max_size(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JQList_empty(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + bool result; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::empty",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::empty",1,"std::vector< sxtwl::JieQiInfo > const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,0))){ + SWIG_fail_ptr("JQList_empty",1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t); + } + + result = (bool)((std::vector< sxtwl::JieQiInfo > const *)arg1)->empty(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JQList_clear(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::clear",1,"std::vector< sxtwl::JieQiInfo > *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,0))){ + SWIG_fail_ptr("JQList_clear",1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t); + } + + (arg1)->clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JQList_push_back(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + sxtwl::JieQiInfo arg2 ; + sxtwl::JieQiInfo *argp2 ; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::push_back",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::push_back",1,"std::vector< sxtwl::JieQiInfo > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::push_back",2,"sxtwl::JieQiInfo"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,0))){ + SWIG_fail_ptr("JQList_push_back",1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_sxtwl__JieQiInfo,0))){ + SWIG_fail_ptr("JQList_push_back",2,SWIGTYPE_p_sxtwl__JieQiInfo); + } + arg2 = *argp2; + + (arg1)->push_back(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JQList_pop_back(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::pop_back",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::pop_back",1,"std::vector< sxtwl::JieQiInfo > *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,0))){ + SWIG_fail_ptr("JQList_pop_back",1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t); + } + + (arg1)->pop_back(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JQList_front(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + sxtwl::JieQiInfo result; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::front",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::front",1,"std::vector< sxtwl::JieQiInfo > const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,0))){ + SWIG_fail_ptr("JQList_front",1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t); + } + + result = ((std::vector< sxtwl::JieQiInfo > const *)arg1)->front(); + { + sxtwl::JieQiInfo * resultptr = new sxtwl::JieQiInfo(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_sxtwl__JieQiInfo,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JQList_back(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + sxtwl::JieQiInfo result; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::back",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::back",1,"std::vector< sxtwl::JieQiInfo > const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,0))){ + SWIG_fail_ptr("JQList_back",1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t); + } + + result = ((std::vector< sxtwl::JieQiInfo > const *)arg1)->back(); + { + sxtwl::JieQiInfo * resultptr = new sxtwl::JieQiInfo(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_sxtwl__JieQiInfo,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JQList___getitem(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + unsigned int arg2 ; + sxtwl::JieQiInfo result; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::__getitem__",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::__getitem__",1,"std::vector< sxtwl::JieQiInfo > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::__getitem__",2,"unsigned int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,0))){ + SWIG_fail_ptr("JQList___getitem",1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t); + } + + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (unsigned int)lua_tonumber(L, 2); + try { + result = std_vector_Sl_sxtwl_JieQiInfo_Sg____getitem__(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception(SWIG_IndexError, (&_e)->what()); + } + { + sxtwl::JieQiInfo * resultptr = new sxtwl::JieQiInfo(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_sxtwl__JieQiInfo,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JQList___setitem(lua_State* L) { + { + int SWIG_arg = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + unsigned int arg2 ; + sxtwl::JieQiInfo arg3 ; + sxtwl::JieQiInfo *argp3 ; + + SWIG_check_num_args("std::vector< sxtwl::JieQiInfo >::__setitem__",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::__setitem__",1,"std::vector< sxtwl::JieQiInfo > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::__setitem__",2,"unsigned int"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("std::vector< sxtwl::JieQiInfo >::__setitem__",3,"sxtwl::JieQiInfo"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,0))){ + SWIG_fail_ptr("JQList___setitem",1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t); + } + + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (unsigned int)lua_tonumber(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_sxtwl__JieQiInfo,0))){ + SWIG_fail_ptr("JQList___setitem",3,SWIGTYPE_p_sxtwl__JieQiInfo); + } + arg3 = *argp3; + + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg____setitem__(arg1,arg2,SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception(SWIG_IndexError, (&_e)->what()); + } + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_JQList(void *obj) { +std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) obj; +delete arg1; +} +static int _proxy__wrap_new_JQList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_JQList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_JQList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_JQList_methods[]= { + { "size", _wrap_JQList_size}, + { "max_size", _wrap_JQList_max_size}, + { "empty", _wrap_JQList_empty}, + { "clear", _wrap_JQList_clear}, + { "push_back", _wrap_JQList_push_back}, + { "pop_back", _wrap_JQList_pop_back}, + { "front", _wrap_JQList_front}, + { "back", _wrap_JQList_back}, + { "__getitem", _wrap_JQList___getitem}, + { "__setitem", _wrap_JQList___setitem}, + {0,0} +}; +static swig_lua_method swig_JQList_meta[] = { + { "__getitem", _wrap_JQList___getitem}, + { "__setitem", _wrap_JQList___setitem}, + {0,0} +}; + +static swig_lua_attribute swig_JQList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_JQList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_JQList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_JQList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_JQList_Sf_SwigStatic = { + "JQList", + swig_JQList_Sf_SwigStatic_methods, + swig_JQList_Sf_SwigStatic_attributes, + swig_JQList_Sf_SwigStatic_constants, + swig_JQList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_JQList_bases[] = {0}; +static const char *swig_JQList_base_names[] = {0}; +static swig_lua_class _wrap_class_JQList = { "JQList", "JQList", &SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,_proxy__wrap_new_JQList, swig_delete_JQList, swig_JQList_methods, swig_JQList_attributes, &swig_JQList_Sf_SwigStatic, swig_JQList_meta, swig_JQList_bases, swig_JQList_base_names }; + +static int _wrap_new_Time__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + Time *result = 0 ; + + SWIG_check_num_args("Time::Time",0,0) + result = (Time *)new Time(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_Time,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_Time__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + int arg2 ; + int arg3 ; + double arg4 ; + double arg5 ; + double arg6 ; + Time *result = 0 ; + + SWIG_check_num_args("Time::Time",6,6) + if(!lua_isnumber(L,1)) SWIG_fail_arg("Time::Time",1,"int"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::Time",2,"int"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("Time::Time",3,"int"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("Time::Time",4,"double"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("Time::Time",5,"double"); + if(!lua_isnumber(L,6)) SWIG_fail_arg("Time::Time",6,"double"); + arg1 = (int)lua_tonumber(L, 1); + arg2 = (int)lua_tonumber(L, 2); + arg3 = (int)lua_tonumber(L, 3); + arg4 = (double)lua_tonumber(L, 4); + arg5 = (double)lua_tonumber(L, 5); + arg6 = (double)lua_tonumber(L, 6); + result = (Time *)new Time(arg1,arg2,arg3,arg4,arg5,arg6); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_Time,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_Time(lua_State* L) { + int argc; + int argv[7]={ + 1,2,3,4,5,6,7 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_Time__SWIG_0(L); + } + if (argc == 6) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[4]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[5]); + } + if (_v) { + return _wrap_new_Time__SWIG_1(L); + } + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Time'\n" + " Possible C/C++ prototypes are:\n" + " Time::Time()\n" + " Time::Time(int,int,int,double,double,double)\n"); + lua_error(L);return 0; +} + + +static int _wrap_Time_Y_set(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + int arg2 ; + + SWIG_check_num_args("Time::Y",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::Y",1,"Time *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::Y",2,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_Y_set",1,SWIGTYPE_p_Time); + } + + arg2 = (int)lua_tonumber(L, 2); + if (arg1) (arg1)->Y = arg2; + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_Y_get(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + int result; + + SWIG_check_num_args("Time::Y",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::Y",1,"Time *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_Y_get",1,SWIGTYPE_p_Time); + } + + result = (int) ((arg1)->Y); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_M_set(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + int arg2 ; + + SWIG_check_num_args("Time::M",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::M",1,"Time *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::M",2,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_M_set",1,SWIGTYPE_p_Time); + } + + arg2 = (int)lua_tonumber(L, 2); + if (arg1) (arg1)->M = arg2; + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_M_get(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + int result; + + SWIG_check_num_args("Time::M",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::M",1,"Time *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_M_get",1,SWIGTYPE_p_Time); + } + + result = (int) ((arg1)->M); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_D_set(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + int arg2 ; + + SWIG_check_num_args("Time::D",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::D",1,"Time *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::D",2,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_D_set",1,SWIGTYPE_p_Time); + } + + arg2 = (int)lua_tonumber(L, 2); + if (arg1) (arg1)->D = arg2; + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_D_get(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + int result; + + SWIG_check_num_args("Time::D",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::D",1,"Time *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_D_get",1,SWIGTYPE_p_Time); + } + + result = (int) ((arg1)->D); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_h_set(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + double arg2 ; + + SWIG_check_num_args("Time::h",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::h",1,"Time *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::h",2,"double"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_h_set",1,SWIGTYPE_p_Time); + } + + arg2 = (double)lua_tonumber(L, 2); + if (arg1) (arg1)->h = arg2; + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_h_get(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + double result; + + SWIG_check_num_args("Time::h",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::h",1,"Time *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_h_get",1,SWIGTYPE_p_Time); + } + + result = (double) ((arg1)->h); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_m_set(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + double arg2 ; + + SWIG_check_num_args("Time::m",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::m",1,"Time *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::m",2,"double"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_m_set",1,SWIGTYPE_p_Time); + } + + arg2 = (double)lua_tonumber(L, 2); + if (arg1) (arg1)->m = arg2; + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_m_get(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + double result; + + SWIG_check_num_args("Time::m",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::m",1,"Time *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_m_get",1,SWIGTYPE_p_Time); + } + + result = (double) ((arg1)->m); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_s_set(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + double arg2 ; + + SWIG_check_num_args("Time::s",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::s",1,"Time *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::s",2,"double"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_s_set",1,SWIGTYPE_p_Time); + } + + arg2 = (double)lua_tonumber(L, 2); + if (arg1) (arg1)->s = arg2; + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_s_get(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + double result; + + SWIG_check_num_args("Time::s",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::s",1,"Time *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_s_get",1,SWIGTYPE_p_Time); + } + + result = (double) ((arg1)->s); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_getYear(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + int result; + + SWIG_check_num_args("Time::getYear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::getYear",1,"Time *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_getYear",1,SWIGTYPE_p_Time); + } + + result = (int)(arg1)->getYear(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_setYear(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + int arg2 ; + + SWIG_check_num_args("Time::setYear",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::setYear",1,"Time *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::setYear",2,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_setYear",1,SWIGTYPE_p_Time); + } + + arg2 = (int)lua_tonumber(L, 2); + (arg1)->setYear(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_setMonth(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + int arg2 ; + + SWIG_check_num_args("Time::setMonth",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::setMonth",1,"Time *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::setMonth",2,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_setMonth",1,SWIGTYPE_p_Time); + } + + arg2 = (int)lua_tonumber(L, 2); + (arg1)->setMonth(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_getMonth(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + int result; + + SWIG_check_num_args("Time::getMonth",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::getMonth",1,"Time *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_getMonth",1,SWIGTYPE_p_Time); + } + + result = (int)(arg1)->getMonth(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_getDay(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + int result; + + SWIG_check_num_args("Time::getDay",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::getDay",1,"Time *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_getDay",1,SWIGTYPE_p_Time); + } + + result = (int)(arg1)->getDay(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_setDay(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + int arg2 ; + + SWIG_check_num_args("Time::setDay",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::setDay",1,"Time *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::setDay",2,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_setDay",1,SWIGTYPE_p_Time); + } + + arg2 = (int)lua_tonumber(L, 2); + (arg1)->setDay(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_getHour(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + double result; + + SWIG_check_num_args("Time::getHour",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::getHour",1,"Time *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_getHour",1,SWIGTYPE_p_Time); + } + + result = (double)(arg1)->getHour(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_setHour(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + double arg2 ; + + SWIG_check_num_args("Time::setHour",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::setHour",1,"Time *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::setHour",2,"double"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_setHour",1,SWIGTYPE_p_Time); + } + + arg2 = (double)lua_tonumber(L, 2); + (arg1)->setHour(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_getMin(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + double result; + + SWIG_check_num_args("Time::getMin",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::getMin",1,"Time *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_getMin",1,SWIGTYPE_p_Time); + } + + result = (double)(arg1)->getMin(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_setMour(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + double arg2 ; + + SWIG_check_num_args("Time::setMour",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::setMour",1,"Time *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::setMour",2,"double"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_setMour",1,SWIGTYPE_p_Time); + } + + arg2 = (double)lua_tonumber(L, 2); + (arg1)->setMour(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_getSec(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + double result; + + SWIG_check_num_args("Time::getSec",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::getSec",1,"Time *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_getSec",1,SWIGTYPE_p_Time); + } + + result = (double)(arg1)->getSec(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Time_setSec(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = (Time *) 0 ; + double arg2 ; + + SWIG_check_num_args("Time::setSec",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Time::setSec",1,"Time *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Time::setSec",2,"double"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("Time_setSec",1,SWIGTYPE_p_Time); + } + + arg2 = (double)lua_tonumber(L, 2); + (arg1)->setSec(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_Time(void *obj) { +Time *arg1 = (Time *) obj; +delete arg1; +} +static int _proxy__wrap_new_Time(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_Time); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_Time_attributes[] = { + { "Y", _wrap_Time_Y_get, _wrap_Time_Y_set }, + { "M", _wrap_Time_M_get, _wrap_Time_M_set }, + { "D", _wrap_Time_D_get, _wrap_Time_D_set }, + { "h", _wrap_Time_h_get, _wrap_Time_h_set }, + { "m", _wrap_Time_m_get, _wrap_Time_m_set }, + { "s", _wrap_Time_s_get, _wrap_Time_s_set }, + {0,0,0} +}; +static swig_lua_method swig_Time_methods[]= { + { "getYear", _wrap_Time_getYear}, + { "setYear", _wrap_Time_setYear}, + { "setMonth", _wrap_Time_setMonth}, + { "getMonth", _wrap_Time_getMonth}, + { "getDay", _wrap_Time_getDay}, + { "setDay", _wrap_Time_setDay}, + { "getHour", _wrap_Time_getHour}, + { "setHour", _wrap_Time_setHour}, + { "getMin", _wrap_Time_getMin}, + { "setMour", _wrap_Time_setMour}, + { "getSec", _wrap_Time_getSec}, + { "setSec", _wrap_Time_setSec}, + {0,0} +}; +static swig_lua_method swig_Time_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_Time_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_Time_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_Time_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_Time_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_Time_Sf_SwigStatic = { + "Time", + swig_Time_Sf_SwigStatic_methods, + swig_Time_Sf_SwigStatic_attributes, + swig_Time_Sf_SwigStatic_constants, + swig_Time_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_Time_bases[] = {0}; +static const char *swig_Time_base_names[] = {0}; +static swig_lua_class _wrap_class_Time = { "Time", "Time", &SWIGTYPE_p_Time,_proxy__wrap_new_Time, swig_delete_Time, swig_Time_methods, swig_Time_attributes, &swig_Time_Sf_SwigStatic, swig_Time_meta, swig_Time_bases, swig_Time_base_names }; + +static int _wrap_new_GZ__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + GZ *result = 0 ; + + SWIG_check_num_args("GZ::GZ",0,0) + result = (GZ *)new GZ(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_GZ,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_GZ__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + uint8_t arg1 ; + uint8_t arg2 ; + GZ *result = 0 ; + + SWIG_check_num_args("GZ::GZ",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("GZ::GZ",1,"uint8_t"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("GZ::GZ",2,"uint8_t"); + SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative"); + arg1 = (uint8_t)lua_tonumber(L, 1); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + result = (GZ *)new GZ(arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_GZ,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_GZ(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_GZ__SWIG_0(L); + } + if (argc == 2) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_new_GZ__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_GZ'\n" + " Possible C/C++ prototypes are:\n" + " GZ::GZ()\n" + " GZ::GZ(uint8_t,uint8_t)\n"); + lua_error(L);return 0; +} + + +static int _wrap_GZ_tg_set(lua_State* L) { + { + int SWIG_arg = 0; + GZ *arg1 = (GZ *) 0 ; + uint8_t arg2 ; + + SWIG_check_num_args("GZ::tg",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("GZ::tg",1,"GZ *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("GZ::tg",2,"uint8_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_GZ,0))){ + SWIG_fail_ptr("GZ_tg_set",1,SWIGTYPE_p_GZ); + } + + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + if (arg1) (arg1)->tg = arg2; + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_GZ_tg_get(lua_State* L) { + { + int SWIG_arg = 0; + GZ *arg1 = (GZ *) 0 ; + uint8_t result; + + SWIG_check_num_args("GZ::tg",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("GZ::tg",1,"GZ *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_GZ,0))){ + SWIG_fail_ptr("GZ_tg_get",1,SWIGTYPE_p_GZ); + } + + result = (uint8_t) ((arg1)->tg); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_GZ_dz_set(lua_State* L) { + { + int SWIG_arg = 0; + GZ *arg1 = (GZ *) 0 ; + uint8_t arg2 ; + + SWIG_check_num_args("GZ::dz",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("GZ::dz",1,"GZ *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("GZ::dz",2,"uint8_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_GZ,0))){ + SWIG_fail_ptr("GZ_dz_set",1,SWIGTYPE_p_GZ); + } + + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + if (arg1) (arg1)->dz = arg2; + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_GZ_dz_get(lua_State* L) { + { + int SWIG_arg = 0; + GZ *arg1 = (GZ *) 0 ; + uint8_t result; + + SWIG_check_num_args("GZ::dz",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("GZ::dz",1,"GZ *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_GZ,0))){ + SWIG_fail_ptr("GZ_dz_get",1,SWIGTYPE_p_GZ); + } + + result = (uint8_t) ((arg1)->dz); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_GZ(void *obj) { +GZ *arg1 = (GZ *) obj; +delete arg1; +} +static int _proxy__wrap_new_GZ(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_GZ); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_GZ_attributes[] = { + { "tg", _wrap_GZ_tg_get, _wrap_GZ_tg_set }, + { "dz", _wrap_GZ_dz_get, _wrap_GZ_dz_set }, + {0,0,0} +}; +static swig_lua_method swig_GZ_methods[]= { + {0,0} +}; +static swig_lua_method swig_GZ_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_GZ_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_GZ_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_GZ_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_GZ_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_GZ_Sf_SwigStatic = { + "GZ", + swig_GZ_Sf_SwigStatic_methods, + swig_GZ_Sf_SwigStatic_attributes, + swig_GZ_Sf_SwigStatic_constants, + swig_GZ_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_GZ_bases[] = {0}; +static const char *swig_GZ_base_names[] = {0}; +static swig_lua_class _wrap_class_GZ = { "GZ", "GZ", &SWIGTYPE_p_GZ,_proxy__wrap_new_GZ, swig_delete_GZ, swig_GZ_methods, swig_GZ_attributes, &swig_GZ_Sf_SwigStatic, swig_GZ_meta, swig_GZ_bases, swig_GZ_base_names }; + +static int _wrap_Day_fromSolar(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + + SWIG_check_num_args("Day::fromSolar",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("Day::fromSolar",1,"int"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Day::fromSolar",2,"uint8_t"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("Day::fromSolar",3,"int"); + arg1 = (int)lua_tonumber(L, 1); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + arg3 = (int)lua_tonumber(L, 3); + result = (Day *)Day::fromSolar(arg1,arg2,arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_Day,0); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_fromLunar__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + bool arg4 ; + Day *result = 0 ; + + SWIG_check_num_args("Day::fromLunar",4,4) + if(!lua_isnumber(L,1)) SWIG_fail_arg("Day::fromLunar",1,"int"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Day::fromLunar",2,"uint8_t"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("Day::fromLunar",3,"int"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("Day::fromLunar",4,"bool"); + arg1 = (int)lua_tonumber(L, 1); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + arg3 = (int)lua_tonumber(L, 3); + arg4 = (lua_toboolean(L, 4)!=0); + result = (Day *)Day::fromLunar(arg1,arg2,arg3,arg4); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_Day,0); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_fromLunar__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + + SWIG_check_num_args("Day::fromLunar",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("Day::fromLunar",1,"int"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Day::fromLunar",2,"uint8_t"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("Day::fromLunar",3,"int"); + arg1 = (int)lua_tonumber(L, 1); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + arg3 = (int)lua_tonumber(L, 3); + result = (Day *)Day::fromLunar(arg1,arg2,arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_Day,0); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_fromLunar(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_Day_fromLunar__SWIG_1(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + return _wrap_Day_fromLunar__SWIG_0(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Day_fromLunar'\n" + " Possible C/C++ prototypes are:\n" + " Day::fromLunar(int,uint8_t,int,bool)\n" + " Day::fromLunar(int,uint8_t,int)\n"); + lua_error(L);return 0; +} + + +static int _wrap_Day_after(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + int arg2 ; + Day *result = 0 ; + + SWIG_check_num_args("Day::after",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::after",1,"Day *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Day::after",2,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_after",1,SWIGTYPE_p_Day); + } + + arg2 = (int)lua_tonumber(L, 2); + result = (Day *)(arg1)->after(arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_Day,0); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_before(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + int arg2 ; + Day *result = 0 ; + + SWIG_check_num_args("Day::before",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::before",1,"Day *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Day::before",2,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_before",1,SWIGTYPE_p_Day); + } + + arg2 = (int)lua_tonumber(L, 2); + result = (Day *)(arg1)->before(arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_Day,0); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getLunarDay(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + int result; + + SWIG_check_num_args("Day::getLunarDay",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getLunarDay",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getLunarDay",1,SWIGTYPE_p_Day); + } + + result = (int)(arg1)->getLunarDay(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getLunarMonth(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + SWIG_check_num_args("Day::getLunarMonth",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getLunarMonth",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getLunarMonth",1,SWIGTYPE_p_Day); + } + + result = (uint8_t)(arg1)->getLunarMonth(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getLunarYear__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + bool arg2 ; + int result; + + SWIG_check_num_args("Day::getLunarYear",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getLunarYear",1,"Day *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("Day::getLunarYear",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getLunarYear",1,SWIGTYPE_p_Day); + } + + arg2 = (lua_toboolean(L, 2)!=0); + result = (int)(arg1)->getLunarYear(arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getLunarYear__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + int result; + + SWIG_check_num_args("Day::getLunarYear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getLunarYear",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getLunarYear",1,SWIGTYPE_p_Day); + } + + result = (int)(arg1)->getLunarYear(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getLunarYear(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Day, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Day_getLunarYear__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Day, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_Day_getLunarYear__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Day_getLunarYear'\n" + " Possible C/C++ prototypes are:\n" + " Day::getLunarYear(bool)\n" + " Day::getLunarYear()\n"); + lua_error(L);return 0; +} + + +static int _wrap_Day_getYearGZ__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + bool arg2 ; + GZ result; + + SWIG_check_num_args("Day::getYearGZ",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getYearGZ",1,"Day *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("Day::getYearGZ",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getYearGZ",1,SWIGTYPE_p_Day); + } + + arg2 = (lua_toboolean(L, 2)!=0); + result = (arg1)->getYearGZ(arg2); + { + GZ * resultptr = new GZ(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_GZ,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getYearGZ__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + GZ result; + + SWIG_check_num_args("Day::getYearGZ",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getYearGZ",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getYearGZ",1,SWIGTYPE_p_Day); + } + + result = (arg1)->getYearGZ(); + { + GZ * resultptr = new GZ(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_GZ,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getYearGZ(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Day, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Day_getYearGZ__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Day, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_Day_getYearGZ__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Day_getYearGZ'\n" + " Possible C/C++ prototypes are:\n" + " Day::getYearGZ(bool)\n" + " Day::getYearGZ()\n"); + lua_error(L);return 0; +} + + +static int _wrap_Day_getMonthGZ(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + GZ result; + + SWIG_check_num_args("Day::getMonthGZ",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getMonthGZ",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getMonthGZ",1,SWIGTYPE_p_Day); + } + + result = (arg1)->getMonthGZ(); + { + GZ * resultptr = new GZ(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_GZ,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getDayGZ(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + GZ result; + + SWIG_check_num_args("Day::getDayGZ",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getDayGZ",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getDayGZ",1,SWIGTYPE_p_Day); + } + + result = (arg1)->getDayGZ(); + { + GZ * resultptr = new GZ(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_GZ,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getHourGZ__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + uint8_t arg2 ; + bool arg3 ; + GZ result; + + SWIG_check_num_args("Day::getHourGZ",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getHourGZ",1,"Day *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Day::getHourGZ",2,"uint8_t"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("Day::getHourGZ",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getHourGZ",1,SWIGTYPE_p_Day); + } + + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + result = (arg1)->getHourGZ(arg2,arg3); + { + GZ * resultptr = new GZ(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_GZ,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getHourGZ__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + uint8_t arg2 ; + GZ result; + + SWIG_check_num_args("Day::getHourGZ",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getHourGZ",1,"Day *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("Day::getHourGZ",2,"uint8_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getHourGZ",1,SWIGTYPE_p_Day); + } + + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + result = (arg1)->getHourGZ(arg2); + { + GZ * resultptr = new GZ(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_GZ,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getHourGZ(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Day, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_Day_getHourGZ__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Day, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_Day_getHourGZ__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Day_getHourGZ'\n" + " Possible C/C++ prototypes are:\n" + " Day::getHourGZ(uint8_t,bool)\n" + " Day::getHourGZ(uint8_t)\n"); + lua_error(L);return 0; +} + + +static int _wrap_Day_isLunarLeap(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + bool result; + + SWIG_check_num_args("Day::isLunarLeap",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::isLunarLeap",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_isLunarLeap",1,SWIGTYPE_p_Day); + } + + result = (bool)(arg1)->isLunarLeap(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getSolarYear(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + int result; + + SWIG_check_num_args("Day::getSolarYear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getSolarYear",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getSolarYear",1,SWIGTYPE_p_Day); + } + + result = (int)(arg1)->getSolarYear(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getSolarMonth(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + SWIG_check_num_args("Day::getSolarMonth",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getSolarMonth",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getSolarMonth",1,SWIGTYPE_p_Day); + } + + result = (uint8_t)(arg1)->getSolarMonth(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getSolarDay(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + int result; + + SWIG_check_num_args("Day::getSolarDay",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getSolarDay",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getSolarDay",1,SWIGTYPE_p_Day); + } + + result = (int)(arg1)->getSolarDay(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getWeek(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + SWIG_check_num_args("Day::getWeek",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getWeek",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getWeek",1,SWIGTYPE_p_Day); + } + + result = (uint8_t)(arg1)->getWeek(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getWeekIndex(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + SWIG_check_num_args("Day::getWeekIndex",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getWeekIndex",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getWeekIndex",1,SWIGTYPE_p_Day); + } + + result = (uint8_t)(arg1)->getWeekIndex(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_hasJieQi(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + bool result; + + SWIG_check_num_args("Day::hasJieQi",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::hasJieQi",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_hasJieQi",1,SWIGTYPE_p_Day); + } + + result = (bool)(arg1)->hasJieQi(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getJieQi(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + SWIG_check_num_args("Day::getJieQi",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getJieQi",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getJieQi",1,SWIGTYPE_p_Day); + } + + result = (uint8_t)(arg1)->getJieQi(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getJieQiJD(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + double result; + + SWIG_check_num_args("Day::getJieQiJD",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getJieQiJD",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getJieQiJD",1,SWIGTYPE_p_Day); + } + + result = (double)(arg1)->getJieQiJD(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_Day_getConstellation(lua_State* L) { + { + int SWIG_arg = 0; + Day *arg1 = (Day *) 0 ; + uint8_t result; + + SWIG_check_num_args("Day::getConstellation",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Day::getConstellation",1,"Day *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Day,0))){ + SWIG_fail_ptr("Day_getConstellation",1,SWIGTYPE_p_Day); + } + + result = (uint8_t)(arg1)->getConstellation(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_Day(void *obj) { +Day *arg1 = (Day *) obj; +delete arg1; +} +static swig_lua_attribute swig_Day_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_Day_methods[]= { + { "after", _wrap_Day_after}, + { "before", _wrap_Day_before}, + { "getLunarDay", _wrap_Day_getLunarDay}, + { "getLunarMonth", _wrap_Day_getLunarMonth}, + { "getLunarYear", _wrap_Day_getLunarYear}, + { "getYearGZ", _wrap_Day_getYearGZ}, + { "getMonthGZ", _wrap_Day_getMonthGZ}, + { "getDayGZ", _wrap_Day_getDayGZ}, + { "getHourGZ", _wrap_Day_getHourGZ}, + { "isLunarLeap", _wrap_Day_isLunarLeap}, + { "getSolarYear", _wrap_Day_getSolarYear}, + { "getSolarMonth", _wrap_Day_getSolarMonth}, + { "getSolarDay", _wrap_Day_getSolarDay}, + { "getWeek", _wrap_Day_getWeek}, + { "getWeekIndex", _wrap_Day_getWeekIndex}, + { "hasJieQi", _wrap_Day_hasJieQi}, + { "getJieQi", _wrap_Day_getJieQi}, + { "getJieQiJD", _wrap_Day_getJieQiJD}, + { "getConstellation", _wrap_Day_getConstellation}, + {0,0} +}; +static swig_lua_method swig_Day_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_Day_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_Day_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_Day_Sf_SwigStatic_methods[]= { + { "fromSolar", _wrap_Day_fromSolar}, + { "fromLunar", _wrap_Day_fromLunar}, + {0,0} +}; +static swig_lua_class* swig_Day_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_Day_Sf_SwigStatic = { + "Day", + swig_Day_Sf_SwigStatic_methods, + swig_Day_Sf_SwigStatic_attributes, + swig_Day_Sf_SwigStatic_constants, + swig_Day_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_Day_bases[] = {0}; +static const char *swig_Day_base_names[] = {0}; +static swig_lua_class _wrap_class_Day = { "Day", "Day", &SWIGTYPE_p_Day,0, swig_delete_Day, swig_Day_methods, swig_Day_attributes, &swig_Day_Sf_SwigStatic, swig_Day_meta, swig_Day_bases, swig_Day_base_names }; + +static int _wrap_JieQiInfo_jd_set(lua_State* L) { + { + int SWIG_arg = 0; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + double arg2 ; + + SWIG_check_num_args("sxtwl::JieQiInfo::jd",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("sxtwl::JieQiInfo::jd",1,"sxtwl::JieQiInfo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("sxtwl::JieQiInfo::jd",2,"double"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_sxtwl__JieQiInfo,0))){ + SWIG_fail_ptr("JieQiInfo_jd_set",1,SWIGTYPE_p_sxtwl__JieQiInfo); + } + + arg2 = (double)lua_tonumber(L, 2); + if (arg1) (arg1)->jd = arg2; + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JieQiInfo_jd_get(lua_State* L) { + { + int SWIG_arg = 0; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + double result; + + SWIG_check_num_args("sxtwl::JieQiInfo::jd",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("sxtwl::JieQiInfo::jd",1,"sxtwl::JieQiInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_sxtwl__JieQiInfo,0))){ + SWIG_fail_ptr("JieQiInfo_jd_get",1,SWIGTYPE_p_sxtwl__JieQiInfo); + } + + result = (double) ((arg1)->jd); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JieQiInfo_jqIndex_set(lua_State* L) { + { + int SWIG_arg = 0; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + uint8_t arg2 ; + + SWIG_check_num_args("sxtwl::JieQiInfo::jqIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("sxtwl::JieQiInfo::jqIndex",1,"sxtwl::JieQiInfo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("sxtwl::JieQiInfo::jqIndex",2,"uint8_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_sxtwl__JieQiInfo,0))){ + SWIG_fail_ptr("JieQiInfo_jqIndex_set",1,SWIGTYPE_p_sxtwl__JieQiInfo); + } + + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + if (arg1) (arg1)->jqIndex = arg2; + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_JieQiInfo_jqIndex_get(lua_State* L) { + { + int SWIG_arg = 0; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + uint8_t result; + + SWIG_check_num_args("sxtwl::JieQiInfo::jqIndex",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("sxtwl::JieQiInfo::jqIndex",1,"sxtwl::JieQiInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_sxtwl__JieQiInfo,0))){ + SWIG_fail_ptr("JieQiInfo_jqIndex_get",1,SWIGTYPE_p_sxtwl__JieQiInfo); + } + + result = (uint8_t) ((arg1)->jqIndex); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_JieQiInfo(lua_State* L) { + { + int SWIG_arg = 0; + sxtwl::JieQiInfo *result = 0 ; + + SWIG_check_num_args("sxtwl::JieQiInfo::JieQiInfo",0,0) + result = (sxtwl::JieQiInfo *)new sxtwl::JieQiInfo(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_sxtwl__JieQiInfo,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_JieQiInfo(void *obj) { +sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) obj; +delete arg1; +} +static int _proxy__wrap_new_JieQiInfo(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_JieQiInfo); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_JieQiInfo_attributes[] = { + { "jd", _wrap_JieQiInfo_jd_get, _wrap_JieQiInfo_jd_set }, + { "jqIndex", _wrap_JieQiInfo_jqIndex_get, _wrap_JieQiInfo_jqIndex_set }, + {0,0,0} +}; +static swig_lua_method swig_JieQiInfo_methods[]= { + {0,0} +}; +static swig_lua_method swig_JieQiInfo_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_JieQiInfo_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_JieQiInfo_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_JieQiInfo_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_JieQiInfo_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_JieQiInfo_Sf_SwigStatic = { + "JieQiInfo", + swig_JieQiInfo_Sf_SwigStatic_methods, + swig_JieQiInfo_Sf_SwigStatic_attributes, + swig_JieQiInfo_Sf_SwigStatic_constants, + swig_JieQiInfo_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_JieQiInfo_bases[] = {0}; +static const char *swig_JieQiInfo_base_names[] = {0}; +static swig_lua_class _wrap_class_JieQiInfo = { "JieQiInfo", "JieQiInfo", &SWIGTYPE_p_sxtwl__JieQiInfo,_proxy__wrap_new_JieQiInfo, swig_delete_JieQiInfo, swig_JieQiInfo_methods, swig_JieQiInfo_attributes, &swig_JieQiInfo_Sf_SwigStatic, swig_JieQiInfo_meta, swig_JieQiInfo_bases, swig_JieQiInfo_base_names }; + +static int _wrap_fromSolar(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + + SWIG_check_num_args("sxtwl::fromSolar",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("sxtwl::fromSolar",1,"int"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("sxtwl::fromSolar",2,"uint8_t"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("sxtwl::fromSolar",3,"int"); + arg1 = (int)lua_tonumber(L, 1); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + arg3 = (int)lua_tonumber(L, 3); + result = (Day *)sxtwl::fromSolar(arg1,arg2,arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_Day,0); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_fromLunar__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + bool arg4 ; + Day *result = 0 ; + + SWIG_check_num_args("sxtwl::fromLunar",4,4) + if(!lua_isnumber(L,1)) SWIG_fail_arg("sxtwl::fromLunar",1,"int"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("sxtwl::fromLunar",2,"uint8_t"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("sxtwl::fromLunar",3,"int"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("sxtwl::fromLunar",4,"bool"); + arg1 = (int)lua_tonumber(L, 1); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + arg3 = (int)lua_tonumber(L, 3); + arg4 = (lua_toboolean(L, 4)!=0); + result = (Day *)sxtwl::fromLunar(arg1,arg2,arg3,arg4); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_Day,0); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_fromLunar__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + Day *result = 0 ; + + SWIG_check_num_args("sxtwl::fromLunar",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("sxtwl::fromLunar",1,"int"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("sxtwl::fromLunar",2,"uint8_t"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("sxtwl::fromLunar",3,"int"); + arg1 = (int)lua_tonumber(L, 1); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + arg3 = (int)lua_tonumber(L, 3); + result = (Day *)sxtwl::fromLunar(arg1,arg2,arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_Day,0); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_fromLunar(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_fromLunar__SWIG_1(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + return _wrap_fromLunar__SWIG_0(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'fromLunar'\n" + " Possible C/C++ prototypes are:\n" + " sxtwl::fromLunar(int,uint8_t,int,bool)\n" + " sxtwl::fromLunar(int,uint8_t,int)\n"); + lua_error(L);return 0; +} + + +static int _wrap_siZhu2Year(lua_State* L) { + { + int SWIG_arg = 0; + GZ arg1 ; + GZ arg2 ; + GZ arg3 ; + GZ arg4 ; + int arg5 ; + int arg6 ; + GZ *argp1 ; + GZ *argp2 ; + GZ *argp3 ; + GZ *argp4 ; + std::vector< double > result; + + SWIG_check_num_args("sxtwl::siZhu2Year",6,6) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("sxtwl::siZhu2Year",1,"GZ"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("sxtwl::siZhu2Year",2,"GZ"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("sxtwl::siZhu2Year",3,"GZ"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("sxtwl::siZhu2Year",4,"GZ"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("sxtwl::siZhu2Year",5,"int"); + if(!lua_isnumber(L,6)) SWIG_fail_arg("sxtwl::siZhu2Year",6,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_GZ,0))){ + SWIG_fail_ptr("siZhu2Year",1,SWIGTYPE_p_GZ); + } + arg1 = *argp1; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GZ,0))){ + SWIG_fail_ptr("siZhu2Year",2,SWIGTYPE_p_GZ); + } + arg2 = *argp2; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_GZ,0))){ + SWIG_fail_ptr("siZhu2Year",3,SWIGTYPE_p_GZ); + } + arg3 = *argp3; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GZ,0))){ + SWIG_fail_ptr("siZhu2Year",4,SWIGTYPE_p_GZ); + } + arg4 = *argp4; + + arg5 = (int)lua_tonumber(L, 5); + arg6 = (int)lua_tonumber(L, 6); + result = sxtwl::siZhu2Year(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,arg6); + { + std::vector< double > * resultptr = new std::vector< double >(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_double_t,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_getShiGz__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + uint8_t arg1 ; + uint8_t arg2 ; + bool arg3 ; + GZ result; + + SWIG_check_num_args("sxtwl::getShiGz",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("sxtwl::getShiGz",1,"uint8_t"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("sxtwl::getShiGz",2,"uint8_t"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("sxtwl::getShiGz",3,"bool"); + SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative"); + arg1 = (uint8_t)lua_tonumber(L, 1); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + result = sxtwl::getShiGz(arg1,arg2,arg3); + { + GZ * resultptr = new GZ(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_GZ,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_getShiGz__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + uint8_t arg1 ; + uint8_t arg2 ; + GZ result; + + SWIG_check_num_args("sxtwl::getShiGz",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("sxtwl::getShiGz",1,"uint8_t"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("sxtwl::getShiGz",2,"uint8_t"); + SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative"); + arg1 = (uint8_t)lua_tonumber(L, 1); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + result = sxtwl::getShiGz(arg1,arg2); + { + GZ * resultptr = new GZ(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_GZ,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_getShiGz(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_getShiGz__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_getShiGz__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getShiGz'\n" + " Possible C/C++ prototypes are:\n" + " sxtwl::getShiGz(uint8_t,uint8_t,bool)\n" + " sxtwl::getShiGz(uint8_t,uint8_t)\n"); + lua_error(L);return 0; +} + + +static int _wrap_getRunMonth(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + uint8_t result; + + SWIG_check_num_args("sxtwl::getRunMonth",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("sxtwl::getRunMonth",1,"int"); + arg1 = (int)lua_tonumber(L, 1); + result = (uint8_t)sxtwl::getRunMonth(arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_getLunarMonthNum__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + uint8_t arg2 ; + bool arg3 ; + uint8_t result; + + SWIG_check_num_args("sxtwl::getLunarMonthNum",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("sxtwl::getLunarMonthNum",1,"int"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("sxtwl::getLunarMonthNum",2,"uint8_t"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("sxtwl::getLunarMonthNum",3,"bool"); + arg1 = (int)lua_tonumber(L, 1); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + result = (uint8_t)sxtwl::getLunarMonthNum(arg1,arg2,arg3); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_getLunarMonthNum__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + uint8_t arg2 ; + uint8_t result; + + SWIG_check_num_args("sxtwl::getLunarMonthNum",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("sxtwl::getLunarMonthNum",1,"int"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("sxtwl::getLunarMonthNum",2,"uint8_t"); + arg1 = (int)lua_tonumber(L, 1); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative"); + arg2 = (uint8_t)lua_tonumber(L, 2); + result = (uint8_t)sxtwl::getLunarMonthNum(arg1,arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_getLunarMonthNum(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_getLunarMonthNum__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_getLunarMonthNum__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getLunarMonthNum'\n" + " Possible C/C++ prototypes are:\n" + " sxtwl::getLunarMonthNum(int,uint8_t,bool)\n" + " sxtwl::getLunarMonthNum(int,uint8_t)\n"); + lua_error(L);return 0; +} + + +static int _wrap_JD2DD(lua_State* L) { + { + int SWIG_arg = 0; + double arg1 ; + Time result; + + SWIG_check_num_args("sxtwl::JD2DD",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("sxtwl::JD2DD",1,"double"); + arg1 = (double)lua_tonumber(L, 1); + result = sxtwl::JD2DD(arg1); + { + Time * resultptr = new Time(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Time,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_toJD(lua_State* L) { + { + int SWIG_arg = 0; + Time *arg1 = 0 ; + double result; + + SWIG_check_num_args("sxtwl::toJD",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("sxtwl::toJD",1,"Time &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Time,0))){ + SWIG_fail_ptr("toJD",1,SWIGTYPE_p_Time); + } + + result = (double)sxtwl::toJD(*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_getJieQiByYear(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + std::vector< sxtwl::JieQiInfo > result; + + SWIG_check_num_args("sxtwl::getJieQiByYear",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("sxtwl::getJieQiByYear",1,"int"); + arg1 = (int)lua_tonumber(L, 1); + result = sxtwl::getJieQiByYear(arg1); + { + std::vector< sxtwl::JieQiInfo > * resultptr = new std::vector< sxtwl::JieQiInfo >(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static swig_lua_attribute swig_SwigModule_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SwigModule_constants[]= { + {SWIG_LUA_CONSTTAB_INT("J2000", 2451545)}, + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SwigModule_methods[]= { + { "Day_fromSolar", _wrap_Day_fromSolar}, + { "Day_fromLunar", _wrap_Day_fromLunar}, + { "fromSolar", _wrap_fromSolar}, + { "fromLunar", _wrap_fromLunar}, + { "siZhu2Year", _wrap_siZhu2Year}, + { "getShiGz", _wrap_getShiGz}, + { "getRunMonth", _wrap_getRunMonth}, + { "getLunarMonthNum", _wrap_getLunarMonthNum}, + { "JD2DD", _wrap_JD2DD}, + { "toJD", _wrap_toJD}, + { "getJieQiByYear", _wrap_getJieQiByYear}, + {0,0} +}; +static swig_lua_class* swig_SwigModule_classes[]= { +&_wrap_class_string, +&_wrap_class_JDList, +&_wrap_class_JQList, +&_wrap_class_Time, +&_wrap_class_GZ, +&_wrap_class_Day, +&_wrap_class_JieQiInfo, + 0 +}; +static swig_lua_namespace* swig_SwigModule_namespaces[] = { + 0 +}; + +static swig_lua_namespace swig_SwigModule = { + "sxtwl", + swig_SwigModule_methods, + swig_SwigModule_attributes, + swig_SwigModule_constants, + swig_SwigModule_classes, + swig_SwigModule_namespaces +}; +#ifdef __cplusplus +} +#endif + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static swig_type_info _swigt__p_Day = {"_p_Day", "Day *", 0, 0, (void*)&_wrap_class_Day, 0}; +static swig_type_info _swigt__p_GZ = {"_p_GZ", "GZ *", 0, 0, (void*)&_wrap_class_GZ, 0}; +static swig_type_info _swigt__p_Time = {"_p_Time", "Time *", 0, 0, (void*)&_wrap_class_Time, 0}; +static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 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_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_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)&_wrap_class_string, 0}; +static swig_type_info _swigt__p_std__vectorT_double_t = {"_p_std__vectorT_double_t", "std::vector< double > *", 0, 0, (void*)&_wrap_class_JDList, 0}; +static swig_type_info _swigt__p_std__vectorT_sxtwl__JieQiInfo_t = {"_p_std__vectorT_sxtwl__JieQiInfo_t", "std::vector< sxtwl::JieQiInfo > *", 0, 0, (void*)&_wrap_class_JQList, 0}; +static swig_type_info _swigt__p_sxtwl__JieQiInfo = {"_p_sxtwl__JieQiInfo", "sxtwl::JieQiInfo *", 0, 0, (void*)&_wrap_class_JieQiInfo, 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 _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_Day, + &_swigt__p_GZ, + &_swigt__p_Time, + &_swigt__p_difference_type, + &_swigt__p_int, + &_swigt__p_long_long, + &_swigt__p_short, + &_swigt__p_signed_char, + &_swigt__p_size_type, + &_swigt__p_std__string, + &_swigt__p_std__vectorT_double_t, + &_swigt__p_std__vectorT_sxtwl__JieQiInfo_t, + &_swigt__p_sxtwl__JieQiInfo, + &_swigt__p_unsigned_char, + &_swigt__p_unsigned_int, + &_swigt__p_unsigned_long_long, + &_swigt__p_unsigned_short, + &_swigt__p_value_type, +}; + +static swig_cast_info _swigc__p_Day[] = { {&_swigt__p_Day, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_GZ[] = { {&_swigt__p_GZ, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_Time[] = { {&_swigt__p_Time, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 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_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_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_double_t[] = { {&_swigt__p_std__vectorT_double_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_sxtwl__JieQiInfo_t[] = { {&_swigt__p_std__vectorT_sxtwl__JieQiInfo_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sxtwl__JieQiInfo[] = { {&_swigt__p_sxtwl__JieQiInfo, 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 _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_Day, + _swigc__p_GZ, + _swigc__p_Time, + _swigc__p_difference_type, + _swigc__p_int, + _swigc__p_long_long, + _swigc__p_short, + _swigc__p_signed_char, + _swigc__p_size_type, + _swigc__p_std__string, + _swigc__p_std__vectorT_double_t, + _swigc__p_std__vectorT_sxtwl__JieQiInfo_t, + _swigc__p_sxtwl__JieQiInfo, + _swigc__p_unsigned_char, + _swigc__p_unsigned_int, + _swigc__p_unsigned_long_long, + _swigc__p_unsigned_short, + _swigc__p_value_type, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +/* ----------------------------------------------------------------------------- + * 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 + + + +/* Forward declaration of where the user's %init{} gets inserted */ +void SWIG_init_user(lua_State* L ); + +#ifdef __cplusplus +extern "C" { +#endif +/* this is the initialization function + added at the very end of the code + the function is always called SWIG_init, but an earlier #define will rename it +*/ +#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)) +LUALIB_API int SWIG_init(lua_State* L) +#else +SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */ +#endif +{ +#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */ + int i; + int globalRegister = 0; + /* start with global table */ + lua_pushglobaltable (L); + /* SWIG's internal initialisation */ + SWIG_InitializeModule((void*)L); + SWIG_PropagateClientData(); +#endif + +#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) || defined(SWIG_LUA_ELUA_EMULATE) + /* add a global fn */ + SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type); + SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_class_equal); +#endif + +#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) + /* set up base class pointers (the hierarchy) */ + for (i = 0; swig_types[i]; i++){ + if (swig_types[i]->clientdata){ + SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata)); + } + } +#ifdef SWIG_LUA_MODULE_GLOBAL + globalRegister = 1; +#endif + + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + SWIG_Lua_namespace_register(L,&swig_SwigModule, globalRegister); +#endif + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) + for (i = 0; swig_types[i]; i++){ + if (swig_types[i]->clientdata){ + SWIG_Lua_elua_class_register_instance(L,(swig_lua_class*)(swig_types[i]->clientdata)); + } + } +#endif + +#if defined(SWIG_LUA_ELUA_EMULATE) + lua_newtable(L); + SWIG_Lua_elua_emulate_register(L,swig_SwigModule.ns_methods); + SWIG_Lua_elua_emulate_register_clear(L); + if(globalRegister) { + lua_pushstring(L,swig_SwigModule.name); + lua_pushvalue(L,-2); + lua_rawset(L,-4); + } +#endif + +#endif + +#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) + /* invoke user-specific initialization */ + SWIG_init_user(L); + /* end module */ + /* Note: We do not clean up the stack here (Lua will do this for us). At this + point, we have the globals table and out module table on the stack. Returning + one value makes the module table the result of the require command. */ + return 1; +#else + return 0; +#endif +} + +#ifdef __cplusplus +} +#endif + + +const char* SWIG_LUACODE= + ""; + +void SWIG_init_user(lua_State* L) +{ + /* exec Lua code if applicable */ + SWIG_Lua_dostring(L,SWIG_LUACODE); +} + diff --git a/export/php7/php_sxtwl.h b/export/php7/php_sxtwl.h new file mode 100644 index 0000000..c05048e --- /dev/null +++ b/export/php7/php_sxtwl.h @@ -0,0 +1,126 @@ +/* ---------------------------------------------------------------------------- + * 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. + * ----------------------------------------------------------------------------- */ + +#ifndef PHP_SXTWL_H +#define PHP_SXTWL_H + +extern zend_module_entry sxtwl_module_entry; +#define phpext_sxtwl_ptr &sxtwl_module_entry + +#ifdef PHP_WIN32 +# define PHP_SXTWL_API __declspec(dllexport) +#else +# define PHP_SXTWL_API +#endif + +static PHP_METHOD(JDList,__construct); +static PHP_METHOD(JDList,size); +static PHP_METHOD(JDList,capacity); +static PHP_METHOD(JDList,reserve); +static PHP_METHOD(JDList,clear); +static PHP_METHOD(JDList,push); +static PHP_METHOD(JDList,is_empty); +static PHP_METHOD(JDList,pop); +static PHP_METHOD(JDList,get); +static PHP_METHOD(JDList,set); +PHP_METHOD(JDList,__set); +PHP_METHOD(JDList,__get); +PHP_METHOD(JDList,__isset); +static PHP_METHOD(JQList,__construct); +static PHP_METHOD(JQList,size); +static PHP_METHOD(JQList,capacity); +static PHP_METHOD(JQList,reserve); +static PHP_METHOD(JQList,clear); +static PHP_METHOD(JQList,push); +static PHP_METHOD(JQList,is_empty); +static PHP_METHOD(JQList,pop); +static PHP_METHOD(JQList,get); +static PHP_METHOD(JQList,set); +PHP_METHOD(JQList,__set); +PHP_METHOD(JQList,__get); +PHP_METHOD(JQList,__isset); +static PHP_METHOD(Time,__construct); +static PHP_METHOD(Time,Y_set); +static PHP_METHOD(Time,Y_get); +static PHP_METHOD(Time,M_set); +static PHP_METHOD(Time,M_get); +static PHP_METHOD(Time,D_set); +static PHP_METHOD(Time,D_get); +static PHP_METHOD(Time,h_set); +static PHP_METHOD(Time,h_get); +static PHP_METHOD(Time,m_set); +static PHP_METHOD(Time,m_get); +static PHP_METHOD(Time,s_set); +static PHP_METHOD(Time,s_get); +static PHP_METHOD(Time,getYear); +static PHP_METHOD(Time,setYear); +static PHP_METHOD(Time,setMonth); +static PHP_METHOD(Time,getMonth); +static PHP_METHOD(Time,getDay); +static PHP_METHOD(Time,setDay); +static PHP_METHOD(Time,getHour); +static PHP_METHOD(Time,setHour); +static PHP_METHOD(Time,getMin); +static PHP_METHOD(Time,setMour); +static PHP_METHOD(Time,getSec); +static PHP_METHOD(Time,setSec); +PHP_METHOD(Time,__set); +PHP_METHOD(Time,__get); +PHP_METHOD(Time,__isset); +static PHP_METHOD(GZ,__construct); +static PHP_METHOD(GZ,tg_set); +static PHP_METHOD(GZ,tg_get); +static PHP_METHOD(GZ,dz_set); +static PHP_METHOD(GZ,dz_get); +PHP_METHOD(GZ,__set); +PHP_METHOD(GZ,__get); +PHP_METHOD(GZ,__isset); +static PHP_METHOD(Day,fromSolar); +static PHP_METHOD(Day,fromLunar); +static PHP_METHOD(Day,after); +static PHP_METHOD(Day,before); +static PHP_METHOD(Day,getLunarDay); +static PHP_METHOD(Day,getLunarMonth); +static PHP_METHOD(Day,getLunarYear); +static PHP_METHOD(Day,getYearGZ); +static PHP_METHOD(Day,getMonthGZ); +static PHP_METHOD(Day,getDayGZ); +static PHP_METHOD(Day,getHourGZ); +static PHP_METHOD(Day,isLunarLeap); +static PHP_METHOD(Day,getSolarYear); +static PHP_METHOD(Day,getSolarMonth); +static PHP_METHOD(Day,getSolarDay); +static PHP_METHOD(Day,getWeek); +static PHP_METHOD(Day,getWeekIndex); +static PHP_METHOD(Day,hasJieQi); +static PHP_METHOD(Day,getJieQi); +static PHP_METHOD(Day,getJieQiJD); +static PHP_METHOD(Day,getConstellation); +PHP_METHOD(Day,__set); +PHP_METHOD(Day,__get); +PHP_METHOD(Day,__isset); +static PHP_METHOD(JieQiInfo,jd_set); +static PHP_METHOD(JieQiInfo,jd_get); +static PHP_METHOD(JieQiInfo,jqIndex_set); +static PHP_METHOD(JieQiInfo,jqIndex_get); +static PHP_METHOD(JieQiInfo,__construct); +PHP_METHOD(JieQiInfo,__set); +PHP_METHOD(JieQiInfo,__get); +PHP_METHOD(JieQiInfo,__isset); +static PHP_FUNCTION(fromSolar); +static ZEND_NAMED_FUNCTION(_wrap_fromLunar); +static PHP_FUNCTION(siZhu2Year); +static ZEND_NAMED_FUNCTION(_wrap_getShiGz); +static PHP_FUNCTION(getRunMonth); +static ZEND_NAMED_FUNCTION(_wrap_getLunarMonthNum); +static PHP_FUNCTION(JD2DD); +static PHP_FUNCTION(toJD); +static PHP_FUNCTION(getJieQiByYear); +PHP_MINIT_FUNCTION(sxtwl); + +#endif /* PHP_SXTWL_H */ diff --git a/export/php7/sxtwl.php b/export/php7/sxtwl.php new file mode 100644 index 0000000..c62ea6a --- /dev/null +++ b/export/php7/sxtwl.php @@ -0,0 +1,436 @@ +_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_sxtwl_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($n_or_other=null) { + if (is_resource($n_or_other) && get_resource_type($n_or_other) === '_p_std__vectorT_double_t') { + $this->_cPtr=$n_or_other; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_JDList(); break; + default: $this->_cPtr=new_JDList($n_or_other); + } + } + + function size() { + return JDList_size($this->_cPtr); + } + + function capacity() { + return JDList_capacity($this->_cPtr); + } + + function reserve($n) { + JDList_reserve($this->_cPtr,$n); + } + + function clear() { + JDList_clear($this->_cPtr); + } + + function push($x) { + JDList_push($this->_cPtr,$x); + } + + function is_empty() { + return JDList_is_empty($this->_cPtr); + } + + function pop() { + return JDList_pop($this->_cPtr); + } + + function get($i) { + return JDList_get($this->_cPtr,$i); + } + + function set($i,$val) { + JDList_set($this->_cPtr,$i,$val); + } +} + +class Time { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + $func = 'Time_'.$var.'_set'; + if (function_exists($func)) return call_user_func($func,$this->_cPtr,$value); + if ($var === 'thisown') return swig_sxtwl_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + $func = 'Time_'.$var.'_get'; + if (function_exists($func)) return call_user_func($func,$this->_cPtr); + if ($var === 'thisown') return swig_sxtwl_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if (function_exists('Time_'.$var.'_get')) return true; + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($year=null,$month=null,$day=null,$hour=null,$min=null,$sec=null) { + if (is_resource($year) && get_resource_type($year) === '_p_Time') { + $this->_cPtr=$year; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_Time(); break; + case 1: $this->_cPtr=new_Time($year); break; + case 2: $this->_cPtr=new_Time($year,$month); break; + case 3: $this->_cPtr=new_Time($year,$month,$day); break; + case 4: $this->_cPtr=new_Time($year,$month,$day,$hour); break; + case 5: $this->_cPtr=new_Time($year,$month,$day,$hour,$min); break; + default: $this->_cPtr=new_Time($year,$month,$day,$hour,$min,$sec); + } + } + + function getYear() { + return Time_getYear($this->_cPtr); + } + + function setYear($year) { + Time_setYear($this->_cPtr,$year); + } + + function setMonth($month) { + Time_setMonth($this->_cPtr,$month); + } + + function getMonth() { + return Time_getMonth($this->_cPtr); + } + + function getDay() { + return Time_getDay($this->_cPtr); + } + + function setDay($day) { + Time_setDay($this->_cPtr,$day); + } + + function getHour() { + return Time_getHour($this->_cPtr); + } + + function setHour($hour) { + Time_setHour($this->_cPtr,$hour); + } + + function getMin() { + return Time_getMin($this->_cPtr); + } + + function setMour($min) { + Time_setMour($this->_cPtr,$min); + } + + function getSec() { + return Time_getSec($this->_cPtr); + } + + function setSec($sec) { + Time_setSec($this->_cPtr,$sec); + } +} + +class GZ { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'tg') return GZ_tg_set($this->_cPtr,$value); + if ($var === 'dz') return GZ_dz_set($this->_cPtr,$value); + if ($var === 'thisown') return swig_sxtwl_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'tg') return GZ_tg_get($this->_cPtr); + if ($var === 'dz') return GZ_dz_get($this->_cPtr); + if ($var === 'thisown') return swig_sxtwl_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if (function_exists('GZ_'.$var.'_get')) return true; + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($tg=null,$dz=null) { + if (is_resource($tg) && get_resource_type($tg) === '_p_GZ') { + $this->_cPtr=$tg; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_GZ(); break; + case 1: $this->_cPtr=new_GZ($tg); break; + default: $this->_cPtr=new_GZ($tg,$dz); + } + } +} + +class Day { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_sxtwl_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_sxtwl_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + static function fromSolar($_year,$_month,$_day) { + $r=Day_fromSolar($_year,$_month,$_day); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Day($r); + } + return $r; + } + + static function fromLunar($year,$month,$day,$isRun=false) { + $r=Day_fromLunar($year,$month,$day,$isRun); + if (!is_resource($r)) return $r; + return new Day($r); + } + + function after($day) { + $r=Day_after($this->_cPtr,$day); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Day($r); + } + return $r; + } + + function before($day) { + $r=Day_before($this->_cPtr,$day); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Day($r); + } + return $r; + } + + function getLunarDay() { + return Day_getLunarDay($this->_cPtr); + } + + function getLunarMonth() { + return Day_getLunarMonth($this->_cPtr); + } + + function getLunarYear($chineseNewYearBoundary=true) { + return Day_getLunarYear($this->_cPtr,$chineseNewYearBoundary); + } + + function getYearGZ($chineseNewYearBoundary=false) { + $r=Day_getYearGZ($this->_cPtr,$chineseNewYearBoundary); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new GZ($r); + } + return $r; + } + + function getMonthGZ() { + $r=Day_getMonthGZ($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new GZ($r); + } + return $r; + } + + function getDayGZ() { + $r=Day_getDayGZ($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new GZ($r); + } + return $r; + } + + function getHourGZ($hour,$isZaoWanZiShi=true) { + $r=Day_getHourGZ($this->_cPtr,$hour,$isZaoWanZiShi); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new GZ($r); + } + return $r; + } + + function isLunarLeap() { + return Day_isLunarLeap($this->_cPtr); + } + + function getSolarYear() { + return Day_getSolarYear($this->_cPtr); + } + + function getSolarMonth() { + return Day_getSolarMonth($this->_cPtr); + } + + function getSolarDay() { + return Day_getSolarDay($this->_cPtr); + } + + function getWeek() { + return Day_getWeek($this->_cPtr); + } + + function getWeekIndex() { + return Day_getWeekIndex($this->_cPtr); + } + + function hasJieQi() { + return Day_hasJieQi($this->_cPtr); + } + + function getJieQi() { + return Day_getJieQi($this->_cPtr); + } + + function getJieQiJD() { + return Day_getJieQiJD($this->_cPtr); + } + + function getConstellation() { + return Day_getConstellation($this->_cPtr); + } +} + + diff --git a/export/php7/sxtwl_wrap.cxx b/export/php7/sxtwl_wrap.cxx new file mode 100644 index 0000000..13e1451 --- /dev/null +++ b/export/php7/sxtwl_wrap.cxx @@ -0,0 +1,5672 @@ +/* ---------------------------------------------------------------------------- + * 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 SWIGPHP + +#if defined __GNUC__ && !defined __cplusplus +# if __GNUC__ >= 4 +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wdeclaration-after-statement" +# endif +#endif +#include "php.h" +#if defined __GNUC__ && !defined __cplusplus +# if __GNUC__ >= 4 +# pragma GCC diagnostic pop +# endif +#endif + +/* ----------------------------------------------------------------------------- + * 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 + +/* ----------------------------------------------------------------------------- + * 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 + + +/* ----------------------------------------------------------------------------- + * phprun.swg + * + * PHP runtime library + * ----------------------------------------------------------------------------- */ + +#define swig_owntype int + +#ifdef __cplusplus +extern "C" { +#endif + +#if PHP_MAJOR_VERSION < 7 +# error These bindings need PHP 7 or later - to generate PHP5 bindings use: SWIG < 4.0.0 and swig -php5 +#endif + +#include "zend_inheritance.h" +#include "zend_exceptions.h" +#include "zend_inheritance.h" + +#if PHP_MAJOR_VERSION == 7 +/* These macros were new in PHP 8.0. For PHP 7.x we define them to give the + * same result except without any type declarations. PHP 7.x supports type + * declarations, but not for the return type, and alternate types aren't + * supported, so we don't try to support these. + */ +# define ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(name, byref, num_req, classes, types) \ + ZEND_BEGIN_ARG_INFO_EX(name, 0, byref, num_req) +# define ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(name, byref, num_req, types) \ + ZEND_BEGIN_ARG_INFO_EX(name, 0, byref, num_req) + +/* NB We can just ignore `default` here we currently always pass NULL for it + * (this mechanism for specifying default parameter values was new in PHP 8.0 + * so it's not useful while we still want to support PHP7 too). + */ +# define ZEND_ARG_OBJ_TYPE_MASK(byref, name, classes, types, default) \ + ZEND_ARG_INFO(byref, name) +# define ZEND_ARG_TYPE_MASK(byref, name, types, default) \ + ZEND_ARG_INFO(byref, name) +#endif + +#include /* for abort(), used in generated code. */ + +#define SWIG_BOOL_CONSTANT(N, V) REGISTER_BOOL_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT) +#define SWIG_LONG_CONSTANT(N, V) REGISTER_LONG_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT) +#define SWIG_DOUBLE_CONSTANT(N, V) REGISTER_DOUBLE_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT) +#define SWIG_STRING_CONSTANT(N, V) REGISTER_STRING_CONSTANT(#N, (char*)V, CONST_CS | CONST_PERSISTENT) +#define SWIG_CHAR_CONSTANT(N, V) do {\ + char swig_char = (V);\ + REGISTER_STRINGL_CONSTANT(#N, &swig_char, 1, CONST_CS | CONST_PERSISTENT);\ +} while (0) + +/* ZEND_CONSTANT_SET_FLAGS was new in PHP 7.3. */ +#ifdef ZEND_CONSTANT_SET_FLAGS +# define SWIG_ZEND_CONSTANT_SET_FLAGS ZEND_CONSTANT_SET_FLAGS +#else +# define SWIG_ZEND_CONSTANT_SET_FLAGS(C, F, N) do { (C)->flags = (F); (C)->module_number = (N); } while (0) +#endif + +/* zend_object_alloc was new in PHP 7.3. */ +#if PHP_MAJOR_VERSION == 7 && PHP_MINOR_VERSION < 3 +static zend_always_inline void *zend_object_alloc(size_t obj_size, zend_class_entry *ce) { + void *obj = emalloc(obj_size + zend_object_properties_size(ce)); + memset(obj, 0, obj_size - sizeof(zval)); + return obj; +} +#endif + +/* ZEND_THIS was new in PHP 7.4. */ +#ifndef ZEND_THIS +# define ZEND_THIS &EX(This) +#endif + +#ifdef __cplusplus +} +#endif + +#define SWIG_fail goto fail + +static const char *default_error_msg = "Unknown error occurred"; +static int default_error_code = E_ERROR; + +#define SWIG_PHP_Arg_Error_Msg(argnum,extramsg) "Error in argument " #argnum " "#extramsg + +#define SWIG_PHP_Error(code,msg) do { zend_throw_exception(NULL, msg, code); SWIG_fail; } while (0) + +#define SWIG_contract_assert(expr,msg) \ + do { if (!(expr)) zend_printf("Contract Assert Failed %s\n", msg); } while (0) + +/* Standard SWIG API */ +#define SWIG_GetModule(clientdata) SWIG_Php_GetModule() +#define SWIG_SetModule(clientdata, pointer) SWIG_Php_SetModule(pointer, *(int*)clientdata) + +static zend_class_entry SWIG_Php_swig_wrapped_interface_ce; + +#if PHP_MAJOR_VERSION == 7 +/* zend_class_implements_interface() was new in PHP 8.0. + * + * We could use instanceof_function_ex(C, I, 1) here for 7.4, but for 7.3 + * and earlier that doesn't work, so instead we just provide a compatibility + * implementation which does what zend_class_implements_interface() does in 8.x + * and use that for all 7.x so there are fewer variants to worry about testing. + */ +static int zend_class_implements_interface(const zend_class_entry *class_ce, const zend_class_entry *interface_ce) { + uint32_t i; + if (class_ce->num_interfaces) { + for (i = 0; i < class_ce->num_interfaces; i++) { + if (class_ce->interfaces[i] == interface_ce) { + return 1; + } + } + } + return 0; +} +#endif + +/* used to wrap returned objects in so we know whether they are newobject + and need freeing, or not */ +typedef struct { + void * ptr; + int newobject; + const swig_type_info * type; + zend_object std; +} swig_object_wrapper; + +#define SWIG_Z_FETCH_OBJ_P(zv) swig_php_fetch_object(Z_OBJ_P(zv)) + +static inline +swig_object_wrapper * swig_php_fetch_object(zend_object *obj) { + return (swig_object_wrapper *)((char *)obj - XtOffsetOf(swig_object_wrapper, std)); +} + +#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) + +static void +SWIG_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject) { + // Return PHP NULL for a C/C++ NULL pointer. + if (!ptr) { + ZVAL_NULL(z); + return; + } + + if (!type->clientdata) { + zend_type_error("Type: %s not registered with zend", type->name); + return; + } + + { + zend_object *obj; + swig_object_wrapper *value; + if (Z_TYPE_P(z) == IS_OBJECT) { + /* The PHP object is already initialised - this is the case when wrapping + * the return value from a PHP constructor. */ + obj = Z_OBJ_P(z); + } else { + zend_class_entry *ce = (zend_class_entry*)(type->clientdata); + obj = ce->create_object(ce); + ZVAL_OBJ(z, obj); + } + value = swig_php_fetch_object(obj); + value->ptr = ptr; + value->newobject = (newobject & 1); + value->type = type; + } +} + +/* We wrap C/C++ pointers as PHP objects. */ +static int +SWIG_ConvertPtrAndOwn(zval *z, void **ptr, swig_type_info *ty, int flags, swig_owntype *own) { + if (own) + *own = 0; + + if (z == NULL) { + *ptr = 0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + + switch (Z_TYPE_P(z)) { + case IS_OBJECT: { + zend_object *obj = Z_OBJ_P(z); + swig_object_wrapper *value; + if (ty && ty->clientdata == (void*)obj->ce) { + // Object is exactly the class asked for - this handles common cases cheaply, + // and in particular the PHP classes we use to wrap a pointer to a non-class. + } else if (!zend_class_implements_interface(obj->ce, &SWIG_Php_swig_wrapped_interface_ce)) { + // Not an object we've wrapped. + return -1; + } + + /* convert and cast value->ptr from value->type to ptr as ty. */ + value = swig_php_fetch_object(obj); + if (!ty) { + /* They don't care about the target type, so just pass on the pointer! */ + *ptr = value->ptr; + } else { + swig_cast_info *tc = SWIG_TypeCheck(value->type->name, ty); + if (tc) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc, value->ptr, &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 |= SWIG_CAST_NEW_MEMORY; + } + } else { + *ptr = NULL; + } + } + + if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !value->newobject) { + return SWIG_ERROR_RELEASE_NOT_OWNED; + } else { + if (*ptr == NULL) + return SWIG_ERROR; /* should be SWIG_NullReferenceError?? */ + if (flags & SWIG_POINTER_DISOWN) { + value->newobject = 0; + } + if (flags & SWIG_POINTER_CLEAR) { + value->ptr = 0; + } + } + + return SWIG_OK; + } + case IS_NULL: + *ptr = 0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + + return -1; +} + +static int +SWIG_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags) { + return SWIG_ConvertPtrAndOwn(z, ptr, ty, flags, 0); +} + +static const char const_name[] = "swig_runtime_data_type_pointer"; +static swig_module_info *SWIG_Php_GetModule(void) { + zval *pointer = zend_get_constant_str(const_name, sizeof(const_name) - 1); + if (pointer) { + if (Z_TYPE_P(pointer) == IS_LONG) { + return (swig_module_info *) pointer->value.lval; + } + } + return NULL; +} + +static void SWIG_Php_SetModule(swig_module_info *pointer, int module_number) { + REGISTER_LONG_CONSTANT(const_name, (long) pointer, CONST_CS | CONST_PERSISTENT); +} + +/* Common parts of the "create_object" object handler. */ +static zend_object *SWIG_Php_do_create_object(zend_class_entry *ce, zend_object_handlers *handlers) { + swig_object_wrapper *obj = (swig_object_wrapper*)zend_object_alloc(sizeof(swig_object_wrapper), ce); + zend_object_std_init(&obj->std, ce); + object_properties_init(&obj->std, ce); + obj->std.handlers = handlers; + obj->newobject = 1; + return &obj->std; +} + +/* Common parts of the "free_obj" object handler. + Returns void* pointer if the C/C++ object should be destroyed. */ +static void* SWIG_Php_free_obj(zend_object *object) { + if (object) { + swig_object_wrapper *obj = swig_php_fetch_object(object); + zend_object_std_dtor(&obj->std); + if (obj->newobject) return obj->ptr; + } + return NULL; +} + +/* 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 + + + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_int swig_types[0] +#define SWIGTYPE_p_Day swig_types[1] +#define SWIGTYPE_p_GZ swig_types[2] +#define SWIGTYPE_p_Time swig_types[3] +#define SWIGTYPE_p_difference_type swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_long_long swig_types[6] +#define SWIGTYPE_p_short swig_types[7] +#define SWIGTYPE_p_signed_char swig_types[8] +#define SWIGTYPE_p_size_type swig_types[9] +#define SWIGTYPE_p_std__vectorT_double_t swig_types[10] +#define SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t swig_types[11] +#define SWIGTYPE_p_sxtwl__JieQiInfo swig_types[12] +#define SWIGTYPE_p_unsigned_char swig_types[13] +#define SWIGTYPE_p_unsigned_int swig_types[14] +#define SWIGTYPE_p_unsigned_long_long swig_types[15] +#define SWIGTYPE_p_unsigned_short swig_types[16] +#define SWIGTYPE_p_value_type 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) -------- */ + +/* header section */ +#define SWIG_name "sxtwl" +#ifdef __cplusplus +extern "C" { +#endif +#include "php_ini.h" +#include "ext/standard/info.h" +#include "php_sxtwl.h" +#ifdef __cplusplus +} +#endif + + +#ifdef __cplusplus +#include +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigSmartPointer { + T *ptr; + SwigSmartPointer(T *p) : ptr(p) { } + ~SwigSmartPointer() { delete ptr; } + SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; } +#if __cplusplus >=201103L + SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; } + operator T&&() const { return std::move(*pointer.ptr); } +#else + operator T&() const { return *pointer.ptr; } +#endif + T *operator&() const { return pointer.ptr; } + static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); } +}; + +/* + * SwigValueInit() is a generic initialisation solution as the following approach: + * + * T c_result = T(); + * + * doesn't compile for all types for example: + * + * unsigned int c_result = unsigned int(); + */ +template T SwigValueInit() { + return T(); +} + +#if __cplusplus >=201103L +# define SWIG_STD_MOVE(OBJ) std::move(OBJ) +#else +# define SWIG_STD_MOVE(OBJ) OBJ +#endif + +#endif + + + +#define SWIG_PHP_INTERFACE_Iterator_CE zend_ce_iterator +#define SWIG_PHP_INTERFACE_Iterator_HEADER "zend_interfaces.h" + +#define SWIG_PHP_INTERFACE_IteratorAggregate_CE zend_ce_aggregate +#define SWIG_PHP_INTERFACE_IteratorAggregate_HEADER "zend_interfaces.h" + +#define SWIG_PHP_INTERFACE_ArrayAccess_CE zend_ce_arrayaccess +#define SWIG_PHP_INTERFACE_ArrayAccess_HEADER "zend_interfaces.h" + +#define SWIG_PHP_INTERFACE_Serializable_CE zend_ce_serializable +#define SWIG_PHP_INTERFACE_Serializable_HEADER "zend_interfaces.h" + +#define SWIG_PHP_INTERFACE_Countable_CE zend_ce_countable +#define SWIG_PHP_INTERFACE_Countable_HEADER "zend_interfaces.h" + +#define SWIG_PHP_INTERFACE_OuterIterator_CE spl_ce_OuterIterator +#define SWIG_PHP_INTERFACE_OuterIterator_HEADER "ext/spl/spl_iterators.h" + +#define SWIG_PHP_INTERFACE_RecursiveIterator_CE spl_ce_RecursiveIterator +#define SWIG_PHP_INTERFACE_RecursiveIterator_HEADER "ext/spl/spl_iterators.h" + +#define SWIG_PHP_INTERFACE_SeekableIterator_CE spl_ce_SeekableIterator +#define SWIG_PHP_INTERFACE_SeekableIterator_HEADER "ext/spl/spl_iterators.h" + +#define SWIG_PHP_INTERFACE_SplObserver_CE spl_ce_SplObserver +#define SWIG_PHP_INTERFACE_SplObserver_HEADER "ext/spl/spl_observer.h" + +#define SWIG_PHP_INTERFACE_SplSubject_CE spl_ce_SplSubject +#define SWIG_PHP_INTERFACE_SplSubject_HEADER "ext/spl/spl_observer.h" + +#define SWIG_PHP_INTERFACE_DateTimeInterface_CE php_date_get_interface_ce() +#define SWIG_PHP_INTERFACE_DateTimeInterface_HEADER "ext/date/php_date.h" + +// The "json" extension needs to be loaded earlier that us for this to work. +#define SWIG_PHP_INTERFACE_JsonSerializable_CE php_json_serializable_ce +#define SWIG_PHP_INTERFACE_JsonSerializable_HEADER "ext/json/php_json.h" + +// New in PHP 8.0. +#if PHP_MAJOR_VERSION >= 8 +# define SWIG_PHP_INTERFACE_Stringable_CE zend_ce_stringable +# define SWIG_PHP_INTERFACE_Stringable_HEADER "zend_interfaces.h" +#endif + + + +#include "const.h" +#include "sxtwl.h" + + +#include // Use the C99 official header + + +#include +#include + + +#include +#include + + +#if PHP_MAJOR_VERSION >= 8 +# define SWIG_HANDLE_VALUE_ERROR_FOR_PHP8(code) code == SWIG_ValueError ? zend_ce_value_error : +#else +# define SWIG_HANDLE_VALUE_ERROR_FOR_PHP8(code) +#endif +#define SWIG_exception(code, msg) do { zend_throw_exception( \ + code == SWIG_TypeError ? zend_ce_type_error : \ + SWIG_HANDLE_VALUE_ERROR_FOR_PHP8(code) \ + code == SWIG_DivisionByZero ? zend_ce_division_by_zero_error : \ + code == SWIG_SyntaxError ? zend_ce_parse_error : \ + code == SWIG_OverflowError ? zend_ce_arithmetic_error : \ + NULL, msg, code); SWIG_fail; } while (0) + + +#include +#include + + +#include + +SWIGINTERN bool std_vector_Sl_double_Sg__is_empty(std::vector< double > const *self){ + return self->empty(); + } +SWIGINTERN double std_vector_Sl_double_Sg__pop(std::vector< double > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty vector"); + double x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< double >::const_reference std_vector_Sl_double_Sg__get(std::vector< double > *self,int i){ + int size = int(self->size()); + if (i>=0 && i *self,int i,std::vector< double >::value_type const &val){ + int size = int(self->size()); + if (i>=0 && i const *self){ + return self->empty(); + } +SWIGINTERN sxtwl::JieQiInfo std_vector_Sl_sxtwl_JieQiInfo_Sg__pop(std::vector< sxtwl::JieQiInfo > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty vector"); + sxtwl::JieQiInfo x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< sxtwl::JieQiInfo >::const_reference std_vector_Sl_sxtwl_JieQiInfo_Sg__get(std::vector< sxtwl::JieQiInfo > *self,int i){ + int size = int(self->size()); + if (i>=0 && i *self,int i,std::vector< sxtwl::JieQiInfo >::value_type const &val){ + int size = int(self->size()); + if (i>=0 && i *)SWIG_Php_free_obj(object);} + +static zend_class_entry *SWIG_Php_ce_JQList; + +static zend_object_handlers JQList_object_handlers; +static zend_object *SWIG_Php_create_object_JQList(zend_class_entry *ce) {return SWIG_Php_do_create_object(ce, &JQList_object_handlers);} +static void SWIG_Php_free_obj_JQList(zend_object *object) {delete (std::vector< sxtwl::JieQiInfo > *)SWIG_Php_free_obj(object);} + +static zend_class_entry *SWIG_Php_ce_sxtwl; + +static zend_class_entry *SWIG_Php_ce_Time; + +static zend_object_handlers Time_object_handlers; +static zend_object *SWIG_Php_create_object_Time(zend_class_entry *ce) {return SWIG_Php_do_create_object(ce, &Time_object_handlers);} +static void SWIG_Php_free_obj_Time(zend_object *object) {delete (Time *)SWIG_Php_free_obj(object);} + +static zend_class_entry *SWIG_Php_ce_GZ; + +static zend_object_handlers GZ_object_handlers; +static zend_object *SWIG_Php_create_object_GZ(zend_class_entry *ce) {return SWIG_Php_do_create_object(ce, &GZ_object_handlers);} +static void SWIG_Php_free_obj_GZ(zend_object *object) {delete (GZ *)SWIG_Php_free_obj(object);} + +static zend_class_entry *SWIG_Php_ce_Day; + +static zend_object_handlers Day_object_handlers; +static zend_object *SWIG_Php_create_object_Day(zend_class_entry *ce) {return SWIG_Php_do_create_object(ce, &Day_object_handlers);} +static void SWIG_Php_free_obj_Day(zend_object *object) {delete (Day *)SWIG_Php_free_obj(object);} + +static zend_class_entry *SWIG_Php_ce_JieQiInfo; + +static zend_object_handlers JieQiInfo_object_handlers; +static zend_object *SWIG_Php_create_object_JieQiInfo(zend_class_entry *ce) {return SWIG_Php_do_create_object(ce, &JieQiInfo_object_handlers);} +static void SWIG_Php_free_obj_JieQiInfo(zend_object *object) {delete (sxtwl::JieQiInfo *)SWIG_Php_free_obj(object);} + +/* class entry for pointer to _p_int */ +static zend_class_entry *SWIG_Php_ce__p_int; + +/* class entry for pointer to _p_size_type */ +static zend_class_entry *SWIG_Php_ce__p_size_type; + +/* class entry for pointer to _p_value_type */ +static zend_class_entry *SWIG_Php_ce__p_value_type; + +/* class entry for pointer to _p_unsigned_char */ +static zend_class_entry *SWIG_Php_ce__p_unsigned_char; + +/* class entry for pointer to _p_unsigned_short */ +static zend_class_entry *SWIG_Php_ce__p_unsigned_short; + +/* class entry for pointer to _p_signed_char */ +static zend_class_entry *SWIG_Php_ce__p_signed_char; + +/* class entry for pointer to _p_long_long */ +static zend_class_entry *SWIG_Php_ce__p_long_long; + +/* class entry for pointer to _p_unsigned_int */ +static zend_class_entry *SWIG_Php_ce__p_unsigned_int; + +/* class entry for pointer to _p_unsigned_long_long */ +static zend_class_entry *SWIG_Php_ce__p_unsigned_long_long; + +/* class entry for pointer to _int */ +static zend_class_entry *SWIG_Php_ce__int; + +/* class entry for pointer to _p_short */ +static zend_class_entry *SWIG_Php_ce__p_short; + +/* class entry for pointer to _p_difference_type */ +static zend_class_entry *SWIG_Php_ce__p_difference_type; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static swig_type_info _swigt__int = {"_int", "int", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_Day = {"_p_Day", "Day *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_GZ = {"_p_GZ", "GZ *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_Time = {"_p_Time", "Time *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 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_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_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_double_t = {"_p_std__vectorT_double_t", "std::vector< double > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_sxtwl__JieQiInfo_t = {"_p_std__vectorT_sxtwl__JieQiInfo_t", "std::vector< sxtwl::JieQiInfo > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_sxtwl__JieQiInfo = {"_p_sxtwl__JieQiInfo", "std::vector< sxtwl::JieQiInfo >::value_type *|sxtwl::JieQiInfo *", 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 _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__int, + &_swigt__p_Day, + &_swigt__p_GZ, + &_swigt__p_Time, + &_swigt__p_difference_type, + &_swigt__p_int, + &_swigt__p_long_long, + &_swigt__p_short, + &_swigt__p_signed_char, + &_swigt__p_size_type, + &_swigt__p_std__vectorT_double_t, + &_swigt__p_std__vectorT_sxtwl__JieQiInfo_t, + &_swigt__p_sxtwl__JieQiInfo, + &_swigt__p_unsigned_char, + &_swigt__p_unsigned_int, + &_swigt__p_unsigned_long_long, + &_swigt__p_unsigned_short, + &_swigt__p_value_type, +}; + +static swig_cast_info _swigc__int[] = { {&_swigt__int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_Day[] = { {&_swigt__p_Day, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_GZ[] = { {&_swigt__p_GZ, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_Time[] = { {&_swigt__p_Time, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 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_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_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_double_t[] = { {&_swigt__p_std__vectorT_double_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_sxtwl__JieQiInfo_t[] = { {&_swigt__p_std__vectorT_sxtwl__JieQiInfo_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sxtwl__JieQiInfo[] = { {&_swigt__p_sxtwl__JieQiInfo, 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 _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__int, + _swigc__p_Day, + _swigc__p_GZ, + _swigc__p_Time, + _swigc__p_difference_type, + _swigc__p_int, + _swigc__p_long_long, + _swigc__p_short, + _swigc__p_signed_char, + _swigc__p_size_type, + _swigc__p_std__vectorT_double_t, + _swigc__p_std__vectorT_sxtwl__JieQiInfo_t, + _swigc__p_sxtwl__JieQiInfo, + _swigc__p_unsigned_char, + _swigc__p_unsigned_int, + _swigc__p_unsigned_long_long, + _swigc__p_unsigned_short, + _swigc__p_value_type, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +/* end header section */ +/* vdecl subsection */ +/* end vdecl subsection */ +/* wrapper section */ +static ZEND_NAMED_FUNCTION(_wrap_new_JDList__SWIG_0) { + std::vector< double > *result = 0 ; + + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (std::vector< double > *)new std::vector< double >(); + + SWIG_SetPointerZval(ZEND_THIS, (void *)result, SWIGTYPE_p_std__vectorT_double_t, 1); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_new_JDList__SWIG_1) { + std::vector< double >::size_type arg1 ; + zval args[1]; + std::vector< double > *result = 0 ; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (std::vector< double >::size_type) zval_get_long(&args[0]); + /*@SWIG@*/; + + result = (std::vector< double > *)new std::vector< double >(arg1); + + SWIG_SetPointerZval(ZEND_THIS, (void *)result, SWIGTYPE_p_std__vectorT_double_t, 1); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_new_JDList__SWIG_2) { + std::vector< double > *arg1 = 0 ; + zval args[1]; + std::vector< double > *result = 0 ; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + if (SWIG_ConvertPtr(&args[0], (void **) &arg1, SWIGTYPE_p_std__vectorT_double_t, 0) < 0 || arg1 == NULL) { + zend_type_error("Expected SWIGTYPE_p_std__vectorT_double_t for argument 1 of new_JDList"); + return; + } + + result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1); + + SWIG_SetPointerZval(ZEND_THIS, (void *)result, SWIGTYPE_p_std__vectorT_double_t, 1); + +fail: + return; +} + + +static PHP_METHOD(JDList,__construct) { + int argc; + zval argv[1]; + + argc = ZEND_NUM_ARGS(); + zend_get_parameters_array_ex(argc, argv); + if (argc == 0) { + _wrap_new_JDList__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + if (argc == 1) { + int _v = 0; + { + void *tmp; + _v = (SWIG_ConvertPtr(&argv[0], (void**)&tmp, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL) >= 0); + } + if (_v) { + _wrap_new_JDList__SWIG_2(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + if (argc == 1) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _wrap_new_JDList__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + + zend_throw_exception(zend_ce_type_error, "No matching function for overloaded 'new_JDList'", 0); +fail: + return; +} + + +static PHP_METHOD(JDList,size) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type result; + + arg1 = (std::vector< double > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = ((std::vector< double > const *)arg1)->size(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(JDList,capacity) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type result; + + arg1 = (std::vector< double > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = ((std::vector< double > const *)arg1)->capacity(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(JDList,reserve) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type arg2 ; + zval args[1]; + + arg1 = (std::vector< double > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (std::vector< double >::size_type) zval_get_long(&args[0]); + /*@SWIG@*/; + + (arg1)->reserve(arg2); + +fail: + return; +} + + +static PHP_METHOD(JDList,clear) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + + arg1 = (std::vector< double > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + (arg1)->clear(); + +fail: + return; +} + + +static PHP_METHOD(JDList,push) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::value_type *arg2 = 0 ; + std::vector< double >::value_type temp2 ; + zval args[1]; + + arg1 = (std::vector< double > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + temp2 = (std::vector< double >::value_type) zval_get_double(&args[0]); + /*@SWIG@*/; + arg2 = &temp2; + + (arg1)->push_back((std::vector< double >::value_type const &)*arg2); + +fail: + return; +} + + +static PHP_METHOD(JDList,is_empty) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + bool result; + + arg1 = (std::vector< double > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (bool)std_vector_Sl_double_Sg__is_empty((std::vector< double > const *)arg1); + + RETVAL_BOOL((result) ? 1 : 0); + +fail: + return; +} + + +static PHP_METHOD(JDList,pop) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + double result; + + arg1 = (std::vector< double > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + try { + result = (double)std_vector_Sl_double_Sg__pop(arg1); + } catch(std::out_of_range &_e) { + (void)_e; + zend_throw_exception(NULL, "C++ std::out_of_range exception thrown", 0); + goto fail; + + } + + RETVAL_DOUBLE(result); + +fail: + return; +} + + +static PHP_METHOD(JDList,get) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + zval args[1]; + std::vector< double >::value_type *result = 0 ; + + arg1 = (std::vector< double > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + try { + result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__get(arg1,arg2); + } catch(std::out_of_range &_e) { + (void)_e; + zend_throw_exception(NULL, "C++ std::out_of_range exception thrown", 0); + goto fail; + + } + + RETVAL_DOUBLE(*result); + +fail: + return; +} + + +static PHP_METHOD(JDList,set) { + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + int arg2 ; + std::vector< double >::value_type *arg3 = 0 ; + std::vector< double >::value_type temp3 ; + zval args[2]; + + arg1 = (std::vector< double > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + temp3 = (std::vector< double >::value_type) zval_get_double(&args[1]); + /*@SWIG@*/; + arg3 = &temp3; + + try { + std_vector_Sl_double_Sg__set(arg1,arg2,(double const &)*arg3); + } catch(std::out_of_range &_e) { + (void)_e; + zend_throw_exception(NULL, "C++ std::out_of_range exception thrown", 0); + goto fail; + + } + +fail: + return; +} + + + + +PHP_METHOD(JDList,__set) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[2]; + zval tempZval; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if (!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_NULL(); + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + arg->newobject = zval_get_long(&args[1]); + } +fail: + return; +} + + +PHP_METHOD(JDList,__get) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[1]; + zval tempZval; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if (!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_NULL(); + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + if(arg->newobject) { + RETVAL_LONG(1); + } + else { + RETVAL_LONG(0); + } + } + + else { + RETVAL_NULL(); + } +fail: + return; +} + + +PHP_METHOD(JDList,__isset) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[1]; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if(!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_FALSE; + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + RETVAL_TRUE; + } + + else { + RETVAL_FALSE; + } +fail: + return; +} + + + + +static ZEND_NAMED_FUNCTION(_wrap_new_JQList__SWIG_0) { + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >(); + + SWIG_SetPointerZval(ZEND_THIS, (void *)result, SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t, 1); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_new_JQList__SWIG_1) { + std::vector< sxtwl::JieQiInfo >::size_type arg1 ; + zval args[1]; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (std::vector< sxtwl::JieQiInfo >::size_type) zval_get_long(&args[0]); + /*@SWIG@*/; + + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >(arg1); + + SWIG_SetPointerZval(ZEND_THIS, (void *)result, SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t, 1); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_new_JQList__SWIG_2) { + std::vector< sxtwl::JieQiInfo > *arg1 = 0 ; + zval args[1]; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + if (SWIG_ConvertPtr(&args[0], (void **) &arg1, SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t, 0) < 0 || arg1 == NULL) { + zend_type_error("Expected SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t for argument 1 of new_JQList"); + return; + } + + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >((std::vector< sxtwl::JieQiInfo > const &)*arg1); + + SWIG_SetPointerZval(ZEND_THIS, (void *)result, SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t, 1); + +fail: + return; +} + + +static PHP_METHOD(JQList,__construct) { + int argc; + zval argv[1]; + + argc = ZEND_NUM_ARGS(); + zend_get_parameters_array_ex(argc, argv); + if (argc == 0) { + _wrap_new_JQList__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + if (argc == 1) { + int _v = 0; + { + void *tmp; + _v = (SWIG_ConvertPtr(&argv[0], (void**)&tmp, SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t, SWIG_POINTER_NO_NULL) >= 0); + } + if (_v) { + _wrap_new_JQList__SWIG_2(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + if (argc == 1) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _wrap_new_JQList__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + + zend_throw_exception(zend_ce_type_error, "No matching function for overloaded 'new_JQList'", 0); +fail: + return; +} + + +static PHP_METHOD(JQList,size) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type result; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = ((std::vector< sxtwl::JieQiInfo > const *)arg1)->size(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(JQList,capacity) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type result; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = ((std::vector< sxtwl::JieQiInfo > const *)arg1)->capacity(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(JQList,reserve) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type arg2 ; + zval args[1]; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (std::vector< sxtwl::JieQiInfo >::size_type) zval_get_long(&args[0]); + /*@SWIG@*/; + + (arg1)->reserve(arg2); + +fail: + return; +} + + +static PHP_METHOD(JQList,clear) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + (arg1)->clear(); + +fail: + return; +} + + +static PHP_METHOD(JQList,push) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg2 = 0 ; + zval args[1]; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + if (SWIG_ConvertPtr(&args[0], (void **) &arg2, SWIGTYPE_p_sxtwl__JieQiInfo, 0) < 0 || arg2 == NULL) { + zend_type_error("Expected SWIGTYPE_p_sxtwl__JieQiInfo for argument 2 of JQList_push"); + return; + } + + (arg1)->push_back((std::vector< sxtwl::JieQiInfo >::value_type const &)*arg2); + +fail: + return; +} + + +static PHP_METHOD(JQList,is_empty) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + bool result; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (bool)std_vector_Sl_sxtwl_JieQiInfo_Sg__is_empty((std::vector< sxtwl::JieQiInfo > const *)arg1); + + RETVAL_BOOL((result) ? 1 : 0); + +fail: + return; +} + + +static PHP_METHOD(JQList,pop) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + sxtwl::JieQiInfo result; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + try { + result = std_vector_Sl_sxtwl_JieQiInfo_Sg__pop(arg1); + } catch(std::out_of_range &_e) { + (void)_e; + zend_throw_exception(NULL, "C++ std::out_of_range exception thrown", 0); + goto fail; + + } + { + sxtwl::JieQiInfo * resultobj = new sxtwl::JieQiInfo(result); + + + + + SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_sxtwl__JieQiInfo, 1); + } +fail: + return; +} + + +static PHP_METHOD(JQList,get) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + zval args[1]; + std::vector< sxtwl::JieQiInfo >::value_type *result = 0 ; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + try { + result = (std::vector< sxtwl::JieQiInfo >::value_type *) &std_vector_Sl_sxtwl_JieQiInfo_Sg__get(arg1,arg2); + } catch(std::out_of_range &_e) { + (void)_e; + zend_throw_exception(NULL, "C++ std::out_of_range exception thrown", 0); + goto fail; + + } + + SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_sxtwl__JieQiInfo, 0); + +fail: + return; +} + + +static PHP_METHOD(JQList,set) { + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + int arg2 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg3 = 0 ; + zval args[2]; + + arg1 = (std::vector< sxtwl::JieQiInfo > *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + + if (SWIG_ConvertPtr(&args[1], (void **) &arg3, SWIGTYPE_p_sxtwl__JieQiInfo, 0) < 0 || arg3 == NULL) { + zend_type_error("Expected SWIGTYPE_p_sxtwl__JieQiInfo for argument 3 of JQList_set"); + return; + } + + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg__set(arg1,arg2,(sxtwl::JieQiInfo const &)*arg3); + } catch(std::out_of_range &_e) { + (void)_e; + zend_throw_exception(NULL, "C++ std::out_of_range exception thrown", 0); + goto fail; + + } + +fail: + return; +} + + + + +PHP_METHOD(JQList,__set) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[2]; + zval tempZval; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if (!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_NULL(); + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + arg->newobject = zval_get_long(&args[1]); + } +fail: + return; +} + + +PHP_METHOD(JQList,__get) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[1]; + zval tempZval; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if (!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_NULL(); + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + if(arg->newobject) { + RETVAL_LONG(1); + } + else { + RETVAL_LONG(0); + } + } + + else { + RETVAL_NULL(); + } +fail: + return; +} + + +PHP_METHOD(JQList,__isset) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[1]; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if(!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_FALSE; + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + RETVAL_TRUE; + } + + else { + RETVAL_FALSE; + } +fail: + return; +} + + + + +static ZEND_NAMED_FUNCTION(_wrap_new_Time__SWIG_0) { + Time *result = 0 ; + + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (Time *)new Time(); + + SWIG_SetPointerZval(ZEND_THIS, (void *)result, SWIGTYPE_p_Time, 1); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_new_Time__SWIG_1) { + int arg1 ; + int arg2 ; + int arg3 ; + double arg4 ; + double arg5 ; + double arg6 ; + zval args[6]; + Time *result = 0 ; + + if(ZEND_NUM_ARGS() != 6 || zend_get_parameters_array_ex(6, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[1]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg3 = (int) zval_get_long(&args[2]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + arg4 = (double) zval_get_double(&args[3]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + arg5 = (double) zval_get_double(&args[4]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + arg6 = (double) zval_get_double(&args[5]); + /*@SWIG@*/; + + result = (Time *)new Time(arg1,arg2,arg3,arg4,arg5,arg6); + + SWIG_SetPointerZval(ZEND_THIS, (void *)result, SWIGTYPE_p_Time, 1); + +fail: + return; +} + + +static PHP_METHOD(Time,__construct) { + int argc; + zval argv[6]; + + argc = ZEND_NUM_ARGS(); + zend_get_parameters_array_ex(argc, argv); + if (argc == 0) { + _wrap_new_Time__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + if (argc == 6) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[1]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[2]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[3]) == IS_DOUBLE); + if (_v) { + _v = (Z_TYPE(argv[4]) == IS_DOUBLE); + if (_v) { + _v = (Z_TYPE(argv[5]) == IS_DOUBLE); + if (_v) { + _wrap_new_Time__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + } + } + } + } + } + + zend_throw_exception(zend_ce_type_error, "No matching function for overloaded 'new_Time'", 0); +fail: + return; +} + + +static PHP_METHOD(Time,Y_set) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + zval args[1]; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + if (arg1) (arg1)->Y = arg2; + +fail: + return; +} + + +static PHP_METHOD(Time,Y_get) { + Time *arg1 = (Time *) 0 ; + int result; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (int) ((arg1)->Y); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Time,M_set) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + zval args[1]; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + if (arg1) (arg1)->M = arg2; + +fail: + return; +} + + +static PHP_METHOD(Time,M_get) { + Time *arg1 = (Time *) 0 ; + int result; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (int) ((arg1)->M); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Time,D_set) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + zval args[1]; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + if (arg1) (arg1)->D = arg2; + +fail: + return; +} + + +static PHP_METHOD(Time,D_get) { + Time *arg1 = (Time *) 0 ; + int result; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (int) ((arg1)->D); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Time,h_set) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + zval args[1]; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + arg2 = (double) zval_get_double(&args[0]); + /*@SWIG@*/; + + if (arg1) (arg1)->h = arg2; + +fail: + return; +} + + +static PHP_METHOD(Time,h_get) { + Time *arg1 = (Time *) 0 ; + double result; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (double) ((arg1)->h); + + RETVAL_DOUBLE(result); + +fail: + return; +} + + +static PHP_METHOD(Time,m_set) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + zval args[1]; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + arg2 = (double) zval_get_double(&args[0]); + /*@SWIG@*/; + + if (arg1) (arg1)->m = arg2; + +fail: + return; +} + + +static PHP_METHOD(Time,m_get) { + Time *arg1 = (Time *) 0 ; + double result; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (double) ((arg1)->m); + + RETVAL_DOUBLE(result); + +fail: + return; +} + + +static PHP_METHOD(Time,s_set) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + zval args[1]; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + arg2 = (double) zval_get_double(&args[0]); + /*@SWIG@*/; + + if (arg1) (arg1)->s = arg2; + +fail: + return; +} + + +static PHP_METHOD(Time,s_get) { + Time *arg1 = (Time *) 0 ; + double result; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (double) ((arg1)->s); + + RETVAL_DOUBLE(result); + +fail: + return; +} + + +static PHP_METHOD(Time,getYear) { + Time *arg1 = (Time *) 0 ; + int result; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (int)(arg1)->getYear(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Time,setYear) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + zval args[1]; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + (arg1)->setYear(arg2); + +fail: + return; +} + + +static PHP_METHOD(Time,setMonth) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + zval args[1]; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + (arg1)->setMonth(arg2); + +fail: + return; +} + + +static PHP_METHOD(Time,getMonth) { + Time *arg1 = (Time *) 0 ; + int result; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (int)(arg1)->getMonth(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Time,getDay) { + Time *arg1 = (Time *) 0 ; + int result; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (int)(arg1)->getDay(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Time,setDay) { + Time *arg1 = (Time *) 0 ; + int arg2 ; + zval args[1]; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + (arg1)->setDay(arg2); + +fail: + return; +} + + +static PHP_METHOD(Time,getHour) { + Time *arg1 = (Time *) 0 ; + double result; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (double)(arg1)->getHour(); + + RETVAL_DOUBLE(result); + +fail: + return; +} + + +static PHP_METHOD(Time,setHour) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + zval args[1]; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + arg2 = (double) zval_get_double(&args[0]); + /*@SWIG@*/; + + (arg1)->setHour(arg2); + +fail: + return; +} + + +static PHP_METHOD(Time,getMin) { + Time *arg1 = (Time *) 0 ; + double result; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (double)(arg1)->getMin(); + + RETVAL_DOUBLE(result); + +fail: + return; +} + + +static PHP_METHOD(Time,setMour) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + zval args[1]; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + arg2 = (double) zval_get_double(&args[0]); + /*@SWIG@*/; + + (arg1)->setMour(arg2); + +fail: + return; +} + + +static PHP_METHOD(Time,getSec) { + Time *arg1 = (Time *) 0 ; + double result; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (double)(arg1)->getSec(); + + RETVAL_DOUBLE(result); + +fail: + return; +} + + +static PHP_METHOD(Time,setSec) { + Time *arg1 = (Time *) 0 ; + double arg2 ; + zval args[1]; + + arg1 = (Time *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + arg2 = (double) zval_get_double(&args[0]); + /*@SWIG@*/; + + (arg1)->setSec(arg2); + +fail: + return; +} + + + + +PHP_METHOD(Time,__set) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[2]; + zval tempZval; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if (!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_NULL(); + } + + else if (strcmp(ZSTR_VAL(arg2),"Y") == 0) { + ZVAL_STRING(&tempZval, "Y_set"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,1,&args[1]); + } + + else if (strcmp(ZSTR_VAL(arg2),"M") == 0) { + ZVAL_STRING(&tempZval, "M_set"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,1,&args[1]); + } + + else if (strcmp(ZSTR_VAL(arg2),"D") == 0) { + ZVAL_STRING(&tempZval, "D_set"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,1,&args[1]); + } + + else if (strcmp(ZSTR_VAL(arg2),"h") == 0) { + ZVAL_STRING(&tempZval, "h_set"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,1,&args[1]); + } + + else if (strcmp(ZSTR_VAL(arg2),"m") == 0) { + ZVAL_STRING(&tempZval, "m_set"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,1,&args[1]); + } + + else if (strcmp(ZSTR_VAL(arg2),"s") == 0) { + ZVAL_STRING(&tempZval, "s_set"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,1,&args[1]); + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + arg->newobject = zval_get_long(&args[1]); + } +fail: + return; +} + + +PHP_METHOD(Time,__get) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[1]; + zval tempZval; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if (!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_NULL(); + } + + else if (strcmp(ZSTR_VAL(arg2),"Y") == 0) { + ZVAL_STRING(&tempZval, "Y_get"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,0,NULL); + } + + else if (strcmp(ZSTR_VAL(arg2),"M") == 0) { + ZVAL_STRING(&tempZval, "M_get"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,0,NULL); + } + + else if (strcmp(ZSTR_VAL(arg2),"D") == 0) { + ZVAL_STRING(&tempZval, "D_get"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,0,NULL); + } + + else if (strcmp(ZSTR_VAL(arg2),"h") == 0) { + ZVAL_STRING(&tempZval, "h_get"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,0,NULL); + } + + else if (strcmp(ZSTR_VAL(arg2),"m") == 0) { + ZVAL_STRING(&tempZval, "m_get"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,0,NULL); + } + + else if (strcmp(ZSTR_VAL(arg2),"s") == 0) { + ZVAL_STRING(&tempZval, "s_get"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,0,NULL); + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + if(arg->newobject) { + RETVAL_LONG(1); + } + else { + RETVAL_LONG(0); + } + } + + else { + RETVAL_NULL(); + } +fail: + return; +} + + +PHP_METHOD(Time,__isset) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[1]; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if(!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_FALSE; + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + RETVAL_TRUE; + } + + + else if (strcmp(ZSTR_VAL(arg2),"Y") == 0) { + RETVAL_TRUE; + } + + else if (strcmp(ZSTR_VAL(arg2),"M") == 0) { + RETVAL_TRUE; + } + + else if (strcmp(ZSTR_VAL(arg2),"D") == 0) { + RETVAL_TRUE; + } + + else if (strcmp(ZSTR_VAL(arg2),"h") == 0) { + RETVAL_TRUE; + } + + else if (strcmp(ZSTR_VAL(arg2),"m") == 0) { + RETVAL_TRUE; + } + + else if (strcmp(ZSTR_VAL(arg2),"s") == 0) { + RETVAL_TRUE; + } + else { + RETVAL_FALSE; + } +fail: + return; +} + + + + +static ZEND_NAMED_FUNCTION(_wrap_new_GZ__SWIG_0) { + GZ *result = 0 ; + + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (GZ *)new GZ(); + + SWIG_SetPointerZval(ZEND_THIS, (void *)result, SWIGTYPE_p_GZ, 1); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_new_GZ__SWIG_1) { + uint8_t arg1 ; + uint8_t arg2 ; + zval args[2]; + GZ *result = 0 ; + + if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (uint8_t) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[1]); + /*@SWIG@*/; + + result = (GZ *)new GZ(arg1,arg2); + + SWIG_SetPointerZval(ZEND_THIS, (void *)result, SWIGTYPE_p_GZ, 1); + +fail: + return; +} + + +static PHP_METHOD(GZ,__construct) { + int argc; + zval argv[2]; + + argc = ZEND_NUM_ARGS(); + zend_get_parameters_array_ex(argc, argv); + if (argc == 0) { + _wrap_new_GZ__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + if (argc == 2) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[1]) == IS_LONG); + if (_v) { + _wrap_new_GZ__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + } + + zend_throw_exception(zend_ce_type_error, "No matching function for overloaded 'new_GZ'", 0); +fail: + return; +} + + +static PHP_METHOD(GZ,tg_set) { + GZ *arg1 = (GZ *) 0 ; + uint8_t arg2 ; + zval args[1]; + + arg1 = (GZ *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[0]); + /*@SWIG@*/; + + if (arg1) (arg1)->tg = arg2; + +fail: + return; +} + + +static PHP_METHOD(GZ,tg_get) { + GZ *arg1 = (GZ *) 0 ; + uint8_t result; + + arg1 = (GZ *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (uint8_t) ((arg1)->tg); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(GZ,dz_set) { + GZ *arg1 = (GZ *) 0 ; + uint8_t arg2 ; + zval args[1]; + + arg1 = (GZ *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[0]); + /*@SWIG@*/; + + if (arg1) (arg1)->dz = arg2; + +fail: + return; +} + + +static PHP_METHOD(GZ,dz_get) { + GZ *arg1 = (GZ *) 0 ; + uint8_t result; + + arg1 = (GZ *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (uint8_t) ((arg1)->dz); + + RETVAL_LONG(result); + +fail: + return; +} + + + + +PHP_METHOD(GZ,__set) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[2]; + zval tempZval; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if (!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_NULL(); + } + + else if (strcmp(ZSTR_VAL(arg2),"tg") == 0) { + ZVAL_STRING(&tempZval, "tg_set"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,1,&args[1]); + } + + else if (strcmp(ZSTR_VAL(arg2),"dz") == 0) { + ZVAL_STRING(&tempZval, "dz_set"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,1,&args[1]); + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + arg->newobject = zval_get_long(&args[1]); + } +fail: + return; +} + + +PHP_METHOD(GZ,__get) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[1]; + zval tempZval; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if (!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_NULL(); + } + + else if (strcmp(ZSTR_VAL(arg2),"tg") == 0) { + ZVAL_STRING(&tempZval, "tg_get"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,0,NULL); + } + + else if (strcmp(ZSTR_VAL(arg2),"dz") == 0) { + ZVAL_STRING(&tempZval, "dz_get"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,0,NULL); + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + if(arg->newobject) { + RETVAL_LONG(1); + } + else { + RETVAL_LONG(0); + } + } + + else { + RETVAL_NULL(); + } +fail: + return; +} + + +PHP_METHOD(GZ,__isset) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[1]; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if(!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_FALSE; + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + RETVAL_TRUE; + } + + + else if (strcmp(ZSTR_VAL(arg2),"tg") == 0) { + RETVAL_TRUE; + } + + else if (strcmp(ZSTR_VAL(arg2),"dz") == 0) { + RETVAL_TRUE; + } + else { + RETVAL_FALSE; + } +fail: + return; +} + + + + +static PHP_METHOD(Day,fromSolar) { + int arg1 ; + uint8_t arg2 ; + int arg3 ; + zval args[3]; + Day *result = 0 ; + + if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[1]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg3 = (int) zval_get_long(&args[2]); + /*@SWIG@*/; + + result = (Day *)Day::fromSolar(arg1,arg2,arg3); + + SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_Day, 0); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_Day_fromLunar__SWIG_0) { + int arg1 ; + uint8_t arg2 ; + int arg3 ; + bool arg4 ; + zval args[4]; + Day *result = 0 ; + + if(ZEND_NUM_ARGS() != 4 || zend_get_parameters_array_ex(4, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[1]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg3 = (int) zval_get_long(&args[2]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,2,CONVERT_BOOL_IN@*/ + arg4 = (bool) zval_is_true(&args[3]); + /*@SWIG@*/; + + result = (Day *)Day::fromLunar(arg1,arg2,arg3,arg4); + + SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_Day, 0); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_Day_fromLunar__SWIG_1) { + int arg1 ; + uint8_t arg2 ; + int arg3 ; + zval args[3]; + Day *result = 0 ; + + if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[1]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg3 = (int) zval_get_long(&args[2]); + /*@SWIG@*/; + + result = (Day *)Day::fromLunar(arg1,arg2,arg3); + + SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_Day, 0); + +fail: + return; +} + + +static PHP_METHOD(Day,fromLunar) { + int argc; + zval argv[4]; + + argc = ZEND_NUM_ARGS(); + zend_get_parameters_array_ex(argc, argv); + if (argc == 3) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[1]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[2]) == IS_LONG); + if (_v) { + _wrap_Day_fromLunar__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + } + } + if (argc == 4) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[1]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[2]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[3]) == IS_TRUE || Z_TYPE(argv[3]) == IS_FALSE); + if (_v) { + _wrap_Day_fromLunar__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + } + } + } + + zend_throw_exception(zend_ce_type_error, "No matching function for overloaded 'Day_fromLunar'", 0); +fail: + return; +} + + +static PHP_METHOD(Day,after) { + Day *arg1 = (Day *) 0 ; + int arg2 ; + zval args[1]; + Day *result = 0 ; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + result = (Day *)(arg1)->after(arg2); + + SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_Day, 0); + +fail: + return; +} + + +static PHP_METHOD(Day,before) { + Day *arg1 = (Day *) 0 ; + int arg2 ; + zval args[1]; + Day *result = 0 ; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + result = (Day *)(arg1)->before(arg2); + + SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_Day, 0); + +fail: + return; +} + + +static PHP_METHOD(Day,getLunarDay) { + Day *arg1 = (Day *) 0 ; + int result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (int)(arg1)->getLunarDay(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Day,getLunarMonth) { + Day *arg1 = (Day *) 0 ; + uint8_t result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (uint8_t)(arg1)->getLunarMonth(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_Day_getLunarYear__SWIG_0) { + Day *arg1 = (Day *) 0 ; + bool arg2 ; + zval args[1]; + int result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,2,CONVERT_BOOL_IN@*/ + arg2 = (bool) zval_is_true(&args[0]); + /*@SWIG@*/; + + result = (int)(arg1)->getLunarYear(arg2); + + RETVAL_LONG(result); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_Day_getLunarYear__SWIG_1) { + Day *arg1 = (Day *) 0 ; + int result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (int)(arg1)->getLunarYear(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Day,getLunarYear) { + int argc; + zval argv[1]; + + argc = ZEND_NUM_ARGS(); + zend_get_parameters_array_ex(argc, argv); + if (argc == 0) { + _wrap_Day_getLunarYear__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + if (argc == 1) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_TRUE || Z_TYPE(argv[0]) == IS_FALSE); + if (_v) { + _wrap_Day_getLunarYear__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + + zend_throw_exception(zend_ce_type_error, "No matching function for overloaded 'Day_getLunarYear'", 0); +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_Day_getYearGZ__SWIG_0) { + Day *arg1 = (Day *) 0 ; + bool arg2 ; + zval args[1]; + GZ result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,2,CONVERT_BOOL_IN@*/ + arg2 = (bool) zval_is_true(&args[0]); + /*@SWIG@*/; + + result = (arg1)->getYearGZ(arg2); + { + GZ * resultobj = new GZ(result); + + + + + SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_GZ, 1); + } +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_Day_getYearGZ__SWIG_1) { + Day *arg1 = (Day *) 0 ; + GZ result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (arg1)->getYearGZ(); + { + GZ * resultobj = new GZ(result); + + + + + SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_GZ, 1); + } +fail: + return; +} + + +static PHP_METHOD(Day,getYearGZ) { + int argc; + zval argv[1]; + + argc = ZEND_NUM_ARGS(); + zend_get_parameters_array_ex(argc, argv); + if (argc == 0) { + _wrap_Day_getYearGZ__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + if (argc == 1) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_TRUE || Z_TYPE(argv[0]) == IS_FALSE); + if (_v) { + _wrap_Day_getYearGZ__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + + zend_throw_exception(zend_ce_type_error, "No matching function for overloaded 'Day_getYearGZ'", 0); +fail: + return; +} + + +static PHP_METHOD(Day,getMonthGZ) { + Day *arg1 = (Day *) 0 ; + GZ result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (arg1)->getMonthGZ(); + { + GZ * resultobj = new GZ(result); + + + + + SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_GZ, 1); + } +fail: + return; +} + + +static PHP_METHOD(Day,getDayGZ) { + Day *arg1 = (Day *) 0 ; + GZ result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (arg1)->getDayGZ(); + { + GZ * resultobj = new GZ(result); + + + + + SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_GZ, 1); + } +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_Day_getHourGZ__SWIG_0) { + Day *arg1 = (Day *) 0 ; + uint8_t arg2 ; + bool arg3 ; + zval args[2]; + GZ result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,2,CONVERT_BOOL_IN@*/ + arg3 = (bool) zval_is_true(&args[1]); + /*@SWIG@*/; + + result = (arg1)->getHourGZ(arg2,arg3); + { + GZ * resultobj = new GZ(result); + + + + + SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_GZ, 1); + } +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_Day_getHourGZ__SWIG_1) { + Day *arg1 = (Day *) 0 ; + uint8_t arg2 ; + zval args[1]; + GZ result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[0]); + /*@SWIG@*/; + + result = (arg1)->getHourGZ(arg2); + { + GZ * resultobj = new GZ(result); + + + + + SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_GZ, 1); + } +fail: + return; +} + + +static PHP_METHOD(Day,getHourGZ) { + int argc; + zval argv[2]; + + argc = ZEND_NUM_ARGS(); + zend_get_parameters_array_ex(argc, argv); + if (argc == 1) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _wrap_Day_getHourGZ__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + if (argc == 2) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[1]) == IS_TRUE || Z_TYPE(argv[1]) == IS_FALSE); + if (_v) { + _wrap_Day_getHourGZ__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + } + + zend_throw_exception(zend_ce_type_error, "No matching function for overloaded 'Day_getHourGZ'", 0); +fail: + return; +} + + +static PHP_METHOD(Day,isLunarLeap) { + Day *arg1 = (Day *) 0 ; + bool result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (bool)(arg1)->isLunarLeap(); + + RETVAL_BOOL((result) ? 1 : 0); + +fail: + return; +} + + +static PHP_METHOD(Day,getSolarYear) { + Day *arg1 = (Day *) 0 ; + int result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (int)(arg1)->getSolarYear(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Day,getSolarMonth) { + Day *arg1 = (Day *) 0 ; + uint8_t result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (uint8_t)(arg1)->getSolarMonth(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Day,getSolarDay) { + Day *arg1 = (Day *) 0 ; + int result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (int)(arg1)->getSolarDay(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Day,getWeek) { + Day *arg1 = (Day *) 0 ; + uint8_t result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (uint8_t)(arg1)->getWeek(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Day,getWeekIndex) { + Day *arg1 = (Day *) 0 ; + uint8_t result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (uint8_t)(arg1)->getWeekIndex(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Day,hasJieQi) { + Day *arg1 = (Day *) 0 ; + bool result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (bool)(arg1)->hasJieQi(); + + RETVAL_BOOL((result) ? 1 : 0); + +fail: + return; +} + + +static PHP_METHOD(Day,getJieQi) { + Day *arg1 = (Day *) 0 ; + uint8_t result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (uint8_t)(arg1)->getJieQi(); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(Day,getJieQiJD) { + Day *arg1 = (Day *) 0 ; + double result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (double)(arg1)->getJieQiJD(); + + RETVAL_DOUBLE(result); + +fail: + return; +} + + +static PHP_METHOD(Day,getConstellation) { + Day *arg1 = (Day *) 0 ; + uint8_t result; + + arg1 = (Day *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (uint8_t)(arg1)->getConstellation(); + + RETVAL_LONG(result); + +fail: + return; +} + + + + +PHP_METHOD(Day,__set) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[2]; + zval tempZval; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if (!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_NULL(); + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + arg->newobject = zval_get_long(&args[1]); + } +fail: + return; +} + + +PHP_METHOD(Day,__get) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[1]; + zval tempZval; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if (!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_NULL(); + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + if(arg->newobject) { + RETVAL_LONG(1); + } + else { + RETVAL_LONG(0); + } + } + + else { + RETVAL_NULL(); + } +fail: + return; +} + + +PHP_METHOD(Day,__isset) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[1]; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if(!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_FALSE; + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + RETVAL_TRUE; + } + + else { + RETVAL_FALSE; + } +fail: + return; +} + + + + +static PHP_METHOD(JieQiInfo,jd_set) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + double arg2 ; + zval args[1]; + + arg1 = (sxtwl::JieQiInfo *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + arg2 = (double) zval_get_double(&args[0]); + /*@SWIG@*/; + + if (arg1) (arg1)->jd = arg2; + +fail: + return; +} + + +static PHP_METHOD(JieQiInfo,jd_get) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + double result; + + arg1 = (sxtwl::JieQiInfo *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (double) ((arg1)->jd); + + RETVAL_DOUBLE(result); + +fail: + return; +} + + +static PHP_METHOD(JieQiInfo,jqIndex_set) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + uint8_t arg2 ; + zval args[1]; + + arg1 = (sxtwl::JieQiInfo *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[0]); + /*@SWIG@*/; + + if (arg1) (arg1)->jqIndex = arg2; + +fail: + return; +} + + +static PHP_METHOD(JieQiInfo,jqIndex_get) { + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + uint8_t result; + + arg1 = (sxtwl::JieQiInfo *)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr; + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (uint8_t) ((arg1)->jqIndex); + + RETVAL_LONG(result); + +fail: + return; +} + + +static PHP_METHOD(JieQiInfo,__construct) { + sxtwl::JieQiInfo *result = 0 ; + + if(ZEND_NUM_ARGS() != 0) { + WRONG_PARAM_COUNT; + } + + result = (sxtwl::JieQiInfo *)new sxtwl::JieQiInfo(); + + SWIG_SetPointerZval(ZEND_THIS, (void *)result, SWIGTYPE_p_sxtwl__JieQiInfo, 1); + +fail: + return; +} + + + + +PHP_METHOD(JieQiInfo,__set) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[2]; + zval tempZval; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if (!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_NULL(); + } + + else if (strcmp(ZSTR_VAL(arg2),"jd") == 0) { + ZVAL_STRING(&tempZval, "jd_set"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,1,&args[1]); + } + + else if (strcmp(ZSTR_VAL(arg2),"jqIndex") == 0) { + ZVAL_STRING(&tempZval, "jqIndex_set"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,1,&args[1]); + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + arg->newobject = zval_get_long(&args[1]); + } +fail: + return; +} + + +PHP_METHOD(JieQiInfo,__get) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[1]; + zval tempZval; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if (!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_NULL(); + } + + else if (strcmp(ZSTR_VAL(arg2),"jd") == 0) { + ZVAL_STRING(&tempZval, "jd_get"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,0,NULL); + } + + else if (strcmp(ZSTR_VAL(arg2),"jqIndex") == 0) { + ZVAL_STRING(&tempZval, "jqIndex_get"); + call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,0,NULL); + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + if(arg->newobject) { + RETVAL_LONG(1); + } + else { + RETVAL_LONG(0); + } + } + + else { + RETVAL_NULL(); + } +fail: + return; +} + + +PHP_METHOD(JieQiInfo,__isset) { + swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS); + zval args[1]; + zend_string *arg2 = 0; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + if(!arg) { + zend_throw_exception(zend_ce_type_error, "this pointer is NULL", 0); + return; + } + arg2 = Z_STR(args[0]); + + if (!arg2) { + RETVAL_FALSE; + } + + else if (strcmp(ZSTR_VAL(arg2),"thisown") == 0) { + RETVAL_TRUE; + } + + + else if (strcmp(ZSTR_VAL(arg2),"jd") == 0) { + RETVAL_TRUE; + } + + else if (strcmp(ZSTR_VAL(arg2),"jqIndex") == 0) { + RETVAL_TRUE; + } + else { + RETVAL_FALSE; + } +fail: + return; +} + + + + +static PHP_METHOD(sxtwl,fromSolar) { + PHP_FN(fromSolar)(INTERNAL_FUNCTION_PARAM_PASSTHRU); +} + +static PHP_FUNCTION(fromSolar) { + int arg1 ; + uint8_t arg2 ; + int arg3 ; + zval args[3]; + Day *result = 0 ; + + if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[1]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg3 = (int) zval_get_long(&args[2]); + /*@SWIG@*/; + + result = (Day *)sxtwl::fromSolar(arg1,arg2,arg3); + + SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_Day, 0); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_fromLunar__SWIG_0) { + int arg1 ; + uint8_t arg2 ; + int arg3 ; + bool arg4 ; + zval args[4]; + Day *result = 0 ; + + if(ZEND_NUM_ARGS() != 4 || zend_get_parameters_array_ex(4, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[1]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg3 = (int) zval_get_long(&args[2]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,2,CONVERT_BOOL_IN@*/ + arg4 = (bool) zval_is_true(&args[3]); + /*@SWIG@*/; + + result = (Day *)sxtwl::fromLunar(arg1,arg2,arg3,arg4); + + SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_Day, 0); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_fromLunar__SWIG_1) { + int arg1 ; + uint8_t arg2 ; + int arg3 ; + zval args[3]; + Day *result = 0 ; + + if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[1]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg3 = (int) zval_get_long(&args[2]); + /*@SWIG@*/; + + result = (Day *)sxtwl::fromLunar(arg1,arg2,arg3); + + SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_Day, 0); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_fromLunar) { + int argc; + zval argv[4]; + + argc = ZEND_NUM_ARGS(); + zend_get_parameters_array_ex(argc, argv); + if (argc == 3) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[1]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[2]) == IS_LONG); + if (_v) { + _wrap_fromLunar__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + } + } + if (argc == 4) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[1]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[2]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[3]) == IS_TRUE || Z_TYPE(argv[3]) == IS_FALSE); + if (_v) { + _wrap_fromLunar__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + } + } + } + + zend_throw_exception(zend_ce_type_error, "No matching function for overloaded 'fromLunar'", 0); +fail: + return; +} + + +static PHP_METHOD(sxtwl,siZhu2Year) { + PHP_FN(siZhu2Year)(INTERNAL_FUNCTION_PARAM_PASSTHRU); +} + +static PHP_FUNCTION(siZhu2Year) { + GZ arg1 ; + GZ arg2 ; + GZ arg3 ; + GZ arg4 ; + int arg5 ; + int arg6 ; + GZ *tmp1 ; + GZ *tmp2 ; + GZ *tmp3 ; + GZ *tmp4 ; + zval args[6]; + std::vector< double > result; + + if(ZEND_NUM_ARGS() != 6 || zend_get_parameters_array_ex(6, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + if (SWIG_ConvertPtr(&args[0], (void **) &tmp1, SWIGTYPE_p_GZ, 0) < 0 || tmp1 == NULL) { + zend_type_error("Expected SWIGTYPE_p_GZ for argument 1 of siZhu2Year"); + return; + } + arg1 = *tmp1; + + + if (SWIG_ConvertPtr(&args[1], (void **) &tmp2, SWIGTYPE_p_GZ, 0) < 0 || tmp2 == NULL) { + zend_type_error("Expected SWIGTYPE_p_GZ for argument 2 of siZhu2Year"); + return; + } + arg2 = *tmp2; + + + if (SWIG_ConvertPtr(&args[2], (void **) &tmp3, SWIGTYPE_p_GZ, 0) < 0 || tmp3 == NULL) { + zend_type_error("Expected SWIGTYPE_p_GZ for argument 3 of siZhu2Year"); + return; + } + arg3 = *tmp3; + + + if (SWIG_ConvertPtr(&args[3], (void **) &tmp4, SWIGTYPE_p_GZ, 0) < 0 || tmp4 == NULL) { + zend_type_error("Expected SWIGTYPE_p_GZ for argument 4 of siZhu2Year"); + return; + } + arg4 = *tmp4; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg5 = (int) zval_get_long(&args[4]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg6 = (int) zval_get_long(&args[5]); + /*@SWIG@*/; + + result = sxtwl::siZhu2Year(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,arg6); + { + std::vector< double > * resultobj = new std::vector< double >(result); + + + + + SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_std__vectorT_double_t, 1); + } +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_getShiGz__SWIG_0) { + uint8_t arg1 ; + uint8_t arg2 ; + bool arg3 ; + zval args[3]; + GZ result; + + if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (uint8_t) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[1]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,2,CONVERT_BOOL_IN@*/ + arg3 = (bool) zval_is_true(&args[2]); + /*@SWIG@*/; + + result = sxtwl::getShiGz(arg1,arg2,arg3); + { + GZ * resultobj = new GZ(result); + + + + + SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_GZ, 1); + } +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_getShiGz__SWIG_1) { + uint8_t arg1 ; + uint8_t arg2 ; + zval args[2]; + GZ result; + + if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (uint8_t) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[1]); + /*@SWIG@*/; + + result = sxtwl::getShiGz(arg1,arg2); + { + GZ * resultobj = new GZ(result); + + + + + SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_GZ, 1); + } +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_getShiGz) { + int argc; + zval argv[3]; + + argc = ZEND_NUM_ARGS(); + zend_get_parameters_array_ex(argc, argv); + if (argc == 2) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[1]) == IS_LONG); + if (_v) { + _wrap_getShiGz__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + } + if (argc == 3) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[1]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[2]) == IS_TRUE || Z_TYPE(argv[2]) == IS_FALSE); + if (_v) { + _wrap_getShiGz__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + } + } + + zend_throw_exception(zend_ce_type_error, "No matching function for overloaded 'getShiGz'", 0); +fail: + return; +} + + +static PHP_METHOD(sxtwl,getRunMonth) { + PHP_FN(getRunMonth)(INTERNAL_FUNCTION_PARAM_PASSTHRU); +} + +static PHP_FUNCTION(getRunMonth) { + int arg1 ; + zval args[1]; + uint8_t result; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + result = (uint8_t)sxtwl::getRunMonth(arg1); + + RETVAL_LONG(result); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_getLunarMonthNum__SWIG_0) { + int arg1 ; + uint8_t arg2 ; + bool arg3 ; + zval args[3]; + uint8_t result; + + if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[1]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,2,CONVERT_BOOL_IN@*/ + arg3 = (bool) zval_is_true(&args[2]); + /*@SWIG@*/; + + result = (uint8_t)sxtwl::getLunarMonthNum(arg1,arg2,arg3); + + RETVAL_LONG(result); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_getLunarMonthNum__SWIG_1) { + int arg1 ; + uint8_t arg2 ; + zval args[2]; + uint8_t result; + + if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg2 = (uint8_t) zval_get_long(&args[1]); + /*@SWIG@*/; + + result = (uint8_t)sxtwl::getLunarMonthNum(arg1,arg2); + + RETVAL_LONG(result); + +fail: + return; +} + + +static ZEND_NAMED_FUNCTION(_wrap_getLunarMonthNum) { + int argc; + zval argv[3]; + + argc = ZEND_NUM_ARGS(); + zend_get_parameters_array_ex(argc, argv); + if (argc == 2) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[1]) == IS_LONG); + if (_v) { + _wrap_getLunarMonthNum__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + } + if (argc == 3) { + int _v = 0; + _v = (Z_TYPE(argv[0]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[1]) == IS_LONG); + if (_v) { + _v = (Z_TYPE(argv[2]) == IS_TRUE || Z_TYPE(argv[2]) == IS_FALSE); + if (_v) { + _wrap_getLunarMonthNum__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU); return; + } + } + } + } + + zend_throw_exception(zend_ce_type_error, "No matching function for overloaded 'getLunarMonthNum'", 0); +fail: + return; +} + + +static PHP_METHOD(sxtwl,JD2DD) { + PHP_FN(JD2DD)(INTERNAL_FUNCTION_PARAM_PASSTHRU); +} + +static PHP_FUNCTION(JD2DD) { + double arg1 ; + zval args[1]; + Time result; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,48,CONVERT_FLOAT_IN@*/ + arg1 = (double) zval_get_double(&args[0]); + /*@SWIG@*/; + + result = sxtwl::JD2DD(arg1); + { + Time * resultobj = new Time(result); + + + + + SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_Time, 1); + } +fail: + return; +} + + +static PHP_METHOD(sxtwl,toJD) { + PHP_FN(toJD)(INTERNAL_FUNCTION_PARAM_PASSTHRU); +} + +static PHP_FUNCTION(toJD) { + Time *arg1 = 0 ; + zval args[1]; + double result; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + if (SWIG_ConvertPtr(&args[0], (void **) &arg1, SWIGTYPE_p_Time, 0) < 0 || arg1 == NULL) { + zend_type_error("Expected SWIGTYPE_p_Time for argument 1 of toJD"); + return; + } + + result = (double)sxtwl::toJD(*arg1); + + RETVAL_DOUBLE(result); + +fail: + return; +} + + +static PHP_METHOD(sxtwl,getJieQiByYear) { + PHP_FN(getJieQiByYear)(INTERNAL_FUNCTION_PARAM_PASSTHRU); +} + +static PHP_FUNCTION(getJieQiByYear) { + int arg1 ; + zval args[1]; + std::vector< sxtwl::JieQiInfo > result; + + if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + + /*@SWIG:D:\swigwin-4.1.1\Lib\php\utils.i,6,CONVERT_INT_IN@*/ + arg1 = (int) zval_get_long(&args[0]); + /*@SWIG@*/; + + result = sxtwl::getJieQiByYear(arg1); + { + std::vector< sxtwl::JieQiInfo > * resultobj = new std::vector< sxtwl::JieQiInfo >(result); + + + + + SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t, 1); + } +fail: + return; +} + + +/* class object handlers for pointer wrappers */ +static zend_object_handlers swig_ptr_object_handlers; + +/* Object Creation Method for pointer wrapping class */ +static zend_object *swig_ptr_object_new(zend_class_entry *ce) { + swig_object_wrapper *obj = (swig_object_wrapper*)zend_object_alloc(sizeof(swig_object_wrapper), ce); + zend_object_std_init(&obj->std, ce); + object_properties_init(&obj->std, ce); + obj->std.handlers = &swig_ptr_object_handlers; + obj->newobject = 0; + return &obj->std; +} + +/* Implement __toString equivalent, since that worked for the old-style resource wrapped pointers. */ +#if PHP_MAJOR_VERSION < 8 +static int swig_ptr_cast_object(zval *z, zval *retval, int type) { +#elif PHP_MAJOR_VERSION > 8 || PHP_MINOR_VERSION >= 2 +static ZEND_RESULT_CODE swig_ptr_cast_object(zend_object *zobj, zval *retval, int type) { +#else +static int swig_ptr_cast_object(zend_object *zobj, zval *retval, int type) { +#endif + if (type == IS_STRING) { +#if PHP_MAJOR_VERSION < 8 + swig_object_wrapper *obj = SWIG_Z_FETCH_OBJ_P(z); +#else + swig_object_wrapper *obj = swig_php_fetch_object(zobj); +#endif + ZVAL_NEW_STR(retval, zend_strpprintf(0, "SWIGPointer(%p,owned=%d)", obj->ptr, obj->newobject)); + return SUCCESS; + } + return FAILURE; +} + +/* end wrapper section */ +/* arginfo subsection */ +ZEND_BEGIN_ARG_INFO_EX(swig_magic_arginfo_get, 0, 0, 1) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_STRING,NULL) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_magic_arginfo_set, 0, 1, MAY_BE_VOID) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_STRING,NULL) + ZEND_ARG_INFO(0,arg2) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_magic_arginfo_isset, 0, 1, MAY_BE_BOOL) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_STRING,NULL) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_JD2DD, 0, 1, Time, 0) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_DOUBLE,NULL) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_fromLunar, 0, 3, Day, MAY_BE_NULL) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg2,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg3,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg4,MAY_BE_BOOL,NULL) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_fromSolar, 0, 3, Day, MAY_BE_NULL) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg2,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg3,MAY_BE_LONG,NULL) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_getJieQiByYear, 0, 1, JQList, 0) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_getLunarMonthNum, 0, 2, MAY_BE_LONG) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg2,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg3,MAY_BE_BOOL,NULL) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_getRunMonth, 0, 1, MAY_BE_LONG) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_getShiGz, 0, 2, GZ, 0) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg2,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg3,MAY_BE_BOOL,NULL) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_siZhu2Year, 0, 6, JDList, 0) + ZEND_ARG_OBJ_TYPE_MASK(0,arg1,GZ,0,NULL) + ZEND_ARG_OBJ_TYPE_MASK(0,arg2,GZ,0,NULL) + ZEND_ARG_OBJ_TYPE_MASK(0,arg3,GZ,0,NULL) + ZEND_ARG_OBJ_TYPE_MASK(0,arg4,GZ,0,NULL) + ZEND_ARG_TYPE_MASK(0,arg5,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg6,MAY_BE_LONG,NULL) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_toJD, 0, 1, MAY_BE_DOUBLE) + ZEND_ARG_OBJ_TYPE_MASK(0,arg1,Time,0,NULL) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_Day_after, 0, 1, Day, MAY_BE_NULL) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_Day_before swig_arginfo_Day_after +#define swig_arginfo_Day_fromLunar swig_arginfo_fromLunar +#define swig_arginfo_Day_fromSolar swig_arginfo_fromSolar +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_Day_getConstellation, 0, 0, MAY_BE_LONG) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_Day_getDayGZ, 0, 0, GZ, 0) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_Day_getHourGZ, 0, 1, GZ, 0) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg2,MAY_BE_BOOL,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_Day_getJieQi swig_arginfo_Day_getConstellation +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_Day_getJieQiJD, 0, 0, MAY_BE_DOUBLE) +ZEND_END_ARG_INFO() +#define swig_arginfo_Day_getLunarDay swig_arginfo_Day_getConstellation +#define swig_arginfo_Day_getLunarMonth swig_arginfo_Day_getConstellation +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_Day_getLunarYear, 0, 0, MAY_BE_LONG) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_BOOL,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_Day_getMonthGZ swig_arginfo_Day_getDayGZ +#define swig_arginfo_Day_getSolarDay swig_arginfo_Day_getConstellation +#define swig_arginfo_Day_getSolarMonth swig_arginfo_Day_getConstellation +#define swig_arginfo_Day_getSolarYear swig_arginfo_Day_getConstellation +#define swig_arginfo_Day_getWeek swig_arginfo_Day_getConstellation +#define swig_arginfo_Day_getWeekIndex swig_arginfo_Day_getConstellation +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_Day_getYearGZ, 0, 0, GZ, 0) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_BOOL,NULL) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_Day_hasJieQi, 0, 0, MAY_BE_BOOL) +ZEND_END_ARG_INFO() +#define swig_arginfo_Day_isLunarLeap swig_arginfo_Day_hasJieQi +ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_new_GZ, 0, 0, 2) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg2,MAY_BE_LONG,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_GZ_dz_get swig_arginfo_Day_getConstellation +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_GZ_dz_set, 0, 1, MAY_BE_VOID) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_GZ_tg_get swig_arginfo_Day_getConstellation +#define swig_arginfo_GZ_tg_set swig_arginfo_GZ_dz_set +ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_new_JDList, 0, 0, 1) + ZEND_ARG_OBJ_TYPE_MASK(0,arg1,JDList,MAY_BE_LONG,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_JDList_capacity swig_arginfo_Day_getConstellation +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_JDList_clear, 0, 0, MAY_BE_VOID) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_JDList_get, 0, 1, MAY_BE_DOUBLE) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_JDList_is_empty swig_arginfo_Day_hasJieQi +#define swig_arginfo_JDList_pop swig_arginfo_Day_getJieQiJD +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_JDList_push, 0, 1, MAY_BE_VOID) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_DOUBLE,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_JDList_reserve swig_arginfo_GZ_dz_set +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_JDList_set, 0, 2, MAY_BE_VOID) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg2,MAY_BE_DOUBLE,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_JDList_size swig_arginfo_Day_getConstellation +ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_new_JQList, 0, 0, 1) + ZEND_ARG_OBJ_TYPE_MASK(0,arg1,JQList,MAY_BE_LONG,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_JQList_capacity swig_arginfo_Day_getConstellation +#define swig_arginfo_JQList_clear swig_arginfo_JDList_clear +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_JQList_get, 0, 1, JieQiInfo, 0) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_JQList_is_empty swig_arginfo_Day_hasJieQi +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_JQList_pop, 0, 0, JieQiInfo, 0) +ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_JQList_push, 0, 1, MAY_BE_VOID) + ZEND_ARG_OBJ_TYPE_MASK(0,arg1,JieQiInfo,0,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_JQList_reserve swig_arginfo_GZ_dz_set +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_JQList_set, 0, 2, MAY_BE_VOID) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) + ZEND_ARG_OBJ_TYPE_MASK(0,arg2,JieQiInfo,0,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_JQList_size swig_arginfo_Day_getConstellation +ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_new_JieQiInfo, 0, 0, 0) +ZEND_END_ARG_INFO() +#define swig_arginfo_JieQiInfo_jd_get swig_arginfo_Day_getJieQiJD +#define swig_arginfo_JieQiInfo_jd_set swig_arginfo_JDList_push +#define swig_arginfo_JieQiInfo_jqIndex_get swig_arginfo_Day_getConstellation +#define swig_arginfo_JieQiInfo_jqIndex_set swig_arginfo_GZ_dz_set +#define swig_arginfo_Time_D_get swig_arginfo_Day_getConstellation +#define swig_arginfo_Time_D_set swig_arginfo_GZ_dz_set +#define swig_arginfo_Time_M_get swig_arginfo_Day_getConstellation +#define swig_arginfo_Time_M_set swig_arginfo_GZ_dz_set +#define swig_arginfo_Time_Y_get swig_arginfo_Day_getConstellation +#define swig_arginfo_Time_Y_set swig_arginfo_GZ_dz_set +ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_new_Time, 0, 0, 6) + ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg2,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg3,MAY_BE_LONG,NULL) + ZEND_ARG_TYPE_MASK(0,arg4,MAY_BE_DOUBLE,NULL) + ZEND_ARG_TYPE_MASK(0,arg5,MAY_BE_DOUBLE,NULL) + ZEND_ARG_TYPE_MASK(0,arg6,MAY_BE_DOUBLE,NULL) +ZEND_END_ARG_INFO() +#define swig_arginfo_Time_getDay swig_arginfo_Day_getConstellation +#define swig_arginfo_Time_getHour swig_arginfo_Day_getJieQiJD +#define swig_arginfo_Time_getMin swig_arginfo_Day_getJieQiJD +#define swig_arginfo_Time_getMonth swig_arginfo_Day_getConstellation +#define swig_arginfo_Time_getSec swig_arginfo_Day_getJieQiJD +#define swig_arginfo_Time_getYear swig_arginfo_Day_getConstellation +#define swig_arginfo_Time_h_get swig_arginfo_Day_getJieQiJD +#define swig_arginfo_Time_h_set swig_arginfo_JDList_push +#define swig_arginfo_Time_m_get swig_arginfo_Day_getJieQiJD +#define swig_arginfo_Time_m_set swig_arginfo_JDList_push +#define swig_arginfo_Time_s_get swig_arginfo_Day_getJieQiJD +#define swig_arginfo_Time_s_set swig_arginfo_JDList_push +#define swig_arginfo_Time_setDay swig_arginfo_GZ_dz_set +#define swig_arginfo_Time_setHour swig_arginfo_JDList_push +#define swig_arginfo_Time_setMonth swig_arginfo_GZ_dz_set +#define swig_arginfo_Time_setMour swig_arginfo_JDList_push +#define swig_arginfo_Time_setSec swig_arginfo_JDList_push +#define swig_arginfo_Time_setYear swig_arginfo_GZ_dz_set + + +/* class entry subsection */ +static const zend_function_entry class_JDList_functions[] = { + PHP_ME(JDList,__construct,swig_arginfo_new_JDList,ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) + PHP_ME(JDList,size,swig_arginfo_JDList_size,ZEND_ACC_PUBLIC) + PHP_ME(JDList,capacity,swig_arginfo_JDList_capacity,ZEND_ACC_PUBLIC) + PHP_ME(JDList,reserve,swig_arginfo_JDList_reserve,ZEND_ACC_PUBLIC) + PHP_ME(JDList,clear,swig_arginfo_JDList_clear,ZEND_ACC_PUBLIC) + PHP_ME(JDList,push,swig_arginfo_JDList_push,ZEND_ACC_PUBLIC) + PHP_ME(JDList,is_empty,swig_arginfo_JDList_is_empty,ZEND_ACC_PUBLIC) + PHP_ME(JDList,pop,swig_arginfo_JDList_pop,ZEND_ACC_PUBLIC) + PHP_ME(JDList,get,swig_arginfo_JDList_get,ZEND_ACC_PUBLIC) + PHP_ME(JDList,set,swig_arginfo_JDList_set,ZEND_ACC_PUBLIC) + PHP_ME(JDList,__set,swig_magic_arginfo_set,ZEND_ACC_PUBLIC) + PHP_ME(JDList,__get,swig_magic_arginfo_get,ZEND_ACC_PUBLIC) + PHP_ME(JDList,__isset,swig_magic_arginfo_isset,ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + +static const zend_function_entry class_JQList_functions[] = { + PHP_ME(JQList,__construct,swig_arginfo_new_JQList,ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) + PHP_ME(JQList,size,swig_arginfo_JQList_size,ZEND_ACC_PUBLIC) + PHP_ME(JQList,capacity,swig_arginfo_JQList_capacity,ZEND_ACC_PUBLIC) + PHP_ME(JQList,reserve,swig_arginfo_JQList_reserve,ZEND_ACC_PUBLIC) + PHP_ME(JQList,clear,swig_arginfo_JQList_clear,ZEND_ACC_PUBLIC) + PHP_ME(JQList,push,swig_arginfo_JQList_push,ZEND_ACC_PUBLIC) + PHP_ME(JQList,is_empty,swig_arginfo_JQList_is_empty,ZEND_ACC_PUBLIC) + PHP_ME(JQList,pop,swig_arginfo_JQList_pop,ZEND_ACC_PUBLIC) + PHP_ME(JQList,get,swig_arginfo_JQList_get,ZEND_ACC_PUBLIC) + PHP_ME(JQList,set,swig_arginfo_JQList_set,ZEND_ACC_PUBLIC) + PHP_ME(JQList,__set,swig_magic_arginfo_set,ZEND_ACC_PUBLIC) + PHP_ME(JQList,__get,swig_magic_arginfo_get,ZEND_ACC_PUBLIC) + PHP_ME(JQList,__isset,swig_magic_arginfo_isset,ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + +static const zend_function_entry class_Time_functions[] = { + PHP_ME(Time,__construct,swig_arginfo_new_Time,ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) + PHP_ME(Time,Y_set,swig_arginfo_Time_Y_set,ZEND_ACC_PUBLIC) + PHP_ME(Time,Y_get,swig_arginfo_Time_Y_get,ZEND_ACC_PUBLIC) + PHP_ME(Time,M_set,swig_arginfo_Time_M_set,ZEND_ACC_PUBLIC) + PHP_ME(Time,M_get,swig_arginfo_Time_M_get,ZEND_ACC_PUBLIC) + PHP_ME(Time,D_set,swig_arginfo_Time_D_set,ZEND_ACC_PUBLIC) + PHP_ME(Time,D_get,swig_arginfo_Time_D_get,ZEND_ACC_PUBLIC) + PHP_ME(Time,h_set,swig_arginfo_Time_h_set,ZEND_ACC_PUBLIC) + PHP_ME(Time,h_get,swig_arginfo_Time_h_get,ZEND_ACC_PUBLIC) + PHP_ME(Time,m_set,swig_arginfo_Time_m_set,ZEND_ACC_PUBLIC) + PHP_ME(Time,m_get,swig_arginfo_Time_m_get,ZEND_ACC_PUBLIC) + PHP_ME(Time,s_set,swig_arginfo_Time_s_set,ZEND_ACC_PUBLIC) + PHP_ME(Time,s_get,swig_arginfo_Time_s_get,ZEND_ACC_PUBLIC) + PHP_ME(Time,getYear,swig_arginfo_Time_getYear,ZEND_ACC_PUBLIC) + PHP_ME(Time,setYear,swig_arginfo_Time_setYear,ZEND_ACC_PUBLIC) + PHP_ME(Time,setMonth,swig_arginfo_Time_setMonth,ZEND_ACC_PUBLIC) + PHP_ME(Time,getMonth,swig_arginfo_Time_getMonth,ZEND_ACC_PUBLIC) + PHP_ME(Time,getDay,swig_arginfo_Time_getDay,ZEND_ACC_PUBLIC) + PHP_ME(Time,setDay,swig_arginfo_Time_setDay,ZEND_ACC_PUBLIC) + PHP_ME(Time,getHour,swig_arginfo_Time_getHour,ZEND_ACC_PUBLIC) + PHP_ME(Time,setHour,swig_arginfo_Time_setHour,ZEND_ACC_PUBLIC) + PHP_ME(Time,getMin,swig_arginfo_Time_getMin,ZEND_ACC_PUBLIC) + PHP_ME(Time,setMour,swig_arginfo_Time_setMour,ZEND_ACC_PUBLIC) + PHP_ME(Time,getSec,swig_arginfo_Time_getSec,ZEND_ACC_PUBLIC) + PHP_ME(Time,setSec,swig_arginfo_Time_setSec,ZEND_ACC_PUBLIC) + PHP_ME(Time,__set,swig_magic_arginfo_set,ZEND_ACC_PUBLIC) + PHP_ME(Time,__get,swig_magic_arginfo_get,ZEND_ACC_PUBLIC) + PHP_ME(Time,__isset,swig_magic_arginfo_isset,ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + +static const zend_function_entry class_GZ_functions[] = { + PHP_ME(GZ,__construct,swig_arginfo_new_GZ,ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) + PHP_ME(GZ,tg_set,swig_arginfo_GZ_tg_set,ZEND_ACC_PUBLIC) + PHP_ME(GZ,tg_get,swig_arginfo_GZ_tg_get,ZEND_ACC_PUBLIC) + PHP_ME(GZ,dz_set,swig_arginfo_GZ_dz_set,ZEND_ACC_PUBLIC) + PHP_ME(GZ,dz_get,swig_arginfo_GZ_dz_get,ZEND_ACC_PUBLIC) + PHP_ME(GZ,__set,swig_magic_arginfo_set,ZEND_ACC_PUBLIC) + PHP_ME(GZ,__get,swig_magic_arginfo_get,ZEND_ACC_PUBLIC) + PHP_ME(GZ,__isset,swig_magic_arginfo_isset,ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + +static const zend_function_entry class_Day_functions[] = { + PHP_ME(Day,fromSolar,swig_arginfo_Day_fromSolar,ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) + PHP_ME(Day,fromLunar,swig_arginfo_Day_fromLunar,ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) + PHP_ME(Day,after,swig_arginfo_Day_after,ZEND_ACC_PUBLIC) + PHP_ME(Day,before,swig_arginfo_Day_before,ZEND_ACC_PUBLIC) + PHP_ME(Day,getLunarDay,swig_arginfo_Day_getLunarDay,ZEND_ACC_PUBLIC) + PHP_ME(Day,getLunarMonth,swig_arginfo_Day_getLunarMonth,ZEND_ACC_PUBLIC) + PHP_ME(Day,getLunarYear,swig_arginfo_Day_getLunarYear,ZEND_ACC_PUBLIC) + PHP_ME(Day,getYearGZ,swig_arginfo_Day_getYearGZ,ZEND_ACC_PUBLIC) + PHP_ME(Day,getMonthGZ,swig_arginfo_Day_getMonthGZ,ZEND_ACC_PUBLIC) + PHP_ME(Day,getDayGZ,swig_arginfo_Day_getDayGZ,ZEND_ACC_PUBLIC) + PHP_ME(Day,getHourGZ,swig_arginfo_Day_getHourGZ,ZEND_ACC_PUBLIC) + PHP_ME(Day,isLunarLeap,swig_arginfo_Day_isLunarLeap,ZEND_ACC_PUBLIC) + PHP_ME(Day,getSolarYear,swig_arginfo_Day_getSolarYear,ZEND_ACC_PUBLIC) + PHP_ME(Day,getSolarMonth,swig_arginfo_Day_getSolarMonth,ZEND_ACC_PUBLIC) + PHP_ME(Day,getSolarDay,swig_arginfo_Day_getSolarDay,ZEND_ACC_PUBLIC) + PHP_ME(Day,getWeek,swig_arginfo_Day_getWeek,ZEND_ACC_PUBLIC) + PHP_ME(Day,getWeekIndex,swig_arginfo_Day_getWeekIndex,ZEND_ACC_PUBLIC) + PHP_ME(Day,hasJieQi,swig_arginfo_Day_hasJieQi,ZEND_ACC_PUBLIC) + PHP_ME(Day,getJieQi,swig_arginfo_Day_getJieQi,ZEND_ACC_PUBLIC) + PHP_ME(Day,getJieQiJD,swig_arginfo_Day_getJieQiJD,ZEND_ACC_PUBLIC) + PHP_ME(Day,getConstellation,swig_arginfo_Day_getConstellation,ZEND_ACC_PUBLIC) + PHP_ME(Day,__set,swig_magic_arginfo_set,ZEND_ACC_PUBLIC) + PHP_ME(Day,__get,swig_magic_arginfo_get,ZEND_ACC_PUBLIC) + PHP_ME(Day,__isset,swig_magic_arginfo_isset,ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + +static const zend_function_entry class_JieQiInfo_functions[] = { + PHP_ME(JieQiInfo,jd_set,swig_arginfo_JieQiInfo_jd_set,ZEND_ACC_PUBLIC) + PHP_ME(JieQiInfo,jd_get,swig_arginfo_JieQiInfo_jd_get,ZEND_ACC_PUBLIC) + PHP_ME(JieQiInfo,jqIndex_set,swig_arginfo_JieQiInfo_jqIndex_set,ZEND_ACC_PUBLIC) + PHP_ME(JieQiInfo,jqIndex_get,swig_arginfo_JieQiInfo_jqIndex_get,ZEND_ACC_PUBLIC) + PHP_ME(JieQiInfo,__construct,swig_arginfo_new_JieQiInfo,ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) + PHP_ME(JieQiInfo,__set,swig_magic_arginfo_set,ZEND_ACC_PUBLIC) + PHP_ME(JieQiInfo,__get,swig_magic_arginfo_get,ZEND_ACC_PUBLIC) + PHP_ME(JieQiInfo,__isset,swig_magic_arginfo_isset,ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + + + +/* entry subsection */ +/* Every non-class user visible function must have an entry here */ +static const zend_function_entry module_sxtwl_functions[] = { + PHP_FE(fromSolar,swig_arginfo_fromSolar) + ZEND_NAMED_FE(fromlunar,_wrap_fromLunar,swig_arginfo_fromLunar) + PHP_FE(siZhu2Year,swig_arginfo_siZhu2Year) + ZEND_NAMED_FE(getshigz,_wrap_getShiGz,swig_arginfo_getShiGz) + PHP_FE(getRunMonth,swig_arginfo_getRunMonth) + ZEND_NAMED_FE(getlunarmonthnum,_wrap_getLunarMonthNum,swig_arginfo_getLunarMonthNum) + PHP_FE(JD2DD,swig_arginfo_JD2DD) + PHP_FE(toJD,swig_arginfo_toJD) + PHP_FE(getJieQiByYear,swig_arginfo_getJieQiByYear) + ZEND_FE_END +}; + +static const zend_function_entry class_sxtwl_functions[] = { + PHP_ME(sxtwl,fromSolar,swig_arginfo_fromSolar,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + ZEND_NAMED_ME(fromlunar,_wrap_fromLunar,swig_arginfo_fromLunar,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + PHP_ME(sxtwl,siZhu2Year,swig_arginfo_siZhu2Year,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + ZEND_NAMED_ME(getshigz,_wrap_getShiGz,swig_arginfo_getShiGz,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + PHP_ME(sxtwl,getRunMonth,swig_arginfo_getRunMonth,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + ZEND_NAMED_ME(getlunarmonthnum,_wrap_getLunarMonthNum,swig_arginfo_getLunarMonthNum,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + PHP_ME(sxtwl,JD2DD,swig_arginfo_JD2DD,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + PHP_ME(sxtwl,toJD,swig_arginfo_toJD,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + PHP_ME(sxtwl,getJieQiByYear,swig_arginfo_getJieQiByYear,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + ZEND_FE_END +}; + +/* init section */ +zend_module_entry sxtwl_module_entry = { + STANDARD_MODULE_HEADER, + "sxtwl", + module_sxtwl_functions, + PHP_MINIT(sxtwl), + NULL, /* No MSHUTDOWN code */ + NULL, /* No RINIT code */ + NULL, /* No RSHUTDOWN code */ + NULL, /* No MINFO code */ + NO_VERSION_YET, + STANDARD_MODULE_PROPERTIES +}; + +#ifdef __cplusplus +extern "C" { +#endif +SWIGEXPORT zend_module_entry *get_module(void) { return &sxtwl_module_entry; } +#ifdef __cplusplus +} +#endif + +#define SWIG_php_minit PHP_MINIT_FUNCTION(sxtwl) + +/* ----------------------------------------------------------------------------- + * 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 + + +SWIG_php_minit { + zend_class_entry SWIGUNUSED internal_ce; + SWIG_InitializeModule((void*)&module_number); +#if PHP_MAJOR_VERSION == 8 && PHP_MINOR_VERSION == 0 + /* This hack is needed to avoid segfaults. */ + EG(class_table) = CG(class_table); +#endif + + /* oinit subsection */ + INIT_CLASS_ENTRY(internal_ce, "JDList", class_JDList_functions); + SWIG_Php_ce_JDList = zend_register_internal_class(&internal_ce); +#ifdef ZEND_ACC_NO_DYNAMIC_PROPERTIES + SWIG_Php_ce_JDList->ce_flags |= ZEND_ACC_NO_DYNAMIC_PROPERTIES; +#endif + INIT_CLASS_ENTRY(SWIG_Php_swig_wrapped_interface_ce, "SWIG\\wrapped", NULL); + zend_do_implement_interface(SWIG_Php_ce_JDList, &SWIG_Php_swig_wrapped_interface_ce); + Swig_Php_base_object_handlers = *zend_get_std_object_handlers(); + Swig_Php_base_object_handlers.offset = XtOffsetOf(swig_object_wrapper, std); + Swig_Php_base_object_handlers.clone_obj = NULL; + SWIG_Php_ce_JDList->create_object = SWIG_Php_create_object_JDList; + JDList_object_handlers = Swig_Php_base_object_handlers; + JDList_object_handlers.free_obj = SWIG_Php_free_obj_JDList; +#ifdef SWIGTYPE_p_std__vectorT_double_t + SWIG_TypeClientData(SWIGTYPE_p_std__vectorT_double_t,SWIG_Php_ce_JDList); +#endif + + INIT_CLASS_ENTRY(internal_ce, "JQList", class_JQList_functions); + SWIG_Php_ce_JQList = zend_register_internal_class(&internal_ce); +#ifdef ZEND_ACC_NO_DYNAMIC_PROPERTIES + SWIG_Php_ce_JQList->ce_flags |= ZEND_ACC_NO_DYNAMIC_PROPERTIES; +#endif + zend_do_implement_interface(SWIG_Php_ce_JQList, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_Php_ce_JQList->create_object = SWIG_Php_create_object_JQList; + JQList_object_handlers = Swig_Php_base_object_handlers; + JQList_object_handlers.free_obj = SWIG_Php_free_obj_JQList; +#ifdef SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t + SWIG_TypeClientData(SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_t,SWIG_Php_ce_JQList); +#endif + + INIT_CLASS_ENTRY(internal_ce, "sxtwl", class_sxtwl_functions); + SWIG_Php_ce_sxtwl = zend_register_internal_class(&internal_ce); + + INIT_CLASS_ENTRY(internal_ce, "Time", class_Time_functions); + SWIG_Php_ce_Time = zend_register_internal_class(&internal_ce); +#ifdef ZEND_ACC_NO_DYNAMIC_PROPERTIES + SWIG_Php_ce_Time->ce_flags |= ZEND_ACC_NO_DYNAMIC_PROPERTIES; +#endif + zend_do_implement_interface(SWIG_Php_ce_Time, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_Php_ce_Time->create_object = SWIG_Php_create_object_Time; + Time_object_handlers = Swig_Php_base_object_handlers; + Time_object_handlers.free_obj = SWIG_Php_free_obj_Time; +#ifdef SWIGTYPE_p_Time + SWIG_TypeClientData(SWIGTYPE_p_Time,SWIG_Php_ce_Time); +#endif + + INIT_CLASS_ENTRY(internal_ce, "GZ", class_GZ_functions); + SWIG_Php_ce_GZ = zend_register_internal_class(&internal_ce); +#ifdef ZEND_ACC_NO_DYNAMIC_PROPERTIES + SWIG_Php_ce_GZ->ce_flags |= ZEND_ACC_NO_DYNAMIC_PROPERTIES; +#endif + zend_do_implement_interface(SWIG_Php_ce_GZ, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_Php_ce_GZ->create_object = SWIG_Php_create_object_GZ; + GZ_object_handlers = Swig_Php_base_object_handlers; + GZ_object_handlers.free_obj = SWIG_Php_free_obj_GZ; +#ifdef SWIGTYPE_p_GZ + SWIG_TypeClientData(SWIGTYPE_p_GZ,SWIG_Php_ce_GZ); +#endif + + INIT_CLASS_ENTRY(internal_ce, "Day", class_Day_functions); + SWIG_Php_ce_Day = zend_register_internal_class(&internal_ce); +#ifdef ZEND_ACC_NO_DYNAMIC_PROPERTIES + SWIG_Php_ce_Day->ce_flags |= ZEND_ACC_NO_DYNAMIC_PROPERTIES; +#endif + zend_do_implement_interface(SWIG_Php_ce_Day, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_Php_ce_Day->create_object = SWIG_Php_create_object_Day; + Day_object_handlers = Swig_Php_base_object_handlers; + Day_object_handlers.free_obj = SWIG_Php_free_obj_Day; +#ifdef SWIGTYPE_p_Day + SWIG_TypeClientData(SWIGTYPE_p_Day,SWIG_Php_ce_Day); +#endif + + INIT_CLASS_ENTRY(internal_ce, "JieQiInfo", class_JieQiInfo_functions); + SWIG_Php_ce_JieQiInfo = zend_register_internal_class(&internal_ce); +#ifdef ZEND_ACC_NO_DYNAMIC_PROPERTIES + SWIG_Php_ce_JieQiInfo->ce_flags |= ZEND_ACC_NO_DYNAMIC_PROPERTIES; +#endif + zend_do_implement_interface(SWIG_Php_ce_JieQiInfo, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_Php_ce_JieQiInfo->create_object = SWIG_Php_create_object_JieQiInfo; + JieQiInfo_object_handlers = Swig_Php_base_object_handlers; + JieQiInfo_object_handlers.free_obj = SWIG_Php_free_obj_JieQiInfo; +#ifdef SWIGTYPE_p_sxtwl__JieQiInfo + SWIG_TypeClientData(SWIGTYPE_p_sxtwl__JieQiInfo,SWIG_Php_ce_JieQiInfo); +#endif + + + /* Register classes to represent non-class pointer types */ + swig_ptr_object_handlers = *zend_get_std_object_handlers(); + swig_ptr_object_handlers.offset = XtOffsetOf(swig_object_wrapper, std); + swig_ptr_object_handlers.cast_object = swig_ptr_cast_object; + INIT_CLASS_ENTRY(internal_ce, "SWIG\\_p_int", NULL); + SWIG_Php_ce__p_int = zend_register_internal_class(&internal_ce); + SWIG_Php_ce__p_int->create_object = swig_ptr_object_new; + zend_do_implement_interface(SWIG_Php_ce__p_int, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_TypeClientData(SWIGTYPE_p_int,SWIG_Php_ce__p_int); + + INIT_CLASS_ENTRY(internal_ce, "SWIG\\_p_size_type", NULL); + SWIG_Php_ce__p_size_type = zend_register_internal_class(&internal_ce); + SWIG_Php_ce__p_size_type->create_object = swig_ptr_object_new; + zend_do_implement_interface(SWIG_Php_ce__p_size_type, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_TypeClientData(SWIGTYPE_p_size_type,SWIG_Php_ce__p_size_type); + + INIT_CLASS_ENTRY(internal_ce, "SWIG\\_p_value_type", NULL); + SWIG_Php_ce__p_value_type = zend_register_internal_class(&internal_ce); + SWIG_Php_ce__p_value_type->create_object = swig_ptr_object_new; + zend_do_implement_interface(SWIG_Php_ce__p_value_type, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_TypeClientData(SWIGTYPE_p_value_type,SWIG_Php_ce__p_value_type); + + INIT_CLASS_ENTRY(internal_ce, "SWIG\\_p_unsigned_char", NULL); + SWIG_Php_ce__p_unsigned_char = zend_register_internal_class(&internal_ce); + SWIG_Php_ce__p_unsigned_char->create_object = swig_ptr_object_new; + zend_do_implement_interface(SWIG_Php_ce__p_unsigned_char, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_TypeClientData(SWIGTYPE_p_unsigned_char,SWIG_Php_ce__p_unsigned_char); + + INIT_CLASS_ENTRY(internal_ce, "SWIG\\_p_unsigned_short", NULL); + SWIG_Php_ce__p_unsigned_short = zend_register_internal_class(&internal_ce); + SWIG_Php_ce__p_unsigned_short->create_object = swig_ptr_object_new; + zend_do_implement_interface(SWIG_Php_ce__p_unsigned_short, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_TypeClientData(SWIGTYPE_p_unsigned_short,SWIG_Php_ce__p_unsigned_short); + + INIT_CLASS_ENTRY(internal_ce, "SWIG\\_p_signed_char", NULL); + SWIG_Php_ce__p_signed_char = zend_register_internal_class(&internal_ce); + SWIG_Php_ce__p_signed_char->create_object = swig_ptr_object_new; + zend_do_implement_interface(SWIG_Php_ce__p_signed_char, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_TypeClientData(SWIGTYPE_p_signed_char,SWIG_Php_ce__p_signed_char); + + INIT_CLASS_ENTRY(internal_ce, "SWIG\\_p_long_long", NULL); + SWIG_Php_ce__p_long_long = zend_register_internal_class(&internal_ce); + SWIG_Php_ce__p_long_long->create_object = swig_ptr_object_new; + zend_do_implement_interface(SWIG_Php_ce__p_long_long, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_TypeClientData(SWIGTYPE_p_long_long,SWIG_Php_ce__p_long_long); + + INIT_CLASS_ENTRY(internal_ce, "SWIG\\_p_unsigned_int", NULL); + SWIG_Php_ce__p_unsigned_int = zend_register_internal_class(&internal_ce); + SWIG_Php_ce__p_unsigned_int->create_object = swig_ptr_object_new; + zend_do_implement_interface(SWIG_Php_ce__p_unsigned_int, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_TypeClientData(SWIGTYPE_p_unsigned_int,SWIG_Php_ce__p_unsigned_int); + + INIT_CLASS_ENTRY(internal_ce, "SWIG\\_p_unsigned_long_long", NULL); + SWIG_Php_ce__p_unsigned_long_long = zend_register_internal_class(&internal_ce); + SWIG_Php_ce__p_unsigned_long_long->create_object = swig_ptr_object_new; + zend_do_implement_interface(SWIG_Php_ce__p_unsigned_long_long, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_TypeClientData(SWIGTYPE_p_unsigned_long_long,SWIG_Php_ce__p_unsigned_long_long); + + INIT_CLASS_ENTRY(internal_ce, "SWIG\\_int", NULL); + SWIG_Php_ce__int = zend_register_internal_class(&internal_ce); + SWIG_Php_ce__int->create_object = swig_ptr_object_new; + zend_do_implement_interface(SWIG_Php_ce__int, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_TypeClientData(SWIGTYPE_int,SWIG_Php_ce__int); + + INIT_CLASS_ENTRY(internal_ce, "SWIG\\_p_short", NULL); + SWIG_Php_ce__p_short = zend_register_internal_class(&internal_ce); + SWIG_Php_ce__p_short->create_object = swig_ptr_object_new; + zend_do_implement_interface(SWIG_Php_ce__p_short, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_TypeClientData(SWIGTYPE_p_short,SWIG_Php_ce__p_short); + + INIT_CLASS_ENTRY(internal_ce, "SWIG\\_p_difference_type", NULL); + SWIG_Php_ce__p_difference_type = zend_register_internal_class(&internal_ce); + SWIG_Php_ce__p_difference_type->create_object = swig_ptr_object_new; + zend_do_implement_interface(SWIG_Php_ce__p_difference_type, &SWIG_Php_swig_wrapped_interface_ce); + SWIG_TypeClientData(SWIGTYPE_p_difference_type,SWIG_Php_ce__p_difference_type); + + /* end oinit subsection */ + + /* cinit subsection */ +SWIG_LONG_CONSTANT(J2000, (int)(2451545)); + + zend_declare_class_constant_long(SWIG_Php_ce_sxtwl, "J2000", sizeof("J2000") - 1, (int)(2451545)); + + /* end cinit subsection */ + + return SUCCESS; +} + +/* end init section */ diff --git a/export/python/README.md b/export/python/README.md new file mode 100644 index 0000000..9bcedb8 --- /dev/null +++ b/export/python/README.md @@ -0,0 +1 @@ +python的接口导出目录在工程的根目录下的python目录中 \ No newline at end of file diff --git a/ndk_build.py b/ndk_build.py new file mode 100644 index 0000000..ec94b87 --- /dev/null +++ b/ndk_build.py @@ -0,0 +1,290 @@ +#-*-coding:utf-8-*- + +import os +import shutil +import zipfile +import hashlib +import sys +import platform +import requests +import urllib +import subprocess + +#工具类 +class Utils(): + #如果目录不存，则创建。 + @staticmethod + def mkDir(dirPath): + if os.path.exists(dirPath) and os.path.isdir(dirPath): + return + parent = os.path.dirname(dirPath) + if not (os.path.exists(parent) and os.path.isdir(parent)): + Utils.mkDir(parent) + + os.mkdir(dirPath) + + #获取某个目录是否含有某个文件, extList获取指定的文件后缀 + @staticmethod + def getAllDirFiles(dirPath, extList = None): + ret = [] + for file in os.listdir( dirPath): + if os.path.isfile(os.path.join(dirPath, file)): + ret.append(os.path.join(dirPath, file)) + else: + ret += Utils.getAllDirFiles(os.path.join(dirPath, file)) + + #需要过滤某些文件 + if extList != None: + extList = [tmp.lower() for tmp in extList] + ret = [path for path in ret if os.path.splitext(path)[1].lower() in extList] + return ret + + #清理掉某个数据 + @staticmethod + def cleanFile(path): + if not os.path.exists(path): + return + if os.path.isdir(path): + shutil.rmtree(path) + elif os.path.isfile(path): + os.remove(path) + + #将一个文件夹压缩成zip文件 + @staticmethod + def makeZipFile(fileName, fromDir): + fileList = Utils.getAllDirFiles(fromDir) + with zipfile.ZipFile(fileName , 'w') as zip: + for file in fileList: + zip.write(file, os.path.relpath(file, fromDir)) + + @staticmethod + def extractZipFile(fileName, toDir = "."): + file_zip = zipfile.ZipFile(fileName, 'r') + for file in file_zip.namelist(): + file_zip.extract(file, toDir) + file_zip.close() + + + @staticmethod + def sha256_checksum(filename, block_size=65536): + sha256 = hashlib.sha256() + with open(filename, 'rb') as f: + for block in iter(lambda: f.read(block_size), b''): + sha256.update(block) + return sha256.hexdigest() + +#获取python文件所在的路径 +def p(): + frozen = "not" + if getattr(sys, 'frozen',False): + frozen = "ever so" + return os.path.dirname(sys.executable) + + return os.path.split(os.path.realpath(__file__))[0] + +#下载进度条回调 +def callbackfunc(blocknum, blocksize, totalsize): + '''回调函数 + @blocknum: 已经下载的数据块 + @blocksize: 数据块的大小 + @totalsize: 远程文件的大小 + ''' + percent = 100.0 * blocknum * blocksize / totalsize + if percent > 100: + percent = 100 + + max_arrow = 50 #进度条的长度 + num_arrow = int(percent * max_arrow/100.0) + + process_bar = '\r[' + '>' * num_arrow + '#' * (max_arrow - num_arrow) + ']'\ + + '%.2f%%' % percent #带输出的字符串，'\r'表示不换行回到最左边 + sys.stdout.write(process_bar) #这两句打印字符到终端 + sys.stdout.flush() + +#andoird sdk 的操作sdk路径 +class AndroidSDK(): + def __init__(self): + self.ANDROID_SDK = self.getAndroidSDKPath() + if self.ANDROID_SDK == None: + self.ANDROID_SDK = self.installAndroidSDK() + #更新android sdk + self.updateSDK(['platforms;android-16']) + + self.cmakeDir = self.getCmakeDir() + if self.cmakeDir == None: + self.updateSDK(['cmake;3.6.4111459']) + self.cmakeDir = self.getCmakeDir() + + self.NDKPath = self.getNDKPath() + if self.NDKPath == None: + self.updateSDK(['ndk-bundle']) + self.NDKPath = self.getNDKPath() + + + def installAndroidSDK(self): + sysstr = platform.system().lower() + + SHA_256 = { + "windows":'7e81d69c303e47a4f0e748a6352d85cd0c8fd90a5a95ae4e076b5e5f960d3c7a', + 'darwin':'ecb29358bc0f13d7c2fa0f9290135a5b608e38434aad9bf7067d0252c160853e', + 'linux':'92ffee5a1d98d856634e8b71132e8a95d96c83a63fde1099be3d86df3106def9', + } + + #是否需要下载包 + needDownload = True + android_sdk_zip = "android_sdk.zip" + if os.path.isfile(android_sdk_zip): + sha256 = Utils.sha256_checksum(android_sdk_zip) + if sha256.lower() == SHA_256[sysstr]: + needDownload = False + + print u"下载Android_sdk" + #下载包 + if needDownload: + sdk_download_url = 'https://dl.google.com/android/repository/sdk-tools-%s-4333796.zip'%(sysstr, ) + urllib.urlretrieve(sdk_download_url, android_sdk_zip, callbackfunc) + + #解压文件 + Utils.extractZipFile(android_sdk_zip, "./android_sdk") + os.environ['ANDROID_HOME'] = os.path.realpath("android_sdk") + return os.environ['ANDROID_HOME'] + + def updateSDK(self, package = [ 'platforms;android-16', 'cmake;3.6.4111459', 'ndk-bundle' ]): + sdkmanager = os.path.join(self.ANDROID_SDK, 'tools/bin/sdkmanager') + if "windows" == platform.system().lower(): + sdkmanager = sdkmanager + '.bat' + else: + cmd = 'chmod +x %s' %(sdkmanager,) + os.system(cmd) + + args = ['"%s"' %(key) for key in package] + + args.insert(0, sdkmanager) + cmd = 'echo y|' + " ".join(args) + os.system(cmd) + + + #获取sdk里的 cmake 信息 + def getCmakeDir(self): + ndk_cmake_dir = os.path.join(self.ANDROID_SDK, "cmake") + if not os.path.isdir(ndk_cmake_dir): + return None + + cmake_dir_list = os.listdir(ndk_cmake_dir) + list_len = len(cmake_dir_list) + if list_len <= 0: + return None + + return os.path.join(ndk_cmake_dir, cmake_dir_list[list_len - 1] ) + + + def getNDKPath(self): + #通过系统变量来寻找 + environ_names = [ + 'NDK_ROOT', + ] + + for name in environ_names: + #环境变量里不存在 + if name not in os.environ.keys(): + continue + + android_ndk_path = os.environ[name] + #验证如果不存在此目录 + if not os.path.isdir(android_ndk_path): + continue + + return android_ndk_path + + ndk_bundle_dir = os.path.join(self.ANDROID_SDK, "ndk-bundle/toolchains") + if os.path.isdir(ndk_bundle_dir): + return os.path.join(self.ANDROID_SDK, "ndk-bundle") + + + # 根据系统变量android sdk的路径 + def getAndroidSDKPath(self): + environ_names = [ + 'ANDROID_HOME', + 'ANDROID_SDK_ROOT' + ] + + for name in environ_names: + #环境变量里不存在 + if name not in os.environ.keys(): + continue + + android_sdk_path = os.environ[name] + #验证如果不存在此目录 + if not os.path.isdir(android_sdk_path): + continue + + return android_sdk_path + + #没有找到相应的sdk路径 + return None + + +if '__main__' == __name__: + android_sdk = AndroidSDK() + ANDROID_SDK = android_sdk.getAndroidSDKPath() + ANDROID_NDK =android_sdk.getNDKPath() + + ANDROID_CMAKE = os.path.join(android_sdk.getCmakeDir(), 'bin/cmake') + ANDROID_NINJA=os.path.join(android_sdk.getCmakeDir(),'bin/ninja') + + if "windows" == platform.system().lower(): + ANDROID_CMAKE = ANDROID_CMAKE + '.exe' + ANDROID_NINJA = ANDROID_NINJA + '.exe' + + pyPath = p() + buildDir = os.path.join(pyPath, "build") + outDir = os.path.join(pyPath, "out") + + + Utils().cleanFile(outDir) + Utils().mkDir(outDir) + + #需要打包的abi + abiList = [ + 'armeabi', + 'armeabi-v7a', + "arm64-v8a", + "x86", + 'x86_64', + 'mips', + 'mips64', + ] + for abi in abiList: + os.chdir(pyPath) + Utils().cleanFile(buildDir) + Utils().mkDir(buildDir) + os.chdir(buildDir) + + cmd = '''%s -DANDROID_ABI=%s \ + -DANDROID_PLATFORM=android-16 \ + -DCMAKE_BUILD_TYPE=Release \ + -DANDROID_NDK=%s \ + -DCMAKE_CXX_FLAGS=-std=c++11 -frtti -fexceptions \ + -DCMAKE_TOOLCHAIN_FILE=%s/build/cmake/android.toolchain.cmake \ + -DCMAKE_MAKE_PROGRAM=%s -G "Ninja" \ + -DCONSOLE=1 \ + -DSXTWL_WRAPPER_JAVA=1 ..'''%(ANDROID_CMAKE,abi,ANDROID_NDK,ANDROID_NDK,ANDROID_NINJA ) + + os.system(cmd) + os.system("%s --build ."%(ANDROID_CMAKE, )) + + outSoPath = os.path.join(outDir, "jniLibs/" + abi) + Utils().cleanFile(outSoPath) + Utils().mkDir(outSoPath) + + outJavaPath = os.path.join(outDir, "java/com/huoyaojing") + if not os.path.isdir(outJavaPath): + Utils().mkDir(outJavaPath) + fileList = Utils.getAllDirFiles(buildDir, [".java"]) + for tmp in fileList: + basename = os.path.basename(tmp) + shutil.move(tmp, os.path.join(outJavaPath, basename)) + + + shutil.move(os.path.join(buildDir, "libsxtwl_java.so"),os.path.join(outSoPath, "libsxtwl_java.so")) + \ No newline at end of file diff --git a/python/.gitignore b/python/.gitignore new file mode 100644 index 0000000..d5a5644 --- /dev/null +++ b/python/.gitignore @@ -0,0 +1,106 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST +sxtwl.egg-info +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version +.idea/ +# celery beat schedule file +celerybeat-schedule +workspace.xml +# SageMath parsed files +*.sage.py +.idea/workspace.xml +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ + +/src diff --git a/python/MANIFEST.in b/python/MANIFEST.in new file mode 100644 index 0000000..6e8673e --- /dev/null +++ b/python/MANIFEST.in @@ -0,0 +1 @@ +recursive-include src *.h \ No newline at end of file diff --git a/python/README.md b/python/README.md new file mode 100644 index 0000000..1efda32 --- /dev/null +++ b/python/README.md @@ -0,0 +1,244 @@ +### 介绍 + +sxtwl_cpp是参考[寿星天文历](http://www.nongli.net/sxwnl/)并使用C++实现日历库。因为其依据天文历法算法实现，故其可查询范围广(BC722年以后与实历相符，支持1800年以前及2200年以后的日历查询)。支持Android、IOS、Windows、MacOS、Linux等平台。使用swig暴露接口给python,lua,java等语言使用。 + + +### 安装方法 + +``` +pip install sxtwl +``` + +旧工程代码兼容 +如果有已使用V1.x版本的工程，想兼容代码 +``` +pip install sxtwl==1.1.0 +``` +或者在requirements.txt里修改 +``` +sxtwl 1.1.0 +``` + +具体使用方法参考： +https://pypi.org/project/sxtwl/ + +本项目 [GitHub](https://github.com/yuangu/sxtwl_cpp) / [Gitee（码云）](https://gitee.com/yuangu/sxtwl)。 + + +### 使用方法 + + 注:因为pip上传后不能二次修改，参考事例可能会有错误无法修改，如果发现下面例子不能用，请以为准: [传送门](https://github.com/yuangu/sxtwl_cpp/blob/master/example/main.py) + + +1. 因为考虑到繁体和简体字的原因，所以本库不以硬编码的形式显示结果。下面是参考的简单索引 +``` +Gan = ["甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"] +Zhi = ["子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"] +ShX = ["鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪"] +numCn = ["零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十"] +jqmc = ["冬至", "小寒", "大寒", "立春", "雨水", "惊蛰", "春分", "清明", "谷雨", "立夏", + "小满", "芒种", "夏至", "小暑", "大暑", "立秋", "处暑","白露", "秋分", "寒露", "霜降", + "立冬", "小雪", "大雪"] +ymc = ["十一", "十二", "正", "二", "三", "四", "五", "六", "七", "八", "九", "十" ] +rmc = ["初一", "初二", "初三", "初四", "初五", "初六", "初七", "初八", "初九", "初十", + "十一", "十二", "十三", "十四", "十五", "十六", "十七", "十八", "十九", "二十", + "廿一", "廿二", "廿三", "廿四", "廿五", "廿六", "廿七", "廿八", "廿九", "三十", "卅一"] +XiZ = ['摩羯', '水瓶', '双鱼', '白羊', '金牛', '双子', '巨蟹', '狮子', '处女', '天秤', '天蝎', '射手'] +WeekCn = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"] +``` + +2. 引入本库 +``` +import sxtwl + +# 从公历年月日获取一天的信息 +day = sxtwl.fromSolar(2021, 11, 7) + +# 从农历年月日获取一天的信息 +day = sxtwl.fromLunar(2020, 12, 1) +``` + +3. 获取某天的信息(这里的信息有，阴历，阳历，二十四节气，天干地支，星期几等) + +``` +# 公历的年月日 +s = "公历:%d年%d月%d日" % (day.getSolarYear(), day.getSolarMonth(), day.getSolarDay()) +print(s) + +# 星期几 +print(WeekCn[day.getWeek()]) + +# 这个月的第几周 +print('该日属于这个月的第%d周'%(day.getWeekIndex(),)) + +# 星座(有bug?待修复) +print("星座:", XiZ[day.getConstellation()]) + +# 以春节为界的农历(注getLunarYear如果没有传参，或者传true，是以春节为界的) +s = "农历:%d年%s%d月%d日" % (day.getLunarYear(), + '闰' if day.isLunarLeap() else '', day.getLunarMonth(), day.getLunarDay()) +print(s) + +# 以立春为界的农历 +s = "农历:%d年%s%d月%d日" % (day.getLunarYear(False), + '闰' if day.isLunarLeap() else '', day.getLunarMonth(), day.getLunarDay()) +print(s) + + +# 以春节为界的天干地支 +yTG = day.getYearGZ(True) +print("以春节为界的年干支", Gan[yTG.tg] + Zhi[yTG.dz]) +print("以春节为界的生肖:", ShX[yTG.dz]) + +# 以立春为界的天干地支 （注，如果没有传参，或者传false，是以立春为界的。刚好和getLunarYear相反） +yTG = day.getYearGZ() +print("以立春为界的年干支", Gan[yTG.tg] + Zhi[yTG.dz]) +print("以立春为界的生肖:", ShX[yTG.dz]) + +#月干支 +mTG = day.getMonthGZ() +print("月干支", Gan[mTG.tg] + Zhi[mTG.dz]) + +#日干支 +dTG = day.getDayGZ() +print("日干支", Gan[dTG.tg] + Zhi[dTG.dz]) + + +#时干支,传24小时制的时间，分早晚子时 +hour = 18 +sTG = day.getHourGZ(hour) +print("%d时的干支"%(hour, ), Gan[sTG.tg] + Zhi[sTG.dz]) + + +#时干支 +for hour in range(24): + # 第一个参数为该天的天干，第二个参数为小时 + hTG = sxtwl.getShiGz(dTG.tg, hour) + print("%d时天干地支:"%(hour), Gan[hTG.tg] + Zhi[hTG.dz]) + + +# 当日是否有节气 +if day.hasJieQi(): + print('节气：%s'% jqmc[day.getJieQi()]) + #获取节气的儒略日数 + jd = day.getJieQiJD() + # 将儒略日数转换成年月日时秒 + t = sxtwl.JD2DD(jd ) + + # 注意，t.s是小数，需要四舍五入 + print("节气时间:%d-%d-%d %d:%d:%d"%(t.Y, t.M, t.D, t.h, t.m, round(t.s))) +else: + print("当天不是节气日") + +``` + +4. 获取某日的前几天或者后几天的信息 （可以用到很多场景中） +``` +# 获取某天的后面几天 +num = 1 #你喜欢写多少天 也多少天，可以写负数，相当于往前 +day = day.after(num) #获取num天后的日信息 +s = "公历:%d年%d月%d日" % (day.getSolarYear(), day.getSolarMonth(), day.getSolarDay()) +print(s) + +# 同上 +day = day.before(num) +s = "公历:%d年%d月%d日" % (day.getSolarYear(), day.getSolarMonth(), day.getSolarDay()) +print(s) +``` + + +5. 获取一年中的闰月 +``` +# 获取一年中的闰月 +year = 2020 +month = sxtwl.getRunMonth(year) +if month >= 0: + print("%d年的闰月是%d"%(year, month) ) +else: + print("没有闰月") +``` + +6. 获取一个农历月的天数 +``` +# 一个农历月的天数 +year = 2020 #农历年 +month = 4 #农历月 +isRun = False #是否是闰月 +daynum = sxtwl.getLunarMonthNum(year, month, isRun) +print("农历%d年%s%d月的天数:"%(year, '闰'if isRun else '', month), daynum) + +``` + +7. 儒略日数与公历的互转 +``` +#儒略日数转公历 +jd = sxtwl.J2000 +t = sxtwl.JD2DD(jd ) + +#公历转儒略日 +jd = sxtwl.toJD(t) +``` + + +8. 查找某日之前或者之后的节气 +``` +# 查找某日前后的节气,此例为之后，之前把after替换成before +while True: + # 这里可以使用after或者before，不用担心速度，这里的计算在底层仅仅是+1这么简单 + day = day.after(1) + # hasJieQi的接口比getJieQiJD速度要快，你也可以使用getJieQiJD来判断是否有节气。 + if day.hasJieQi(): + print('节气：%s'% jqmc[day.getJieQi()]) + #获取节气的儒略日数， 如果说你要计算什么时间的相距多少，直接比对儒略日要方便，相信我。 + jd = day.getJieQiJD() + + # 将儒略日数转换成年月日时秒 + t = sxtwl.JD2DD(jd ) + + # 注意，t.s是小数，需要四舍五入 + print("节气时间:%d-%d-%d %d:%d:%d"%(t.Y, t.M, t.D, t.h, t.m, round(t.s))) + + break +``` + +9. 四柱反查 (好像还有bug，待修复) +``` +###================================================================================== +# 四柱反查工具方法 +# 实际项目中不要这样子搞哈，因为汉字utf-8，GBK2312不同的编码。建议还是直接使用天干地支的数字索引 +def getGZ(gzStr): + tg = -1 + dz = -1 + for i, v in enumerate(Gan): + if gzStr[0] == v: + tg = i + break + + for i, v in enumerate(Zhi): + if gzStr[1] == v: + dz = i + break + return sxtwl.GZ(tg, dz) +###================================================================================== + +# 四注反查 分别传的是年天干，月天干，日天干，时天干， 开始查询年，结束查询年 返回满足条件的儒略日数 +jds = sxtwl.siZhu2Year(getGZ('辛丑'), getGZ('己亥'), getGZ('丙寅'), getGZ('癸巳'), 2003, 2029); +for jd in jds: + t = sxtwl.JD2DD(jd ) + print("符合条件的时间:%d-%d-%d %d:%d:%d"%(t.Y, t.M, t.D, t.h, t.m, round(t.s))) + +``` + +### 联系作者及广告 + +作者微信二维码: + +![微信二维码](https://gitee.com/yuangu/sxtwl/raw/master/doc/img/WechatIMG5.jpeg) + +请您扫码支持作者的海棠万年历(广告): + +![海棠万年历](https://gitee.com/yuangu/sxtwl/raw/master/doc/img/qrcode_for_gh_d48e82be45fb_430.jpg) + +如果您想请作者喝杯奶茶，扫如下微信支付码： + +![微信收款](https://gitee.com/yuangu/sxtwl/raw/master/doc/img/WechatIMG7.jpeg) \ No newline at end of file diff --git a/python/setup.py b/python/setup.py new file mode 100644 index 0000000..012fab4 --- /dev/null +++ b/python/setup.py @@ -0,0 +1,99 @@ +#!/usr/bin/env python +#-*-coding:utf-8-*- + +import setuptools +from distutils import ccompiler +import os,sys +import shutil,os +import platform +import io +import os + +long_description = "" + +try: + if sys.version_info < (3, 0) : + with open('README.md') as f: + long_description = f.read() + else: + long_description = io.open('README.md', 'r', encoding="utf-8").read() +except Exception as e: + long_description = "" +finally: + pass + +# if sys.version_info < (3, 0) and platform.system() == 'Windows': +# long_description = long_description.decode("utf-8").encode("gbk") + +if sys.version_info >= (3, 0) and platform.system() == 'Windows': + try: + if isinstance(long_description, unicode): + tmp=copy.deepcopy(long_description) + tmp.encode("mbcs") + except Exception as e: + long_description = '' + else: + pass + + +# if sys.version_info < (3, 0): +# with open("README.md", "r") as fh: +# long_description = fh.read() +# if platform.system() == 'Windows': +# long_description = long_description.decode("utf8").encode("gbk") +# else: +# with open("README.md", "r", encoding='utf-8') as fh: +# long_description = "".join(fh.readlines()) +# #发现了一个有趣的问题：http://www.queasy.me/rbsoaeod.html/questions/43255455/unicode+character+causing+error+with+bdist_wininst+on+python+3+but+not+python+2 +# try: +# long_description.encode("mbcs") +# except Exception as e: +# long_description = '' +# else: +# pass + + + +if os.path.isdir("../src"): + if os.path.isdir("src"): + shutil.rmtree("src") + shutil.copytree("../src","src") + +extra_compile_args = [] +if ccompiler.get_default_compiler() == "msvc": + extra_compile_args.append("/utf-8") +else: + extra_compile_args.append('-std=c++11') + + +sxtwl_module = setuptools.Extension('_sxtwl', + sources=[ + 'sxtwl_wrap.cxx', + 'src/eph.cpp', + 'src/JD.cpp', + 'src/SSQ.cpp', + 'src/sxtwl.cpp', + 'src/day.cpp', + ], + include_dirs=["./src"], + extra_compile_args=extra_compile_args + +) + + +setuptools.setup( + name="sxtwl", + version="2.0.6", + author="yuangu", + author_email="seantone@126.com", + description="sxtwl_cpp warpper for python", + long_description=long_description, + long_description_content_type="text/markdown", + license = "BSD", + #package_dir={'src': '../src'}, + url="https://github.com/yuangu/sxtwl_cpp", + packages=setuptools.find_packages(), + ext_modules = [sxtwl_module], + py_modules = ["sxtwl"], + +) diff --git a/python/sxtwl.py b/python/sxtwl.py new file mode 100644 index 0000000..9dad7cb --- /dev/null +++ b/python/sxtwl.py @@ -0,0 +1,510 @@ +# 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 the low-level C/C++ module +if __package__ or "." in __name__: + from . import _sxtwl +else: + import _sxtwl + +try: + import builtins as __builtin__ +except ImportError: + import __builtin__ + +def _swig_repr(self): + try: + strthis = "proxy of " + self.this.__repr__() + except __builtin__.Exception: + strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + + +def _swig_setattr_nondynamic_instance_variable(set): + def set_instance_attr(self, name, value): + if name == "this": + set(self, name, value) + elif name == "thisown": + self.this.own(value) + elif hasattr(self, name) and isinstance(getattr(type(self), name), property): + set(self, name, value) + else: + raise AttributeError("You cannot add instance attributes to %s" % self) + return set_instance_attr + + +def _swig_setattr_nondynamic_class_variable(set): + def set_class_attr(cls, name, value): + if hasattr(cls, name) and not isinstance(getattr(cls, name), property): + set(cls, name, value) + else: + raise AttributeError("You cannot add class attributes to %s" % cls) + return set_class_attr + + +def _swig_add_metaclass(metaclass): + """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass""" + def wrapper(cls): + return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy()) + return wrapper + + +class _SwigNonDynamicMeta(type): + """Meta class to enforce nondynamic attributes (no new attributes) for a class""" + __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__) + + +class SwigPyIterator(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _sxtwl.delete_SwigPyIterator + + def value(self): + return _sxtwl.SwigPyIterator_value(self) + + def incr(self, n=1): + return _sxtwl.SwigPyIterator_incr(self, n) + + def decr(self, n=1): + return _sxtwl.SwigPyIterator_decr(self, n) + + def distance(self, x): + return _sxtwl.SwigPyIterator_distance(self, x) + + def equal(self, x): + return _sxtwl.SwigPyIterator_equal(self, x) + + def copy(self): + return _sxtwl.SwigPyIterator_copy(self) + + def next(self): + return _sxtwl.SwigPyIterator_next(self) + + def __next__(self): + return _sxtwl.SwigPyIterator___next__(self) + + def previous(self): + return _sxtwl.SwigPyIterator_previous(self) + + def advance(self, n): + return _sxtwl.SwigPyIterator_advance(self, n) + + def __eq__(self, x): + return _sxtwl.SwigPyIterator___eq__(self, x) + + def __ne__(self, x): + return _sxtwl.SwigPyIterator___ne__(self, x) + + def __iadd__(self, n): + return _sxtwl.SwigPyIterator___iadd__(self, n) + + def __isub__(self, n): + return _sxtwl.SwigPyIterator___isub__(self, n) + + def __add__(self, n): + return _sxtwl.SwigPyIterator___add__(self, n) + + def __sub__(self, *args): + return _sxtwl.SwigPyIterator___sub__(self, *args) + def __iter__(self): + return self + +# Register SwigPyIterator in _sxtwl: +_sxtwl.SwigPyIterator_swigregister(SwigPyIterator) +class JDList(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def iterator(self): + return _sxtwl.JDList_iterator(self) + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + return _sxtwl.JDList___nonzero__(self) + + def __bool__(self): + return _sxtwl.JDList___bool__(self) + + def __len__(self): + return _sxtwl.JDList___len__(self) + + def __getslice__(self, i, j): + return _sxtwl.JDList___getslice__(self, i, j) + + def __setslice__(self, *args): + return _sxtwl.JDList___setslice__(self, *args) + + def __delslice__(self, i, j): + return _sxtwl.JDList___delslice__(self, i, j) + + def __delitem__(self, *args): + return _sxtwl.JDList___delitem__(self, *args) + + def __getitem__(self, *args): + return _sxtwl.JDList___getitem__(self, *args) + + def __setitem__(self, *args): + return _sxtwl.JDList___setitem__(self, *args) + + def pop(self): + return _sxtwl.JDList_pop(self) + + def append(self, x): + return _sxtwl.JDList_append(self, x) + + def empty(self): + return _sxtwl.JDList_empty(self) + + def size(self): + return _sxtwl.JDList_size(self) + + def swap(self, v): + return _sxtwl.JDList_swap(self, v) + + def begin(self): + return _sxtwl.JDList_begin(self) + + def end(self): + return _sxtwl.JDList_end(self) + + def rbegin(self): + return _sxtwl.JDList_rbegin(self) + + def rend(self): + return _sxtwl.JDList_rend(self) + + def clear(self): + return _sxtwl.JDList_clear(self) + + def get_allocator(self): + return _sxtwl.JDList_get_allocator(self) + + def pop_back(self): + return _sxtwl.JDList_pop_back(self) + + def erase(self, *args): + return _sxtwl.JDList_erase(self, *args) + + def __init__(self, *args): + _sxtwl.JDList_swiginit(self, _sxtwl.new_JDList(*args)) + + def push_back(self, x): + return _sxtwl.JDList_push_back(self, x) + + def front(self): + return _sxtwl.JDList_front(self) + + def back(self): + return _sxtwl.JDList_back(self) + + def assign(self, n, x): + return _sxtwl.JDList_assign(self, n, x) + + def resize(self, *args): + return _sxtwl.JDList_resize(self, *args) + + def insert(self, *args): + return _sxtwl.JDList_insert(self, *args) + + def reserve(self, n): + return _sxtwl.JDList_reserve(self, n) + + def capacity(self): + return _sxtwl.JDList_capacity(self) + __swig_destroy__ = _sxtwl.delete_JDList + +# Register JDList in _sxtwl: +_sxtwl.JDList_swigregister(JDList) +class JQList(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def iterator(self): + return _sxtwl.JQList_iterator(self) + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + return _sxtwl.JQList___nonzero__(self) + + def __bool__(self): + return _sxtwl.JQList___bool__(self) + + def __len__(self): + return _sxtwl.JQList___len__(self) + + def __getslice__(self, i, j): + return _sxtwl.JQList___getslice__(self, i, j) + + def __setslice__(self, *args): + return _sxtwl.JQList___setslice__(self, *args) + + def __delslice__(self, i, j): + return _sxtwl.JQList___delslice__(self, i, j) + + def __delitem__(self, *args): + return _sxtwl.JQList___delitem__(self, *args) + + def __getitem__(self, *args): + return _sxtwl.JQList___getitem__(self, *args) + + def __setitem__(self, *args): + return _sxtwl.JQList___setitem__(self, *args) + + def pop(self): + return _sxtwl.JQList_pop(self) + + def append(self, x): + return _sxtwl.JQList_append(self, x) + + def empty(self): + return _sxtwl.JQList_empty(self) + + def size(self): + return _sxtwl.JQList_size(self) + + def swap(self, v): + return _sxtwl.JQList_swap(self, v) + + def begin(self): + return _sxtwl.JQList_begin(self) + + def end(self): + return _sxtwl.JQList_end(self) + + def rbegin(self): + return _sxtwl.JQList_rbegin(self) + + def rend(self): + return _sxtwl.JQList_rend(self) + + def clear(self): + return _sxtwl.JQList_clear(self) + + def get_allocator(self): + return _sxtwl.JQList_get_allocator(self) + + def pop_back(self): + return _sxtwl.JQList_pop_back(self) + + def erase(self, *args): + return _sxtwl.JQList_erase(self, *args) + + def __init__(self, *args): + _sxtwl.JQList_swiginit(self, _sxtwl.new_JQList(*args)) + + def push_back(self, x): + return _sxtwl.JQList_push_back(self, x) + + def front(self): + return _sxtwl.JQList_front(self) + + def back(self): + return _sxtwl.JQList_back(self) + + def assign(self, n, x): + return _sxtwl.JQList_assign(self, n, x) + + def resize(self, *args): + return _sxtwl.JQList_resize(self, *args) + + def insert(self, *args): + return _sxtwl.JQList_insert(self, *args) + + def reserve(self, n): + return _sxtwl.JQList_reserve(self, n) + + def capacity(self): + return _sxtwl.JQList_capacity(self) + __swig_destroy__ = _sxtwl.delete_JQList + +# Register JQList in _sxtwl: +_sxtwl.JQList_swigregister(JQList) +J2000 = _sxtwl.J2000 +class Time(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + _sxtwl.Time_swiginit(self, _sxtwl.new_Time(*args)) + Y = property(_sxtwl.Time_Y_get, _sxtwl.Time_Y_set) + M = property(_sxtwl.Time_M_get, _sxtwl.Time_M_set) + D = property(_sxtwl.Time_D_get, _sxtwl.Time_D_set) + h = property(_sxtwl.Time_h_get, _sxtwl.Time_h_set) + m = property(_sxtwl.Time_m_get, _sxtwl.Time_m_set) + s = property(_sxtwl.Time_s_get, _sxtwl.Time_s_set) + + def getYear(self): + return _sxtwl.Time_getYear(self) + + def setYear(self, year): + return _sxtwl.Time_setYear(self, year) + + def setMonth(self, month): + return _sxtwl.Time_setMonth(self, month) + + def getMonth(self): + return _sxtwl.Time_getMonth(self) + + def getDay(self): + return _sxtwl.Time_getDay(self) + + def setDay(self, day): + return _sxtwl.Time_setDay(self, day) + + def getHour(self): + return _sxtwl.Time_getHour(self) + + def setHour(self, hour): + return _sxtwl.Time_setHour(self, hour) + + def getMin(self): + return _sxtwl.Time_getMin(self) + + def setMour(self, min): + return _sxtwl.Time_setMour(self, min) + + def getSec(self): + return _sxtwl.Time_getSec(self) + + def setSec(self, sec): + return _sxtwl.Time_setSec(self, sec) + __swig_destroy__ = _sxtwl.delete_Time + +# Register Time in _sxtwl: +_sxtwl.Time_swigregister(Time) +class GZ(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + _sxtwl.GZ_swiginit(self, _sxtwl.new_GZ(*args)) + tg = property(_sxtwl.GZ_tg_get, _sxtwl.GZ_tg_set) + dz = property(_sxtwl.GZ_dz_get, _sxtwl.GZ_dz_set) + __swig_destroy__ = _sxtwl.delete_GZ + +# Register GZ in _sxtwl: +_sxtwl.GZ_swigregister(GZ) +class Day(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined") + __repr__ = _swig_repr + + @staticmethod + def fromSolar(_year, _month, _day): + return _sxtwl.Day_fromSolar(_year, _month, _day) + + @staticmethod + def fromLunar(year, month, day, isRun=False): + return _sxtwl.Day_fromLunar(year, month, day, isRun) + + def after(self, day): + return _sxtwl.Day_after(self, day) + + def before(self, day): + return _sxtwl.Day_before(self, day) + + def getLunarDay(self): + return _sxtwl.Day_getLunarDay(self) + + def getLunarMonth(self): + return _sxtwl.Day_getLunarMonth(self) + + def getLunarYear(self, chineseNewYearBoundary=True): + return _sxtwl.Day_getLunarYear(self, chineseNewYearBoundary) + + def getYearGZ(self, chineseNewYearBoundary=False): + return _sxtwl.Day_getYearGZ(self, chineseNewYearBoundary) + + def getMonthGZ(self): + return _sxtwl.Day_getMonthGZ(self) + + def getDayGZ(self): + return _sxtwl.Day_getDayGZ(self) + + def getHourGZ(self, hour, isZaoWanZiShi=True): + return _sxtwl.Day_getHourGZ(self, hour, isZaoWanZiShi) + + def isLunarLeap(self): + return _sxtwl.Day_isLunarLeap(self) + + def getSolarYear(self): + return _sxtwl.Day_getSolarYear(self) + + def getSolarMonth(self): + return _sxtwl.Day_getSolarMonth(self) + + def getSolarDay(self): + return _sxtwl.Day_getSolarDay(self) + + def getWeek(self): + return _sxtwl.Day_getWeek(self) + + def getWeekIndex(self): + return _sxtwl.Day_getWeekIndex(self) + + def hasJieQi(self): + return _sxtwl.Day_hasJieQi(self) + + def getJieQi(self): + return _sxtwl.Day_getJieQi(self) + + def getJieQiJD(self): + return _sxtwl.Day_getJieQiJD(self) + + def getConstellation(self): + return _sxtwl.Day_getConstellation(self) + __swig_destroy__ = _sxtwl.delete_Day + +# Register Day in _sxtwl: +_sxtwl.Day_swigregister(Day) +class JieQiInfo(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + jd = property(_sxtwl.JieQiInfo_jd_get, _sxtwl.JieQiInfo_jd_set) + jqIndex = property(_sxtwl.JieQiInfo_jqIndex_get, _sxtwl.JieQiInfo_jqIndex_set) + + def __init__(self): + _sxtwl.JieQiInfo_swiginit(self, _sxtwl.new_JieQiInfo()) + __swig_destroy__ = _sxtwl.delete_JieQiInfo + +# Register JieQiInfo in _sxtwl: +_sxtwl.JieQiInfo_swigregister(JieQiInfo) + +def fromSolar(year, month, day): + return _sxtwl.fromSolar(year, month, day) + +def fromLunar(year, month, day, isRun=False): + return _sxtwl.fromLunar(year, month, day, isRun) + +def siZhu2Year(year, yue, ri, shi, fromYear, toYear): + return _sxtwl.siZhu2Year(year, yue, ri, shi, fromYear, toYear) + +def getShiGz(dayTg, hour, isZaoWanZiShi=True): + return _sxtwl.getShiGz(dayTg, hour, isZaoWanZiShi) + +def getRunMonth(By): + return _sxtwl.getRunMonth(By) + +def getLunarMonthNum(By, month, isRun=False): + return _sxtwl.getLunarMonthNum(By, month, isRun) + +def JD2DD(jd): + return _sxtwl.JD2DD(jd) + +def toJD(time): + return _sxtwl.toJD(time) + +def getJieQiByYear(year): + return _sxtwl.getJieQiByYear(year) + diff --git a/python/sxtwl_wrap.cxx b/python/sxtwl_wrap.cxx new file mode 100644 index 0000000..bb64594 --- /dev/null +++ b/python/sxtwl_wrap.cxx @@ -0,0 +1,13109 @@ +/* ---------------------------------------------------------------------------- + * 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 + +/* ----------------------------------------------------------------------------- + * 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 + + + +#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) + + + + #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) + + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_Day swig_types[0] +#define SWIGTYPE_p_GZ swig_types[1] +#define SWIGTYPE_p_Time swig_types[2] +#define SWIGTYPE_p_allocator_type swig_types[3] +#define SWIGTYPE_p_char swig_types[4] +#define SWIGTYPE_p_difference_type swig_types[5] +#define SWIGTYPE_p_int swig_types[6] +#define SWIGTYPE_p_long_long swig_types[7] +#define SWIGTYPE_p_p_PyObject swig_types[8] +#define SWIGTYPE_p_short swig_types[9] +#define SWIGTYPE_p_signed_char swig_types[10] +#define SWIGTYPE_p_size_type swig_types[11] +#define SWIGTYPE_p_std__allocatorT_double_t swig_types[12] +#define SWIGTYPE_p_std__allocatorT_sxtwl__JieQiInfo_t swig_types[13] +#define SWIGTYPE_p_std__invalid_argument swig_types[14] +#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[15] +#define SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t swig_types[16] +#define SWIGTYPE_p_swig__SwigPyIterator swig_types[17] +#define SWIGTYPE_p_sxtwl__JieQiInfo swig_types[18] +#define SWIGTYPE_p_unsigned_char swig_types[19] +#define SWIGTYPE_p_unsigned_int swig_types[20] +#define SWIGTYPE_p_unsigned_long_long swig_types[21] +#define SWIGTYPE_p_unsigned_short swig_types[22] +#define SWIGTYPE_p_value_type swig_types[23] +static swig_type_info *swig_types[25]; +static swig_module_info swig_module = {swig_types, 24, 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):= _sxtwl.so + ------------------------------------------------*/ +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_init PyInit__sxtwl + +#else +# define SWIG_init init_sxtwl + +#endif +#define SWIG_name "_sxtwl" + +#ifdef __cplusplus +#include +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigSmartPointer { + T *ptr; + SwigSmartPointer(T *p) : ptr(p) { } + ~SwigSmartPointer() { delete ptr; } + SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; } +#if __cplusplus >=201103L + SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; } + operator T&&() const { return std::move(*pointer.ptr); } +#else + operator T&() const { return *pointer.ptr; } +#endif + T *operator&() const { return pointer.ptr; } + static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); } +}; + +/* + * SwigValueInit() is a generic initialisation solution as the following approach: + * + * T c_result = T(); + * + * doesn't compile for all types for example: + * + * unsigned int c_result = unsigned int(); + */ +template T SwigValueInit() { + return T(); +} + +#if __cplusplus >=201103L +# define SWIG_STD_MOVE(OBJ) std::move(OBJ) +#else +# define SWIG_STD_MOVE(OBJ) OBJ +#endif + +#endif + + +#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) + + +#include + + +namespace swig { + class SwigPtr_PyObject { + protected: + PyObject *_obj; + + public: + SwigPtr_PyObject() :_obj(0) + { + } + + SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj) + { + if (initial_ref) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(item._obj); + Py_XDECREF(_obj); + _obj = item._obj; + SWIG_PYTHON_THREAD_END_BLOCK; + return *this; + } + + ~SwigPtr_PyObject() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XDECREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + operator PyObject *() const + { + return _obj; + } + + PyObject *operator->() const + { + return _obj; + } + }; +} + + +namespace swig { + struct SwigVar_PyObject : SwigPtr_PyObject { + SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { } + + SwigVar_PyObject & operator = (PyObject* obj) + { + Py_XDECREF(_obj); + _obj = obj; + return *this; + } + }; +} + + +#include "const.h" +#include "sxtwl.h" + + +#include // Use the C99 official header + + +#include + +#if PY_VERSION_HEX >= 0x03020000 +# define SWIGPY_SLICEOBJECT PyObject +#else +# define SWIGPY_SLICEOBJECT PySliceObject +#endif + + +#include +#include + + +#if defined(__GNUC__) +# if __GNUC__ == 2 && __GNUC_MINOR <= 96 +# define SWIG_STD_NOMODERN_STL +# endif +#endif + + +#include + + +#include + + +namespace swig { + struct stop_iteration { + }; + + struct SwigPyIterator { + private: + SwigPtr_PyObject _seq; + + protected: + SwigPyIterator(PyObject *seq) : _seq(seq) + { + } + + public: + virtual ~SwigPyIterator() {} + + // Access iterator method, required by Python + virtual PyObject *value() const = 0; + + // Forward iterator method, required by Python + virtual SwigPyIterator *incr(size_t n = 1) = 0; + + // Backward iterator method, very common in C++, but not required in Python + virtual SwigPyIterator *decr(size_t /*n*/ = 1) + { + throw stop_iteration(); + } + + // Random access iterator methods, but not required in Python + virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const + { + throw std::invalid_argument("operation not supported"); + } + + virtual bool equal (const SwigPyIterator &/*x*/) const + { + throw std::invalid_argument("operation not supported"); + } + + // C++ common/needed methods + virtual SwigPyIterator *copy() const = 0; + + PyObject *next() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads + PyObject *obj = value(); + incr(); + SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads + return obj; + } + + /* Make an alias for Python 3.x */ + PyObject *__next__() + { + return next(); + } + + PyObject *previous() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads + decr(); + PyObject *obj = value(); + SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads + return obj; + } + + SwigPyIterator *advance(ptrdiff_t n) + { + return (n > 0) ? incr(n) : decr(-n); + } + + bool operator == (const SwigPyIterator& x) const + { + return equal(x); + } + + bool operator != (const SwigPyIterator& x) const + { + return ! operator==(x); + } + + SwigPyIterator& operator += (ptrdiff_t n) + { + return *advance(n); + } + + SwigPyIterator& operator -= (ptrdiff_t n) + { + return *advance(-n); + } + + SwigPyIterator* operator + (ptrdiff_t n) const + { + return copy()->advance(n); + } + + SwigPyIterator* operator - (ptrdiff_t n) const + { + return copy()->advance(-n); + } + + ptrdiff_t operator - (const SwigPyIterator& x) const + { + return x.distance(*this); + } + + static swig_type_info* descriptor() { + static int init = 0; + static swig_type_info* desc = 0; + if (!init) { + desc = SWIG_TypeQuery("swig::SwigPyIterator *"); + init = 1; + } + return desc; + } + }; + +#if defined(SWIGPYTHON_BUILTIN) + inline PyObject* make_output_iterator_builtin (PyObject *pyself) + { + Py_INCREF(pyself); + return pyself; + } +#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_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; +} + + +#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 + + +#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 + + +SWIGINTERNINLINE int +SWIG_AsVal_size_t (PyObject * obj, size_t *val) +{ + int res = SWIG_TypeError; +#ifdef SWIG_LONG_LONG_AVAILABLE + if (sizeof(size_t) <= sizeof(unsigned long)) { +#endif + unsigned long v; + res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); +#ifdef SWIG_LONG_LONG_AVAILABLE + } else if (sizeof(size_t) <= sizeof(unsigned long long)) { + unsigned long long v; + res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); + } +#endif + return res; +} + + + #define SWIG_From_long PyInt_FromLong + + +#ifdef SWIG_LONG_LONG_AVAILABLE +SWIGINTERNINLINE PyObject* +SWIG_From_long_SS_long (long long value) +{ + return ((value < LONG_MIN) || (value > LONG_MAX)) ? + PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value)); +} +#endif + + +SWIGINTERNINLINE PyObject * +SWIG_From_ptrdiff_t (ptrdiff_t value) +{ +#ifdef SWIG_LONG_LONG_AVAILABLE + if (sizeof(ptrdiff_t) <= sizeof(long)) { +#endif + return SWIG_From_long (static_cast< long >(value)); +#ifdef SWIG_LONG_LONG_AVAILABLE + } else { + /* assume sizeof(ptrdiff_t) <= sizeof(long long) */ + return SWIG_From_long_SS_long (static_cast< long long >(value)); + } +#endif +} + + +SWIGINTERNINLINE PyObject* + SWIG_From_bool (bool value) +{ + return PyBool_FromLong(value ? 1 : 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; +} + + +#ifdef SWIG_LONG_LONG_AVAILABLE +SWIGINTERN int +SWIG_AsVal_long_SS_long (PyObject *obj, long long *val) +{ + int res = SWIG_TypeError; + if (PyLong_Check(obj)) { + long long v = PyLong_AsLongLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + res = SWIG_OverflowError; + } + } else { + long v; + res = SWIG_AsVal_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; + const double mant_min = -mant_max; + double d; + res = SWIG_AsVal_double (obj,&d); + if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max)) + return SWIG_OverflowError; + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) { + if (val) *val = (long long)(d); + return SWIG_AddCast(res); + } + res = SWIG_TypeError; + } +#endif + return res; +} +#endif + + +SWIGINTERNINLINE int +SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val) +{ + int res = SWIG_TypeError; +#ifdef SWIG_LONG_LONG_AVAILABLE + if (sizeof(ptrdiff_t) <= sizeof(long)) { +#endif + long v; + res = SWIG_AsVal_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v); +#ifdef SWIG_LONG_LONG_AVAILABLE + } else if (sizeof(ptrdiff_t) <= sizeof(long long)) { + long long v; + res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v); + } +#endif + return res; +} + + +#include + + +#include + + +namespace swig { + template + struct noconst_traits { + typedef Type noconst_type; + }; + + template + struct noconst_traits { + typedef Type noconst_type; + }; + + /* + type categories + */ + struct pointer_category { }; + struct value_category { }; + + /* + General traits that provides type_name and type_info + */ + template struct traits { }; + + template + inline const char* type_name() { + return traits::noconst_type >::type_name(); + } + + template struct traits_info { + static swig_type_info *type_query(std::string name) { + name += " *"; + return SWIG_TypeQuery(name.c_str()); + } + static swig_type_info *type_info() { + static swig_type_info *info = type_query(type_name()); + return info; + } + }; + + /* + Partial specialization for pointers (traits_info) + */ + template struct traits_info { + static swig_type_info *type_query(std::string name) { + name += " *"; + return SWIG_TypeQuery(name.c_str()); + } + static swig_type_info *type_info() { + static swig_type_info *info = type_query(type_name()); + return info; + } + }; + + template + inline swig_type_info *type_info() { + return traits_info::type_info(); + } + + /* + Partial specialization for pointers (traits) + */ + template struct traits { + typedef pointer_category category; + static std::string make_ptr_name(const char* name) { + std::string ptrname = name; + ptrname += " *"; + return ptrname; + } + static const char* type_name() { + static std::string name = make_ptr_name(swig::type_name()); + return name.c_str(); + } + }; + + template + struct traits_as { }; + + template + struct traits_check { }; + +} + + +namespace swig { + /* + Traits that provides the from method + */ + template struct traits_from_ptr { + static PyObject *from(Type *val, int owner = 0) { + return SWIG_InternalNewPointerObj(val, type_info(), owner); + } + }; + + template struct traits_from { + static PyObject *from(const Type& val) { + return traits_from_ptr::from(new Type(val), 1); + } + }; + + template struct traits_from { + static PyObject *from(Type* val) { + return traits_from_ptr::from(val, 0); + } + }; + + template struct traits_from { + static PyObject *from(const Type* val) { + return traits_from_ptr::from(const_cast(val), 0); + } + }; + + + template + inline PyObject *from(const Type& val) { + return traits_from::from(val); + } + + template + inline PyObject *from_ptr(Type* val, int owner) { + return traits_from_ptr::from(val, owner); + } + + /* + Traits that provides the asval/as/check method + */ + template + struct traits_asptr { + static int asptr(PyObject *obj, Type **val) { + int res = SWIG_ERROR; + swig_type_info *descriptor = type_info(); + if (val) { + Type *p = 0; + int newmem = 0; + res = descriptor ? SWIG_ConvertPtrAndOwn(obj, (void **)&p, descriptor, 0, &newmem) : SWIG_ERROR; + if (SWIG_IsOK(res)) { + if (newmem & SWIG_CAST_NEW_MEMORY) { + res |= SWIG_NEWOBJMASK; + } + *val = p; + } + } else { + res = descriptor ? SWIG_ConvertPtr(obj, 0, descriptor, 0) : SWIG_ERROR; + } + return res; + } + }; + + template + inline int asptr(PyObject *obj, Type **vptr) { + return traits_asptr::asptr(obj, vptr); + } + + template + struct traits_asval { + static int asval(PyObject *obj, Type *val) { + if (val) { + Type *p = 0; + int res = traits_asptr::asptr(obj, &p); + if (!SWIG_IsOK(res)) return res; + if (p) { + typedef typename noconst_traits::noconst_type noconst_type; + *(const_cast(val)) = *p; + if (SWIG_IsNewObj(res)){ + delete p; + res = SWIG_DelNewMask(res); + } + return res; + } else { + return SWIG_ERROR; + } + } else { + return traits_asptr::asptr(obj, (Type **)(0)); + } + } + }; + + template struct traits_asval { + static int asval(PyObject *obj, Type **val) { + if (val) { + typedef typename noconst_traits::noconst_type noconst_type; + noconst_type *p = 0; + int res = traits_asptr::asptr(obj, &p); + if (SWIG_IsOK(res)) { + *(const_cast(val)) = p; + } + return res; + } else { + return traits_asptr::asptr(obj, (Type **)(0)); + } + } + }; + + template + inline int asval(PyObject *obj, Type *val) { + return traits_asval::asval(obj, val); + } + + template + struct traits_as { + static Type as(PyObject *obj) { + Type v; + int res = asval(obj, &v); + if (!obj || !SWIG_IsOK(res)) { + if (!PyErr_Occurred()) { + ::SWIG_Error(SWIG_TypeError, swig::type_name()); + } + throw std::invalid_argument("bad type"); + } + return v; + } + }; + + template + struct traits_as { + static Type as(PyObject *obj) { + Type *v = 0; + int res = (obj ? traits_asptr::asptr(obj, &v) : SWIG_ERROR); + if (SWIG_IsOK(res) && v) { + if (SWIG_IsNewObj(res)) { + Type r(*v); + delete v; + return r; + } else { + return *v; + } + } else { + if (!PyErr_Occurred()) { + SWIG_Error(SWIG_TypeError, swig::type_name()); + } + throw std::invalid_argument("bad type"); + } + } + }; + + template + struct traits_as { + static Type* as(PyObject *obj) { + Type *v = 0; + int res = (obj ? traits_asptr::asptr(obj, &v) : SWIG_ERROR); + if (SWIG_IsOK(res)) { + return v; + } else { + if (!PyErr_Occurred()) { + SWIG_Error(SWIG_TypeError, swig::type_name()); + } + throw std::invalid_argument("bad type"); + } + } + }; + + template + inline Type as(PyObject *obj) { + return traits_as::category>::as(obj); + } + + template + struct traits_check { + static bool check(PyObject *obj) { + int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR; + return SWIG_IsOK(res) ? true : false; + } + }; + + template + struct traits_check { + static bool check(PyObject *obj) { + int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR; + return SWIG_IsOK(res) ? true : false; + } + }; + + template + inline bool check(PyObject *obj) { + return traits_check::category>::check(obj); + } +} + + +#include + +namespace std { + template <> + struct less + { + bool + operator()(PyObject * v, PyObject *w) const + { + bool res; + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false; + /* This may fall into a case of inconsistent + eg. ObjA > ObjX > ObjB + but ObjA < ObjB + */ + if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) ) + { + /* Objects can't be compared, this mostly occurred in Python 3.0 */ + /* Compare their ptr directly for a workaround */ + res = (v < w); + PyErr_Clear(); + } + SWIG_PYTHON_THREAD_END_BLOCK; + return res; + } + }; + + template <> + struct less + { + bool + operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const + { + return std::less()(v, w); + } + }; + + template <> + struct less + { + bool + operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const + { + return std::less()(v, w); + } + }; + +} + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return "PyObject *"; } + }; + + template <> struct traits_asval { + typedef PyObject * value_type; + static int asval(PyObject *obj, value_type *val) { + if (val) *val = obj; + return SWIG_OK; + } + }; + + template <> + struct traits_check { + static bool check(PyObject *) { + return true; + } + }; + + template <> struct traits_from { + typedef PyObject * value_type; + static PyObject *from(const value_type& val) { + Py_XINCREF(val); + return val; + } + }; + +} + +namespace swig { + template + inline size_t + check_index(Difference i, size_t size, bool insert = false) { + if ( i < 0 ) { + if ((size_t) (-i) <= size) + return (size_t) (i + size); + } else if ( (size_t) i < size ) { + return (size_t) i; + } else if (insert && ((size_t) i == size)) { + return size; + } + throw std::out_of_range("index out of range"); + } + + template + void + slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) { + if (step == 0) { + throw std::invalid_argument("slice step cannot be zero"); + } else if (step > 0) { + // Required range: 0 <= i < size, 0 <= j < size, i <= j + if (i < 0) { + ii = 0; + } else if (i < (Difference)size) { + ii = i; + } else if (insert && (i >= (Difference)size)) { + ii = (Difference)size; + } + if (j < 0) { + jj = 0; + } else { + jj = (j < (Difference)size) ? j : (Difference)size; + } + if (jj < ii) + jj = ii; + } else { + // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j + if (i < -1) { + ii = -1; + } else if (i < (Difference) size) { + ii = i; + } else if (i >= (Difference)(size-1)) { + ii = (Difference)(size-1); + } + if (j < -1) { + jj = -1; + } else { + jj = (j < (Difference)size ) ? j : (Difference)(size-1); + } + if (ii < jj) + ii = jj; + } + } + + template + inline typename Sequence::iterator + getpos(Sequence* self, Difference i) { + typename Sequence::iterator pos = self->begin(); + std::advance(pos, check_index(i,self->size())); + return pos; + } + + template + inline typename Sequence::const_iterator + cgetpos(const Sequence* self, Difference i) { + typename Sequence::const_iterator pos = self->begin(); + std::advance(pos, check_index(i,self->size())); + return pos; + } + + template + inline void + erase(Sequence* seq, const typename Sequence::iterator& position) { + seq->erase(position); + } + + template + struct traits_reserve { + static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) { + // This should be specialized for types that support reserve + } + }; + + template + inline Sequence* + getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) { + typename Sequence::size_type size = self->size(); + Difference ii = 0; + Difference jj = 0; + swig::slice_adjust(i, j, step, size, ii, jj); + + if (step > 0) { + typename Sequence::const_iterator sb = self->begin(); + typename Sequence::const_iterator se = self->begin(); + std::advance(sb,ii); + std::advance(se,jj); + if (step == 1) { + return new Sequence(sb, se); + } else { + Sequence *sequence = new Sequence(); + swig::traits_reserve::reserve(*sequence, (jj - ii + step - 1) / step); + typename Sequence::const_iterator it = sb; + while (it!=se) { + sequence->push_back(*it); + for (Py_ssize_t c=0; c::reserve(*sequence, (ii - jj - step - 1) / -step); + typename Sequence::const_reverse_iterator sb = self->rbegin(); + typename Sequence::const_reverse_iterator se = self->rbegin(); + std::advance(sb,size-ii-1); + std::advance(se,size-jj-1); + typename Sequence::const_reverse_iterator it = sb; + while (it!=se) { + sequence->push_back(*it); + for (Py_ssize_t c=0; c<-step && it!=se; ++c) + it++; + } + return sequence; + } + } + + template + inline void + setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) { + typename Sequence::size_type size = self->size(); + Difference ii = 0; + Difference jj = 0; + swig::slice_adjust(i, j, step, size, ii, jj, true); + if (step > 0) { + if (step == 1) { + size_t ssize = jj - ii; + if (ssize <= is.size()) { + // expanding/staying the same size + swig::traits_reserve::reserve(*self, self->size() - ssize + is.size()); + typename Sequence::iterator sb = self->begin(); + typename InputSeq::const_iterator isit = is.begin(); + std::advance(sb,ii); + std::advance(isit, jj - ii); + self->insert(std::copy(is.begin(), isit, sb), isit, is.end()); + } else { + // shrinking + typename Sequence::iterator sb = self->begin(); + typename Sequence::iterator se = self->begin(); + std::advance(sb,ii); + std::advance(se,jj); + self->erase(sb,se); + sb = self->begin(); + std::advance(sb,ii); + self->insert(sb, is.begin(), is.end()); + } + } else { + size_t replacecount = (jj - ii + step - 1) / step; + if (is.size() != replacecount) { + char msg[1024]; + sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount); + throw std::invalid_argument(msg); + } + typename Sequence::const_iterator isit = is.begin(); + typename Sequence::iterator it = self->begin(); + std::advance(it,ii); + for (size_t rc=0; rcend(); ++rc) { + *it++ = *isit++; + for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c) + it++; + } + } + } else { + size_t replacecount = (ii - jj - step - 1) / -step; + if (is.size() != replacecount) { + char msg[1024]; + sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount); + throw std::invalid_argument(msg); + } + typename Sequence::const_iterator isit = is.begin(); + typename Sequence::reverse_iterator it = self->rbegin(); + std::advance(it,size-ii-1); + for (size_t rc=0; rcrend(); ++rc) { + *it++ = *isit++; + for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c) + it++; + } + } + } + + template + inline void + delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) { + typename Sequence::size_type size = self->size(); + Difference ii = 0; + Difference jj = 0; + swig::slice_adjust(i, j, step, size, ii, jj, true); + if (step > 0) { + typename Sequence::iterator sb = self->begin(); + std::advance(sb,ii); + if (step == 1) { + typename Sequence::iterator se = self->begin(); + std::advance(se,jj); + self->erase(sb,se); + } else { + typename Sequence::iterator it = sb; + size_t delcount = (jj - ii + step - 1) / step; + while (delcount) { + it = self->erase(it); + for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c) + it++; + delcount--; + } + } + } else { + typename Sequence::reverse_iterator sb = self->rbegin(); + std::advance(sb,size-ii-1); + typename Sequence::reverse_iterator it = sb; + size_t delcount = (ii - jj - step - 1) / -step; + while (delcount) { + it = typename Sequence::reverse_iterator(self->erase((++it).base())); + for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c) + it++; + delcount--; + } + } + } +} + + +#if defined(__SUNPRO_CC) && defined(_RWSTD_VER) +# if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL) +# define SWIG_STD_NOITERATOR_TRAITS_STL +# endif +#endif + +#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL) +#include +#else +namespace std { + template + struct iterator_traits { + typedef ptrdiff_t difference_type; + typedef typename Iterator::value_type value_type; + }; + + template + struct iterator_traits<__reverse_bi_iterator > { + typedef Distance difference_type; + typedef T value_type; + }; + + template + struct iterator_traits { + typedef T value_type; + typedef ptrdiff_t difference_type; + }; + + template + inline typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) { + ++__first; ++__n; + } + return __n; + } +} +#endif + + +namespace swig { + template + class SwigPyIterator_T : public SwigPyIterator + { + public: + typedef OutIterator out_iterator; + typedef typename std::iterator_traits::value_type value_type; + typedef SwigPyIterator_T self_type; + + SwigPyIterator_T(out_iterator curr, PyObject *seq) + : SwigPyIterator(seq), current(curr) + { + } + + const out_iterator& get_current() const + { + return current; + } + + + bool equal (const SwigPyIterator &iter) const + { + const self_type *iters = dynamic_cast(&iter); + if (iters) { + return (current == iters->get_current()); + } else { + throw std::invalid_argument("bad iterator type"); + } + } + + ptrdiff_t distance(const SwigPyIterator &iter) const + { + const self_type *iters = dynamic_cast(&iter); + if (iters) { + return std::distance(current, iters->get_current()); + } else { + throw std::invalid_argument("bad iterator type"); + } + } + + protected: + out_iterator current; + }; + + template + struct from_oper + { + typedef const ValueType& argument_type; + typedef PyObject *result_type; + result_type operator()(argument_type v) const + { + return swig::from(v); + } + }; + + template::value_type, + typename FromOper = from_oper > + class SwigPyForwardIteratorOpen_T : public SwigPyIterator_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef SwigPyIterator_T base; + typedef SwigPyForwardIteratorOpen_T self_type; + + SwigPyForwardIteratorOpen_T(out_iterator curr, PyObject *seq) + : SwigPyIterator_T(curr, seq) + { + } + + PyObject *value() const { + return from(static_cast(*(base::current))); + } + + SwigPyIterator *copy() const + { + return new self_type(*this); + } + + SwigPyIterator *incr(size_t n = 1) + { + while (n--) { + ++base::current; + } + return this; + } + + }; + + template::value_type, + typename FromOper = from_oper > + class SwigPyIteratorOpen_T : public SwigPyForwardIteratorOpen_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef SwigPyIterator_T base; + typedef SwigPyIteratorOpen_T self_type; + + SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq) + : SwigPyForwardIteratorOpen_T(curr, seq) + { + } + + SwigPyIterator *decr(size_t n = 1) + { + while (n--) { + --base::current; + } + return this; + } + }; + + template::value_type, + typename FromOper = from_oper > + class SwigPyForwardIteratorClosed_T : public SwigPyIterator_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef SwigPyIterator_T base; + typedef SwigPyForwardIteratorClosed_T self_type; + + SwigPyForwardIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq) + : SwigPyIterator_T(curr, seq), begin(first), end(last) + { + } + + PyObject *value() const { + if (base::current == end) { + throw stop_iteration(); + } else { + return from(static_cast(*(base::current))); + } + } + + SwigPyIterator *copy() const + { + return new self_type(*this); + } + + SwigPyIterator *incr(size_t n = 1) + { + while (n--) { + if (base::current == end) { + throw stop_iteration(); + } else { + ++base::current; + } + } + return this; + } + + protected: + out_iterator begin; + out_iterator end; + }; + + template::value_type, + typename FromOper = from_oper > + class SwigPyIteratorClosed_T : public SwigPyForwardIteratorClosed_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef SwigPyIterator_T base; + typedef SwigPyForwardIteratorClosed_T base0; + typedef SwigPyIteratorClosed_T self_type; + + SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq) + : SwigPyForwardIteratorClosed_T(curr, first, last, seq) + { + } + + SwigPyIterator *decr(size_t n = 1) + { + while (n--) { + if (base::current == base0::begin) { + throw stop_iteration(); + } else { + --base::current; + } + } + return this; + } + }; + + + template + inline SwigPyIterator* + make_output_forward_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0) + { + return new SwigPyForwardIteratorClosed_T(current, begin, end, seq); + } + + template + inline SwigPyIterator* + make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0) + { + return new SwigPyIteratorClosed_T(current, begin, end, seq); + } + + template + inline SwigPyIterator* + make_output_forward_iterator(const OutIter& current, PyObject *seq = 0) + { + return new SwigPyForwardIteratorOpen_T(current, seq); + } + + template + inline SwigPyIterator* + make_output_iterator(const OutIter& current, PyObject *seq = 0) + { + return new SwigPyIteratorOpen_T(current, seq); + } + +} + + +namespace swig +{ + template + struct SwigPySequence_Ref + { + SwigPySequence_Ref(PyObject* seq, Py_ssize_t index) + : _seq(seq), _index(index) + { + } + + operator T () const + { + swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index); + try { + return swig::as(item); + } catch (const std::invalid_argument& e) { + char msg[1024]; + sprintf(msg, "in sequence element %d ", (int)_index); + if (!PyErr_Occurred()) { + ::SWIG_Error(SWIG_TypeError, swig::type_name()); + } + SWIG_Python_AddErrorMsg(msg); + SWIG_Python_AddErrorMsg(e.what()); + throw; + } + } + + SwigPySequence_Ref& operator=(const T& v) + { + PySequence_SetItem(_seq, _index, swig::from(v)); + return *this; + } + + private: + PyObject* _seq; + Py_ssize_t _index; + }; + + template + struct SwigPySequence_ArrowProxy + { + SwigPySequence_ArrowProxy(const T& x): m_value(x) {} + const T* operator->() const { return &m_value; } + operator const T*() const { return &m_value; } + T m_value; + }; + + template + struct SwigPySequence_InputIterator + { + typedef SwigPySequence_InputIterator self; + + typedef std::random_access_iterator_tag iterator_category; + typedef Reference reference; + typedef T value_type; + typedef T* pointer; + typedef Py_ssize_t difference_type; + + SwigPySequence_InputIterator() + { + } + + SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index) + : _seq(seq), _index(index) + { + } + + reference operator*() const + { + return reference(_seq, _index); + } + + SwigPySequence_ArrowProxy + operator->() const { + return SwigPySequence_ArrowProxy(operator*()); + } + + bool operator==(const self& ri) const + { + return (_index == ri._index) && (_seq == ri._seq); + } + + bool operator!=(const self& ri) const + { + return !(operator==(ri)); + } + + self& operator ++ () + { + ++_index; + return *this; + } + + self& operator -- () + { + --_index; + return *this; + } + + self& operator += (difference_type n) + { + _index += n; + return *this; + } + + self operator +(difference_type n) const + { + return self(_seq, _index + n); + } + + self& operator -= (difference_type n) + { + _index -= n; + return *this; + } + + self operator -(difference_type n) const + { + return self(_seq, _index - n); + } + + difference_type operator - (const self& ri) const + { + return _index - ri._index; + } + + bool operator < (const self& ri) const + { + return _index < ri._index; + } + + reference + operator[](difference_type n) const + { + return reference(_seq, _index + n); + } + + private: + PyObject* _seq; + difference_type _index; + }; + + // STL container wrapper around a Python sequence + template + struct SwigPySequence_Cont + { + typedef SwigPySequence_Ref reference; + typedef const SwigPySequence_Ref const_reference; + typedef T value_type; + typedef T* pointer; + typedef Py_ssize_t difference_type; + typedef size_t size_type; + typedef const pointer const_pointer; + typedef SwigPySequence_InputIterator iterator; + typedef SwigPySequence_InputIterator const_iterator; + + SwigPySequence_Cont(PyObject* seq) : _seq(0) + { + if (!PySequence_Check(seq)) { + throw std::invalid_argument("a sequence is expected"); + } + _seq = seq; + Py_INCREF(_seq); + } + + ~SwigPySequence_Cont() + { + Py_XDECREF(_seq); + } + + size_type size() const + { + return static_cast(PySequence_Size(_seq)); + } + + bool empty() const + { + return size() == 0; + } + + iterator begin() + { + return iterator(_seq, 0); + } + + const_iterator begin() const + { + return const_iterator(_seq, 0); + } + + iterator end() + { + return iterator(_seq, size()); + } + + const_iterator end() const + { + return const_iterator(_seq, size()); + } + + reference operator[](difference_type n) + { + return reference(_seq, n); + } + + const_reference operator[](difference_type n) const + { + return const_reference(_seq, n); + } + + bool check() const + { + Py_ssize_t s = size(); + for (Py_ssize_t i = 0; i < s; ++i) { + swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i); + if (!swig::check(item)) + return false; + } + return true; + } + + private: + PyObject* _seq; + }; + +} + + + #define SWIG_From_double PyFloat_FromDouble + + +namespace swig { + template <> struct traits< double > { + typedef value_category category; + static const char* type_name() { return"double"; } + }; + template <> struct traits_asval< double > { + typedef double value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_double (obj, val); + } + }; + template <> struct traits_from< double > { + typedef double value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_double (val); + } + }; +} + + +namespace swig { + template + inline void + assign(const SwigPySeq& swigpyseq, Seq* seq) { + // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented + typedef typename SwigPySeq::value_type value_type; + typename SwigPySeq::const_iterator it = swigpyseq.begin(); + for (;it != swigpyseq.end(); ++it) { + seq->insert(seq->end(),(value_type)(*it)); + } + } + + template + struct traits_asptr_stdseq { + typedef Seq sequence; + typedef T value_type; + + static int asptr(PyObject *obj, sequence **seq) { + if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) { + sequence *p; + swig_type_info *descriptor = swig::type_info(); + if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) { + if (seq) *seq = p; + return SWIG_OLDOBJ; + } + } else if (PySequence_Check(obj)) { + try { + SwigPySequence_Cont swigpyseq(obj); + if (seq) { + sequence *pseq = new sequence(); + assign(swigpyseq, pseq); + *seq = pseq; + return SWIG_NEWOBJ; + } else { + return swigpyseq.check() ? SWIG_OK : SWIG_ERROR; + } + } catch (std::exception& e) { + if (seq) { + if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, e.what()); + } + } + return SWIG_ERROR; + } + } + return SWIG_ERROR; + } + }; + + template + struct traits_from_stdseq { + typedef Seq sequence; + typedef T value_type; + typedef typename Seq::size_type size_type; + typedef typename sequence::const_iterator const_iterator; + + static PyObject *from(const sequence& seq) { +#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS + swig_type_info *desc = swig::type_info(); + if (desc && desc->clientdata) { + return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN); + } +#endif + size_type size = seq.size(); + if (size <= (size_type)INT_MAX) { + PyObject *obj = PyTuple_New((Py_ssize_t)size); + Py_ssize_t i = 0; + for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) { + PyTuple_SetItem(obj,i,swig::from(*it)); + } + return obj; + } else { + PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python"); + return NULL; + } + } + }; +} + + + namespace swig { + template + struct traits_reserve > { + static void reserve(std::vector &seq, typename std::vector::size_type n) { + seq.reserve(n); + } + }; + + template + struct traits_asptr > { + static int asptr(PyObject *obj, std::vector **vec) { + return traits_asptr_stdseq >::asptr(obj, vec); + } + }; + + template + struct traits_from > { + static PyObject *from(const std::vector& vec) { + return traits_from_stdseq >::from(vec); + } + }; + } + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "double" "," "std::allocator< double >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){ + return self->size(); + } + +SWIGINTERNINLINE PyObject* +SWIG_From_unsigned_SS_long (unsigned long value) +{ + return (value > LONG_MAX) ? + PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value)); +} + + +#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(static_cast< long >(value)); +} +#endif + + +SWIGINTERNINLINE PyObject * +SWIG_From_size_t (size_t value) +{ +#ifdef SWIG_LONG_LONG_AVAILABLE + if (sizeof(size_t) <= sizeof(unsigned long)) { +#endif + return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value)); +#ifdef SWIG_LONG_LONG_AVAILABLE + } else { + /* assume sizeof(size_t) <= sizeof(unsigned long long) */ + return SWIG_From_unsigned_SS_long_SS_long (static_cast< unsigned long long >(value)); + } +#endif +} + +SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){ + return swig::getslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){ + swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >()); + } +SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){ + swig::setslice(self, i, j, 1, v); + } +SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){ + swig::delslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){ + swig::erase(self, swig::getpos(self, i)); + } +SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< double,std::allocator< double > >::difference_type id = i; + std::vector< double,std::allocator< double > >::difference_type jd = j; + return swig::getslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice,std::vector< double,std::allocator< double > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< double,std::allocator< double > >::difference_type id = i; + std::vector< double,std::allocator< double > >::difference_type jd = j; + swig::setslice(self, id, jd, step, v); + } +SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< double,std::allocator< double > >::difference_type id = i; + std::vector< double,std::allocator< double > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< double,std::allocator< double > >::difference_type id = i; + std::vector< double,std::allocator< double > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){ + return *(swig::cgetpos(self, i)); + } + +namespace swig { + static PyObject* container_owner_attribute() { + static PyObject* attr = SWIG_Python_str_FromChar("__swig_container"); + return attr; + } + + template + struct container_owner { + // By default, do not add the back-reference (for value types) + // Specialization below will check the reference for pointer types. + static bool back_reference(PyObject* /*child*/, PyObject* /*owner*/) { + return false; + } + }; + + template <> + struct container_owner { + /* + * Call to add a back-reference to the owning object when returning a + * reference from a container. Will only set the reference if child + * is a SWIG wrapper object that does not own the pointer. + * + * returns whether the reference was set or not + */ + static bool back_reference(PyObject* child, PyObject* owner) { + SwigPyObject* swigThis = SWIG_Python_GetSwigThis(child); + if (swigThis && (swigThis->own & SWIG_POINTER_OWN) != SWIG_POINTER_OWN) { + return PyObject_SetAttr(child, container_owner_attribute(), owner) != -1; + } + return false; + } + }; +} + +SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector< double,std::allocator< double > >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); } +SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); } +SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); } +SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); } + + namespace swig { + template <> struct traits< sxtwl::JieQiInfo > { + typedef pointer_category category; + static const char* type_name() { return"sxtwl::JieQiInfo"; } + }; + } + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "sxtwl::JieQiInfo" "," "std::allocator< sxtwl::JieQiInfo >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_sxtwl_JieQiInfo_Sg__iterator(std::vector< sxtwl::JieQiInfo > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_sxtwl_JieQiInfo_Sg____nonzero__(std::vector< sxtwl::JieQiInfo > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_sxtwl_JieQiInfo_Sg____bool__(std::vector< sxtwl::JieQiInfo > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< sxtwl::JieQiInfo >::size_type std_vector_Sl_sxtwl_JieQiInfo_Sg____len__(std::vector< sxtwl::JieQiInfo > const *self){ + return self->size(); + } +SWIGINTERN std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *std_vector_Sl_sxtwl_JieQiInfo_Sg____getslice__(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo >::difference_type i,std::vector< sxtwl::JieQiInfo >::difference_type j){ + return swig::getslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg____setslice____SWIG_0(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo >::difference_type i,std::vector< sxtwl::JieQiInfo >::difference_type j){ + swig::setslice(self, i, j, 1, std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >()); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg____setslice____SWIG_1(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo >::difference_type i,std::vector< sxtwl::JieQiInfo >::difference_type j,std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > const &v){ + swig::setslice(self, i, j, 1, v); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg____delslice__(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo >::difference_type i,std::vector< sxtwl::JieQiInfo >::difference_type j){ + swig::delslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg____delitem____SWIG_0(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo >::difference_type i){ + swig::erase(self, swig::getpos(self, i)); + } +SWIGINTERN std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *std_vector_Sl_sxtwl_JieQiInfo_Sg____getitem____SWIG_0(std::vector< sxtwl::JieQiInfo > *self,SWIGPY_SLICEOBJECT *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >::difference_type id = i; + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >::difference_type jd = j; + return swig::getslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg____setitem____SWIG_0(std::vector< sxtwl::JieQiInfo > *self,SWIGPY_SLICEOBJECT *slice,std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >::difference_type id = i; + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >::difference_type jd = j; + swig::setslice(self, id, jd, step, v); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg____setitem____SWIG_1(std::vector< sxtwl::JieQiInfo > *self,SWIGPY_SLICEOBJECT *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >::difference_type id = i; + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg____delitem____SWIG_1(std::vector< sxtwl::JieQiInfo > *self,SWIGPY_SLICEOBJECT *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >::difference_type id = i; + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN std::vector< sxtwl::JieQiInfo >::value_type const &std_vector_Sl_sxtwl_JieQiInfo_Sg____getitem____SWIG_1(std::vector< sxtwl::JieQiInfo > const *self,std::vector< sxtwl::JieQiInfo >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg____setitem____SWIG_2(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo >::difference_type i,std::vector< sxtwl::JieQiInfo >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN std::vector< sxtwl::JieQiInfo >::value_type std_vector_Sl_sxtwl_JieQiInfo_Sg__pop(std::vector< sxtwl::JieQiInfo > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__append(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN std::vector< sxtwl::JieQiInfo >::iterator std_vector_Sl_sxtwl_JieQiInfo_Sg__erase__SWIG_0(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo >::iterator pos){ return self->erase(pos); } +SWIGINTERN std::vector< sxtwl::JieQiInfo >::iterator std_vector_Sl_sxtwl_JieQiInfo_Sg__erase__SWIG_1(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo >::iterator first,std::vector< sxtwl::JieQiInfo >::iterator last){ return self->erase(first, last); } +SWIGINTERN std::vector< sxtwl::JieQiInfo >::iterator std_vector_Sl_sxtwl_JieQiInfo_Sg__insert__SWIG_0(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo >::iterator pos,std::vector< sxtwl::JieQiInfo >::value_type const &x){ return self->insert(pos, x); } +SWIGINTERN void std_vector_Sl_sxtwl_JieQiInfo_Sg__insert__SWIG_1(std::vector< sxtwl::JieQiInfo > *self,std::vector< sxtwl::JieQiInfo >::iterator pos,std::vector< sxtwl::JieQiInfo >::size_type n,std::vector< sxtwl::JieQiInfo >::value_type const &x){ self->insert(pos, n, x); } + +SWIGINTERNINLINE PyObject* + SWIG_From_int (int value) +{ + return PyInt_FromLong((long) value); +} + + +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 = static_cast< int >(v); + } + } + return res; +} + + +SWIGINTERN int +SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val) +{ + unsigned long v; + int res = SWIG_AsVal_unsigned_SS_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v > UCHAR_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< unsigned char >(v); + } + } + return res; +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_unsigned_SS_char (unsigned char value) +{ + return SWIG_From_unsigned_SS_long (value); +} + + +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value(); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + try { + result = (swig::SwigPyIterator *)(arg1)->incr(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (swig::SwigPyIterator *)(arg1)->incr(); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_incr", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SwigPyIterator_incr__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SwigPyIterator_incr__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n" + " Possible C/C++ prototypes are:\n" + " swig::SwigPyIterator::incr(size_t)\n" + " swig::SwigPyIterator::incr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + try { + result = (swig::SwigPyIterator *)(arg1)->decr(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (swig::SwigPyIterator *)(arg1)->decr(); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n" + " Possible C/C++ prototypes are:\n" + " swig::SwigPyIterator::decr(size_t)\n" + " swig::SwigPyIterator::decr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + ptrdiff_t result; + + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + try { + result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2); + } catch(std::invalid_argument &_e) { + SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; + } + resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + try { + result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2); + } catch(std::invalid_argument &_e) { + SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + swig::SwigPyIterator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)(arg1)->next(); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)(arg1)->__next__(); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)(arg1)->previous(); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + swig::SwigPyIterator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *)(arg1)->advance(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + swig::SwigPyIterator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + swig::SwigPyIterator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + swig::SwigPyIterator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + ptrdiff_t result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2); + resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); + return resultobj; +fail: + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv); + } + } + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_JDList_iterator(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + swig::SwigPyIterator *result = 0 ; + + arg2 = &swig_obj[0]; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_iterator" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___nonzero__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___bool__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___bool__" "', argument " "1"" of type '" "std::vector< double > const *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = (bool)std_vector_Sl_double_Sg____bool__((std::vector< double > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___len__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< double >::size_type result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___len__" "', argument " "1"" of type '" "std::vector< double > const *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___getslice__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::difference_type arg2 ; + std::vector< double >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + std::vector< double,std::allocator< double > > *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "JDList___getslice__", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'"); + } + arg2 = static_cast< std::vector< double >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JDList___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'"); + } + arg3 = static_cast< std::vector< double >::difference_type >(val3); + try { + result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::difference_type arg2 ; + std::vector< double >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'"); + } + arg2 = static_cast< std::vector< double >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JDList___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'"); + } + arg3 = static_cast< std::vector< double >::difference_type >(val3); + try { + std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::difference_type arg2 ; + std::vector< double >::difference_type arg3 ; + std::vector< double,std::allocator< double > > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'"); + } + arg2 = static_cast< std::vector< double >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JDList___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'"); + } + arg3 = static_cast< std::vector< double >::difference_type >(val3); + { + std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0; + res4 = swig::asptr(swig_obj[3], &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "JDList___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JDList___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); + } + arg4 = ptr; + } + try { + std_vector_Sl_double_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< double,std::allocator< double > > const &)*arg4); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___setslice__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JDList___setslice__", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_JDList___setslice____SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_JDList___setslice____SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JDList___setslice__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n" + " std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JDList___delslice__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::difference_type arg2 ; + std::vector< double >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "JDList___delslice__", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'"); + } + arg2 = static_cast< std::vector< double >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JDList___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'"); + } + arg3 = static_cast< std::vector< double >::difference_type >(val3); + try { + std_vector_Sl_double_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'"); + } + arg2 = static_cast< std::vector< double >::difference_type >(val2); + try { + std_vector_Sl_double_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< double,std::allocator< double > > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___getitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + try { + result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + std::vector< double,std::allocator< double > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 = SWIG_OLDOBJ ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + { + std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0; + res3 = swig::asptr(swig_obj[2], &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "JDList___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JDList___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); + } + arg3 = ptr; + } + try { + std_vector_Sl_double_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + try { + std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + try { + std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___delitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JDList___delitem__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_JDList___delitem____SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_JDList___delitem____SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JDList___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< double >::__delitem__(std::vector< double >::difference_type)\n" + " std::vector< double >::__delitem__(SWIGPY_SLICEOBJECT *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JDList___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< double >::value_type *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'"); + } + arg2 = static_cast< std::vector< double >::difference_type >(val2); + try { + result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg____getitem____SWIG_1((std::vector< double > const *)arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_From_double(static_cast< double >(*result)); + (void)swig::container_owner::value_type>::category>::back_reference(resultobj, swig_obj[0]); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___getitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JDList___getitem__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_JDList___getitem____SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_JDList___getitem____SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JDList___getitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< double >::__getitem__(SWIGPY_SLICEOBJECT *)\n" + " std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JDList___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::difference_type arg2 ; + std::vector< double >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< double >::value_type temp3 ; + double val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'"); + } + arg2 = static_cast< std::vector< double >::difference_type >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JDList___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'"); + } + temp3 = static_cast< std::vector< double >::value_type >(val3); + arg3 = &temp3; + try { + std_vector_Sl_double_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(double const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList___setitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JDList___setitem__", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_JDList___setitem____SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_JDList___setitem____SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_JDList___setitem____SWIG_2(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JDList___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n" + " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n" + " std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JDList_pop(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< double >::value_type result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_pop" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + try { + result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_append(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< double >::value_type temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "JDList_append", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_append" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'"); + } + temp2 = static_cast< std::vector< double >::value_type >(val2); + arg2 = &temp2; + std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_JDList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + std::vector< double > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (std::vector< double > *)new std::vector< double >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_JDList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + std::vector< double > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0; + res1 = swig::asptr(swig_obj[0], &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JDList" "', argument " "1"" of type '" "std::vector< double > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JDList" "', argument " "1"" of type '" "std::vector< double > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_empty(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_empty" "', argument " "1"" of type '" "std::vector< double > const *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = (bool)((std::vector< double > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_size(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< double >::size_type result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_size" "', argument " "1"" of type '" "std::vector< double > const *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = ((std::vector< double > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_swap(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "JDList_swap", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_swap" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JDList_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JDList_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); + } + arg2 = reinterpret_cast< std::vector< double > * >(argp2); + (arg1)->swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_begin(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< double >::iterator result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_begin" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = (arg1)->begin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_end(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< double >::iterator result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_end" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = (arg1)->end(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_rbegin(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< double >::reverse_iterator result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_rbegin" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = (arg1)->rbegin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_rend(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< double >::reverse_iterator result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_rend" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = (arg1)->rend(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_clear(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_clear" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_get_allocator(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< std::allocator< double > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = ((std::vector< double > const *)arg1)->get_allocator(); + resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_JDList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< double > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JDList" "', argument " "1"" of type '" "std::vector< double >::size_type""'"); + } + arg1 = static_cast< std::vector< double >::size_type >(val1); + result = (std::vector< double > *)new std::vector< double >(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_pop_back(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + (arg1)->pop_back(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_resize" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'"); + } + arg2 = static_cast< std::vector< double >::size_type >(val2); + (arg1)->resize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::iterator arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + std::vector< double >::iterator result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_erase" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'"); + } + } + result = std_vector_Sl_double_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2)); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::iterator arg2 ; + std::vector< double >::iterator arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + swig::SwigPyIterator *iter3 = 0 ; + int res3 ; + std::vector< double >::iterator result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_erase" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'"); + } + } + result = std_vector_Sl_double_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_erase(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JDList_erase", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_JDList_erase__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_JDList_erase__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JDList_erase'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< double >::erase(std::vector< double >::iterator)\n" + " std::vector< double >::erase(std::vector< double >::iterator,std::vector< double >::iterator)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_JDList__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double >::size_type arg1 ; + std::vector< double >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< double >::value_type temp2 ; + double val2 ; + int ecode2 = 0 ; + std::vector< double > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JDList" "', argument " "1"" of type '" "std::vector< double >::size_type""'"); + } + arg1 = static_cast< std::vector< double >::size_type >(val1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JDList" "', argument " "2"" of type '" "std::vector< double >::value_type""'"); + } + temp2 = static_cast< std::vector< double >::value_type >(val2); + arg2 = &temp2; + result = (std::vector< double > *)new std::vector< double >(arg1,(std::vector< double >::value_type const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_JDList(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_JDList", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_JDList__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_JDList__SWIG_2(self, argc, argv); + } + } + if (argc == 1) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_JDList__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_JDList__SWIG_3(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_JDList'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< double >::vector()\n" + " std::vector< double >::vector(std::vector< double > const &)\n" + " std::vector< double >::vector(std::vector< double >::size_type)\n" + " std::vector< double >::vector(std::vector< double >::size_type,std::vector< double >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JDList_push_back(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< double >::value_type temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "JDList_push_back", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_push_back" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'"); + } + temp2 = static_cast< std::vector< double >::value_type >(val2); + arg2 = &temp2; + (arg1)->push_back((std::vector< double >::value_type const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_front(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< double >::value_type *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_front" "', argument " "1"" of type '" "std::vector< double > const *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->front(); + resultobj = SWIG_From_double(static_cast< double >(*result)); + (void)swig::container_owner::value_type>::category>::back_reference(resultobj, swig_obj[0]); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_back(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< double >::value_type *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_back" "', argument " "1"" of type '" "std::vector< double > const *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->back(); + resultobj = SWIG_From_double(static_cast< double >(*result)); + (void)swig::container_owner::value_type>::category>::back_reference(resultobj, swig_obj[0]); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_assign(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type arg2 ; + std::vector< double >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< double >::value_type temp3 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "JDList_assign", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_assign" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'"); + } + arg2 = static_cast< std::vector< double >::size_type >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JDList_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'"); + } + temp3 = static_cast< std::vector< double >::value_type >(val3); + arg3 = &temp3; + (arg1)->assign(arg2,(std::vector< double >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type arg2 ; + std::vector< double >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< double >::value_type temp3 ; + double val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_resize" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'"); + } + arg2 = static_cast< std::vector< double >::size_type >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JDList_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'"); + } + temp3 = static_cast< std::vector< double >::value_type >(val3); + arg3 = &temp3; + (arg1)->resize(arg2,(std::vector< double >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_resize(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JDList_resize", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_JDList_resize__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_JDList_resize__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JDList_resize'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< double >::resize(std::vector< double >::size_type)\n" + " std::vector< double >::resize(std::vector< double >::size_type,std::vector< double >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JDList_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::iterator arg2 ; + std::vector< double >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + std::vector< double >::value_type temp3 ; + double val3 ; + int ecode3 = 0 ; + std::vector< double >::iterator result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_insert" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JDList_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'"); + } + temp3 = static_cast< std::vector< double >::value_type >(val3); + arg3 = &temp3; + result = std_vector_Sl_double_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(double const &)*arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::iterator arg2 ; + std::vector< double >::size_type arg3 ; + std::vector< double >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + std::vector< double >::value_type temp4 ; + double val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_insert" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JDList_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JDList_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'"); + } + arg3 = static_cast< std::vector< double >::size_type >(val3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "JDList_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'"); + } + temp4 = static_cast< std::vector< double >::value_type >(val4); + arg4 = &temp4; + std_vector_Sl_double_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(double const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_insert(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JDList_insert", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_JDList_insert__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_JDList_insert__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JDList_insert'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::value_type const &)\n" + " std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JDList_reserve(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + std::vector< double >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "JDList_reserve", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_reserve" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JDList_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'"); + } + arg2 = static_cast< std::vector< double >::size_type >(val2); + (arg1)->reserve(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JDList_capacity(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< double >::size_type result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JDList_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + result = ((std::vector< double > const *)arg1)->capacity(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_JDList(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< double > *arg1 = (std::vector< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JDList" "', argument " "1"" of type '" "std::vector< double > *""'"); + } + arg1 = reinterpret_cast< std::vector< double > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *JDList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *JDList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_JQList_iterator(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + swig::SwigPyIterator *result = 0 ; + + arg2 = &swig_obj[0]; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_iterator" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_sxtwl_JieQiInfo_Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___nonzero__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___nonzero__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = (bool)std_vector_Sl_sxtwl_JieQiInfo_Sg____nonzero__((std::vector< sxtwl::JieQiInfo > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___bool__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___bool__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = (bool)std_vector_Sl_sxtwl_JieQiInfo_Sg____bool__((std::vector< sxtwl::JieQiInfo > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___len__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< sxtwl::JieQiInfo >::size_type result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___len__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = std_vector_Sl_sxtwl_JieQiInfo_Sg____len__((std::vector< sxtwl::JieQiInfo > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___getslice__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::difference_type arg2 ; + std::vector< sxtwl::JieQiInfo >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "JQList___getslice__", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___getslice__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JQList___getslice__" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< sxtwl::JieQiInfo >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JQList___getslice__" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::difference_type""'"); + } + arg3 = static_cast< std::vector< sxtwl::JieQiInfo >::difference_type >(val3); + try { + result = (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *)std_vector_Sl_sxtwl_JieQiInfo_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::difference_type arg2 ; + std::vector< sxtwl::JieQiInfo >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___setslice__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JQList___setslice__" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< sxtwl::JieQiInfo >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JQList___setslice__" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::difference_type""'"); + } + arg3 = static_cast< std::vector< sxtwl::JieQiInfo >::difference_type >(val3); + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::difference_type arg2 ; + std::vector< sxtwl::JieQiInfo >::difference_type arg3 ; + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___setslice__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JQList___setslice__" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< sxtwl::JieQiInfo >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JQList___setslice__" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::difference_type""'"); + } + arg3 = static_cast< std::vector< sxtwl::JieQiInfo >::difference_type >(val3); + { + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *ptr = (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *)0; + res4 = swig::asptr(swig_obj[3], &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "JQList___setslice__" "', argument " "4"" of type '" "std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JQList___setslice__" "', argument " "4"" of type '" "std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > const &""'"); + } + arg4 = ptr; + } + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > const &)*arg4); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___setslice__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JQList___setslice__", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_JQList___setslice____SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = swig::asptr(argv[3], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_JQList___setslice____SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JQList___setslice__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< sxtwl::JieQiInfo >::__setslice__(std::vector< sxtwl::JieQiInfo >::difference_type,std::vector< sxtwl::JieQiInfo >::difference_type)\n" + " std::vector< sxtwl::JieQiInfo >::__setslice__(std::vector< sxtwl::JieQiInfo >::difference_type,std::vector< sxtwl::JieQiInfo >::difference_type,std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JQList___delslice__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::difference_type arg2 ; + std::vector< sxtwl::JieQiInfo >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "JQList___delslice__", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___delslice__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JQList___delslice__" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< sxtwl::JieQiInfo >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JQList___delslice__" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::difference_type""'"); + } + arg3 = static_cast< std::vector< sxtwl::JieQiInfo >::difference_type >(val3); + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___delitem__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JQList___delitem__" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< sxtwl::JieQiInfo >::difference_type >(val2); + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___getitem__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + try { + result = (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *)std_vector_Sl_sxtwl_JieQiInfo_Sg____getitem____SWIG_0(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 = SWIG_OLDOBJ ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___setitem__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + { + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *ptr = (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *)0; + res3 = swig::asptr(swig_obj[2], &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "JQList___setitem__" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JQList___setitem__" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > const &""'"); + } + arg3 = ptr; + } + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___setitem__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg____setitem____SWIG_1(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___delitem__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg____delitem____SWIG_1(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___delitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JQList___delitem__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_JQList___delitem____SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_JQList___delitem____SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JQList___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< sxtwl::JieQiInfo >::__delitem__(std::vector< sxtwl::JieQiInfo >::difference_type)\n" + " std::vector< sxtwl::JieQiInfo >::__delitem__(SWIGPY_SLICEOBJECT *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JQList___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< sxtwl::JieQiInfo >::value_type *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___getitem__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JQList___getitem__" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< sxtwl::JieQiInfo >::difference_type >(val2); + try { + result = (std::vector< sxtwl::JieQiInfo >::value_type *) &std_vector_Sl_sxtwl_JieQiInfo_Sg____getitem____SWIG_1((std::vector< sxtwl::JieQiInfo > const *)arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0 ); + (void)swig::container_owner::value_type>::category>::back_reference(resultobj, swig_obj[0]); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___getitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JQList___getitem__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_JQList___getitem____SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_JQList___getitem____SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JQList___getitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< sxtwl::JieQiInfo >::__getitem__(SWIGPY_SLICEOBJECT *)\n" + " std::vector< sxtwl::JieQiInfo >::__getitem__(std::vector< sxtwl::JieQiInfo >::difference_type) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JQList___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::difference_type arg2 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList___setitem__" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JQList___setitem__" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::difference_type""'"); + } + arg2 = static_cast< std::vector< sxtwl::JieQiInfo >::difference_type >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "JQList___setitem__" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JQList___setitem__" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< sxtwl::JieQiInfo >::value_type * >(argp3); + try { + std_vector_Sl_sxtwl_JieQiInfo_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(sxtwl::JieQiInfo const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList___setitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JQList___setitem__", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_JQList___setitem____SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_JQList___setitem____SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sxtwl__JieQiInfo, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_JQList___setitem____SWIG_2(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JQList___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< sxtwl::JieQiInfo >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > const &)\n" + " std::vector< sxtwl::JieQiInfo >::__setitem__(SWIGPY_SLICEOBJECT *)\n" + " std::vector< sxtwl::JieQiInfo >::__setitem__(std::vector< sxtwl::JieQiInfo >::difference_type,std::vector< sxtwl::JieQiInfo >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JQList_pop(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< sxtwl::JieQiInfo >::value_type result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_pop" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + try { + result = std_vector_Sl_sxtwl_JieQiInfo_Sg__pop(arg1); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_NewPointerObj((new std::vector< sxtwl::JieQiInfo >::value_type(result)), SWIGTYPE_p_sxtwl__JieQiInfo, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_append(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "JQList_append", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_append" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JQList_append" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JQList_append" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + arg2 = reinterpret_cast< std::vector< sxtwl::JieQiInfo >::value_type * >(argp2); + std_vector_Sl_sxtwl_JieQiInfo_Sg__append(arg1,(sxtwl::JieQiInfo const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_JQList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_JQList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *ptr = (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *)0; + res1 = swig::asptr(swig_obj[0], &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JQList" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JQList" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >((std::vector< sxtwl::JieQiInfo > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_empty(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_empty" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = (bool)((std::vector< sxtwl::JieQiInfo > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_size(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< sxtwl::JieQiInfo >::size_type result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_size" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = ((std::vector< sxtwl::JieQiInfo > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_swap(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "JQList_swap", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_swap" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JQList_swap" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JQList_swap" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo > &""'"); + } + arg2 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp2); + (arg1)->swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_begin(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< sxtwl::JieQiInfo >::iterator result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_begin" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = (arg1)->begin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sxtwl::JieQiInfo >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_end(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< sxtwl::JieQiInfo >::iterator result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_end" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = (arg1)->end(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sxtwl::JieQiInfo >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_rbegin(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< sxtwl::JieQiInfo >::reverse_iterator result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_rbegin" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = (arg1)->rbegin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sxtwl::JieQiInfo >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_rend(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< sxtwl::JieQiInfo >::reverse_iterator result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_rend" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = (arg1)->rend(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sxtwl::JieQiInfo >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_clear(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_clear" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_get_allocator(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< std::allocator< sxtwl::JieQiInfo > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_get_allocator" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = ((std::vector< sxtwl::JieQiInfo > const *)arg1)->get_allocator(); + resultobj = SWIG_NewPointerObj((new std::vector< sxtwl::JieQiInfo >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_sxtwl__JieQiInfo_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_JQList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JQList" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo >::size_type""'"); + } + arg1 = static_cast< std::vector< sxtwl::JieQiInfo >::size_type >(val1); + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_pop_back(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_pop_back" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + (arg1)->pop_back(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_resize" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JQList_resize" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::size_type""'"); + } + arg2 = static_cast< std::vector< sxtwl::JieQiInfo >::size_type >(val2); + (arg1)->resize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::iterator arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + std::vector< sxtwl::JieQiInfo >::iterator result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_erase" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList_erase" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList_erase" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::iterator""'"); + } + } + result = std_vector_Sl_sxtwl_JieQiInfo_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2)); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sxtwl::JieQiInfo >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::iterator arg2 ; + std::vector< sxtwl::JieQiInfo >::iterator arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + swig::SwigPyIterator *iter3 = 0 ; + int res3 ; + std::vector< sxtwl::JieQiInfo >::iterator result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_erase" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList_erase" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList_erase" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList_erase" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList_erase" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::iterator""'"); + } + } + result = std_vector_Sl_sxtwl_JieQiInfo_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sxtwl::JieQiInfo >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_erase(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JQList_erase", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_JQList_erase__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_JQList_erase__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JQList_erase'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< sxtwl::JieQiInfo >::erase(std::vector< sxtwl::JieQiInfo >::iterator)\n" + " std::vector< sxtwl::JieQiInfo >::erase(std::vector< sxtwl::JieQiInfo >::iterator,std::vector< sxtwl::JieQiInfo >::iterator)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_JQList__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo >::size_type arg1 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::vector< sxtwl::JieQiInfo > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JQList" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo >::size_type""'"); + } + arg1 = static_cast< std::vector< sxtwl::JieQiInfo >::size_type >(val1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JQList" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JQList" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + arg2 = reinterpret_cast< std::vector< sxtwl::JieQiInfo >::value_type * >(argp2); + result = (std::vector< sxtwl::JieQiInfo > *)new std::vector< sxtwl::JieQiInfo >(arg1,(std::vector< sxtwl::JieQiInfo >::value_type const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_JQList(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_JQList", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_JQList__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_JQList__SWIG_2(self, argc, argv); + } + } + if (argc == 1) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_JQList__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sxtwl__JieQiInfo, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_JQList__SWIG_3(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_JQList'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< sxtwl::JieQiInfo >::vector()\n" + " std::vector< sxtwl::JieQiInfo >::vector(std::vector< sxtwl::JieQiInfo > const &)\n" + " std::vector< sxtwl::JieQiInfo >::vector(std::vector< sxtwl::JieQiInfo >::size_type)\n" + " std::vector< sxtwl::JieQiInfo >::vector(std::vector< sxtwl::JieQiInfo >::size_type,std::vector< sxtwl::JieQiInfo >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JQList_push_back(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "JQList_push_back", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_push_back" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JQList_push_back" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JQList_push_back" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + arg2 = reinterpret_cast< std::vector< sxtwl::JieQiInfo >::value_type * >(argp2); + (arg1)->push_back((std::vector< sxtwl::JieQiInfo >::value_type const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_front(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< sxtwl::JieQiInfo >::value_type *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_front" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = (std::vector< sxtwl::JieQiInfo >::value_type *) &((std::vector< sxtwl::JieQiInfo > const *)arg1)->front(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0 ); + (void)swig::container_owner::value_type>::category>::back_reference(resultobj, swig_obj[0]); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_back(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< sxtwl::JieQiInfo >::value_type *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_back" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = (std::vector< sxtwl::JieQiInfo >::value_type *) &((std::vector< sxtwl::JieQiInfo > const *)arg1)->back(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0 ); + (void)swig::container_owner::value_type>::category>::back_reference(resultobj, swig_obj[0]); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_assign(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type arg2 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "JQList_assign", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_assign" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JQList_assign" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::size_type""'"); + } + arg2 = static_cast< std::vector< sxtwl::JieQiInfo >::size_type >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "JQList_assign" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JQList_assign" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< sxtwl::JieQiInfo >::value_type * >(argp3); + (arg1)->assign(arg2,(std::vector< sxtwl::JieQiInfo >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type arg2 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_resize" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JQList_resize" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::size_type""'"); + } + arg2 = static_cast< std::vector< sxtwl::JieQiInfo >::size_type >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "JQList_resize" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JQList_resize" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< sxtwl::JieQiInfo >::value_type * >(argp3); + (arg1)->resize(arg2,(std::vector< sxtwl::JieQiInfo >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_resize(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JQList_resize", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_JQList_resize__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sxtwl__JieQiInfo, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_JQList_resize__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JQList_resize'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< sxtwl::JieQiInfo >::resize(std::vector< sxtwl::JieQiInfo >::size_type)\n" + " std::vector< sxtwl::JieQiInfo >::resize(std::vector< sxtwl::JieQiInfo >::size_type,std::vector< sxtwl::JieQiInfo >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JQList_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::iterator arg2 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + void *argp3 = 0 ; + int res3 = 0 ; + std::vector< sxtwl::JieQiInfo >::iterator result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_insert" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList_insert" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList_insert" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "JQList_insert" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JQList_insert" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + arg3 = reinterpret_cast< std::vector< sxtwl::JieQiInfo >::value_type * >(argp3); + result = std_vector_Sl_sxtwl_JieQiInfo_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(sxtwl::JieQiInfo const &)*arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sxtwl::JieQiInfo >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::iterator arg2 ; + std::vector< sxtwl::JieQiInfo >::size_type arg3 ; + std::vector< sxtwl::JieQiInfo >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_insert" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList_insert" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "JQList_insert" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JQList_insert" "', argument " "3"" of type '" "std::vector< sxtwl::JieQiInfo >::size_type""'"); + } + arg3 = static_cast< std::vector< sxtwl::JieQiInfo >::size_type >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "JQList_insert" "', argument " "4"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JQList_insert" "', argument " "4"" of type '" "std::vector< sxtwl::JieQiInfo >::value_type const &""'"); + } + arg4 = reinterpret_cast< std::vector< sxtwl::JieQiInfo >::value_type * >(argp4); + std_vector_Sl_sxtwl_JieQiInfo_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(sxtwl::JieQiInfo const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_insert(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "JQList_insert", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sxtwl__JieQiInfo, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_JQList_insert__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_sxtwl__JieQiInfo, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_JQList_insert__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'JQList_insert'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< sxtwl::JieQiInfo >::insert(std::vector< sxtwl::JieQiInfo >::iterator,std::vector< sxtwl::JieQiInfo >::value_type const &)\n" + " std::vector< sxtwl::JieQiInfo >::insert(std::vector< sxtwl::JieQiInfo >::iterator,std::vector< sxtwl::JieQiInfo >::size_type,std::vector< sxtwl::JieQiInfo >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JQList_reserve(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + std::vector< sxtwl::JieQiInfo >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "JQList_reserve", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_reserve" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JQList_reserve" "', argument " "2"" of type '" "std::vector< sxtwl::JieQiInfo >::size_type""'"); + } + arg2 = static_cast< std::vector< sxtwl::JieQiInfo >::size_type >(val2); + (arg1)->reserve(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JQList_capacity(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< sxtwl::JieQiInfo >::size_type result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JQList_capacity" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > const *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + result = ((std::vector< sxtwl::JieQiInfo > const *)arg1)->capacity(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_JQList(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< sxtwl::JieQiInfo > *arg1 = (std::vector< sxtwl::JieQiInfo > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JQList" "', argument " "1"" of type '" "std::vector< sxtwl::JieQiInfo > *""'"); + } + arg1 = reinterpret_cast< std::vector< sxtwl::JieQiInfo > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *JQList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *JQList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_Time__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + Time *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (Time *)new Time(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Time, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Time__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + double arg4 ; + double arg5 ; + double arg6 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + double val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + Time *result = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Time" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Time" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Time" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Time" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Time" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Time" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + result = (Time *)new Time(arg1,arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Time, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Time(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_Time", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_Time__SWIG_0(self, argc, argv); + } + if (argc == 6) { + int _v = 0; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Time__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Time'.\n" + " Possible C/C++ prototypes are:\n" + " Time::Time()\n" + " Time::Time(int,int,int,double,double,double)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Time_Y_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Time_Y_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_Y_set" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Time_Y_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->Y = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_Y_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_Y_get" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (int) ((arg1)->Y); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_M_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Time_M_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_M_set" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Time_M_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->M = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_M_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_M_get" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (int) ((arg1)->M); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_D_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Time_D_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_D_set" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Time_D_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->D = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_D_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_D_get" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (int) ((arg1)->D); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_h_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Time_h_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_h_set" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Time_h_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + if (arg1) (arg1)->h = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_h_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_h_get" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (double) ((arg1)->h); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_m_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Time_m_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_m_set" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Time_m_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + if (arg1) (arg1)->m = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_m_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_m_get" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (double) ((arg1)->m); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_s_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Time_s_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_s_set" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Time_s_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + if (arg1) (arg1)->s = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_s_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_s_get" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (double) ((arg1)->s); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_getYear(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_getYear" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (int)(arg1)->getYear(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_setYear(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Time_setYear", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_setYear" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Time_setYear" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setYear(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_setMonth(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Time_setMonth", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_setMonth" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Time_setMonth" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setMonth(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_getMonth(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_getMonth" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (int)(arg1)->getMonth(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_getDay(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_getDay" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (int)(arg1)->getDay(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_setDay(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Time_setDay", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_setDay" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Time_setDay" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setDay(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_getHour(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_getHour" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (double)(arg1)->getHour(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_setHour(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Time_setHour", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_setHour" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Time_setHour" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + (arg1)->setHour(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_getMin(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_getMin" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (double)(arg1)->getMin(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_setMour(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Time_setMour", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_setMour" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Time_setMour" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + (arg1)->setMour(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_getSec(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_getSec" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (double)(arg1)->getSec(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Time_setSec(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Time_setSec", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_setSec" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Time_setSec" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + (arg1)->setSec(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_Time(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = (Time *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Time, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Time" "', argument " "1"" of type '" "Time *""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Time_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_Time, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *Time_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_GZ__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + GZ *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (GZ *)new GZ(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GZ, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GZ__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uint8_t arg1 ; + uint8_t arg2 ; + unsigned char val1 ; + int ecode1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + GZ *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GZ" "', argument " "1"" of type '" "uint8_t""'"); + } + arg1 = static_cast< uint8_t >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GZ" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + result = (GZ *)new GZ(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GZ, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GZ(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_GZ", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_GZ__SWIG_0(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_AsVal_unsigned_SS_char(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_GZ__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GZ'.\n" + " Possible C/C++ prototypes are:\n" + " GZ::GZ()\n" + " GZ::GZ(uint8_t,uint8_t)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GZ_tg_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + GZ *arg1 = (GZ *) 0 ; + uint8_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "GZ_tg_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GZ, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GZ_tg_set" "', argument " "1"" of type '" "GZ *""'"); + } + arg1 = reinterpret_cast< GZ * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GZ_tg_set" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + if (arg1) (arg1)->tg = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GZ_tg_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + GZ *arg1 = (GZ *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint8_t result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GZ, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GZ_tg_get" "', argument " "1"" of type '" "GZ *""'"); + } + arg1 = reinterpret_cast< GZ * >(argp1); + result = (uint8_t) ((arg1)->tg); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GZ_dz_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + GZ *arg1 = (GZ *) 0 ; + uint8_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "GZ_dz_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GZ, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GZ_dz_set" "', argument " "1"" of type '" "GZ *""'"); + } + arg1 = reinterpret_cast< GZ * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GZ_dz_set" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + if (arg1) (arg1)->dz = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GZ_dz_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + GZ *arg1 = (GZ *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint8_t result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GZ, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GZ_dz_get" "', argument " "1"" of type '" "GZ *""'"); + } + arg1 = reinterpret_cast< GZ * >(argp1); + result = (uint8_t) ((arg1)->dz); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_GZ(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + GZ *arg1 = (GZ *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GZ, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GZ" "', argument " "1"" of type '" "GZ *""'"); + } + arg1 = reinterpret_cast< GZ * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *GZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_GZ, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GZ_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_Day_fromSolar(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + int val1 ; + int ecode1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + Day *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "Day_fromSolar", 3, 3, swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Day_fromSolar" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Day_fromSolar" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Day_fromSolar" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (Day *)Day::fromSolar(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Day, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_fromLunar__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + bool arg4 ; + int val1 ; + int ecode1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + Day *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Day_fromLunar" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Day_fromLunar" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Day_fromLunar" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Day_fromLunar" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + result = (Day *)Day::fromLunar(arg1,arg2,arg3,arg4); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Day, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_fromLunar__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + int val1 ; + int ecode1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + Day *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Day_fromLunar" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Day_fromLunar" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Day_fromLunar" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (Day *)Day::fromLunar(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Day, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_fromLunar(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Day_fromLunar", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Day_fromLunar__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Day_fromLunar__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Day_fromLunar'.\n" + " Possible C/C++ prototypes are:\n" + " Day::fromLunar(int,uint8_t,int,bool)\n" + " Day::fromLunar(int,uint8_t,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Day_after(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + Day *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "Day_after", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_after" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Day_after" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (Day *)(arg1)->after(arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Day, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_before(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + Day *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "Day_before", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_before" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Day_before" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (Day *)(arg1)->before(arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Day, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getLunarDay(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getLunarDay" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (int)(arg1)->getLunarDay(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getLunarMonth(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint8_t result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getLunarMonth" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (uint8_t)(arg1)->getLunarMonth(); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getLunarYear__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getLunarYear" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Day_getLunarYear" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + result = (int)(arg1)->getLunarYear(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getLunarYear__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getLunarYear" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (int)(arg1)->getLunarYear(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getLunarYear(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Day_getLunarYear", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Day, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Day_getLunarYear__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Day, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Day_getLunarYear__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Day_getLunarYear'.\n" + " Possible C/C++ prototypes are:\n" + " Day::getLunarYear(bool)\n" + " Day::getLunarYear()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Day_getYearGZ__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + GZ result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getYearGZ" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Day_getYearGZ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + result = (arg1)->getYearGZ(arg2); + resultobj = SWIG_NewPointerObj((new GZ(result)), SWIGTYPE_p_GZ, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getYearGZ__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + GZ result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getYearGZ" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (arg1)->getYearGZ(); + resultobj = SWIG_NewPointerObj((new GZ(result)), SWIGTYPE_p_GZ, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getYearGZ(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Day_getYearGZ", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Day, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Day_getYearGZ__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Day, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Day_getYearGZ__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Day_getYearGZ'.\n" + " Possible C/C++ prototypes are:\n" + " Day::getYearGZ(bool)\n" + " Day::getYearGZ()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Day_getMonthGZ(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + GZ result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getMonthGZ" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (arg1)->getMonthGZ(); + resultobj = SWIG_NewPointerObj((new GZ(result)), SWIGTYPE_p_GZ, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getDayGZ(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + GZ result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getDayGZ" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (arg1)->getDayGZ(); + resultobj = SWIG_NewPointerObj((new GZ(result)), SWIGTYPE_p_GZ, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getHourGZ__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + uint8_t arg2 ; + bool arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + GZ result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getHourGZ" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Day_getHourGZ" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Day_getHourGZ" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + result = (arg1)->getHourGZ(arg2,arg3); + resultobj = SWIG_NewPointerObj((new GZ(result)), SWIGTYPE_p_GZ, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getHourGZ__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + uint8_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + GZ result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getHourGZ" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Day_getHourGZ" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + result = (arg1)->getHourGZ(arg2); + resultobj = SWIG_NewPointerObj((new GZ(result)), SWIGTYPE_p_GZ, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getHourGZ(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Day_getHourGZ", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Day, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Day_getHourGZ__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Day, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Day_getHourGZ__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Day_getHourGZ'.\n" + " Possible C/C++ prototypes are:\n" + " Day::getHourGZ(uint8_t,bool)\n" + " Day::getHourGZ(uint8_t)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Day_isLunarLeap(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_isLunarLeap" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (bool)(arg1)->isLunarLeap(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getSolarYear(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getSolarYear" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (int)(arg1)->getSolarYear(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getSolarMonth(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint8_t result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getSolarMonth" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (uint8_t)(arg1)->getSolarMonth(); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getSolarDay(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getSolarDay" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (int)(arg1)->getSolarDay(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getWeek(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint8_t result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getWeek" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (uint8_t)(arg1)->getWeek(); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getWeekIndex(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint8_t result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getWeekIndex" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (uint8_t)(arg1)->getWeekIndex(); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_hasJieQi(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_hasJieQi" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (bool)(arg1)->hasJieQi(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getJieQi(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint8_t result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getJieQi" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (uint8_t)(arg1)->getJieQi(); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getJieQiJD(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getJieQiJD" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (double)(arg1)->getJieQiJD(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Day_getConstellation(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint8_t result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Day_getConstellation" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + result = (uint8_t)(arg1)->getConstellation(); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_Day(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Day *arg1 = (Day *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Day, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Day" "', argument " "1"" of type '" "Day *""'"); + } + arg1 = reinterpret_cast< Day * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Day_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_Day, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_JieQiInfo_jd_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "JieQiInfo_jd_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JieQiInfo_jd_set" "', argument " "1"" of type '" "sxtwl::JieQiInfo *""'"); + } + arg1 = reinterpret_cast< sxtwl::JieQiInfo * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JieQiInfo_jd_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + if (arg1) (arg1)->jd = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JieQiInfo_jd_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JieQiInfo_jd_get" "', argument " "1"" of type '" "sxtwl::JieQiInfo *""'"); + } + arg1 = reinterpret_cast< sxtwl::JieQiInfo * >(argp1); + result = (double) ((arg1)->jd); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JieQiInfo_jqIndex_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + uint8_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "JieQiInfo_jqIndex_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JieQiInfo_jqIndex_set" "', argument " "1"" of type '" "sxtwl::JieQiInfo *""'"); + } + arg1 = reinterpret_cast< sxtwl::JieQiInfo * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JieQiInfo_jqIndex_set" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + if (arg1) (arg1)->jqIndex = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_JieQiInfo_jqIndex_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint8_t result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sxtwl__JieQiInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JieQiInfo_jqIndex_get" "', argument " "1"" of type '" "sxtwl::JieQiInfo *""'"); + } + arg1 = reinterpret_cast< sxtwl::JieQiInfo * >(argp1); + result = (uint8_t) ((arg1)->jqIndex); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_JieQiInfo(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + sxtwl::JieQiInfo *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_JieQiInfo", 0, 0, 0)) SWIG_fail; + result = (sxtwl::JieQiInfo *)new sxtwl::JieQiInfo(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sxtwl__JieQiInfo, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_JieQiInfo(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + sxtwl::JieQiInfo *arg1 = (sxtwl::JieQiInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sxtwl__JieQiInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JieQiInfo" "', argument " "1"" of type '" "sxtwl::JieQiInfo *""'"); + } + arg1 = reinterpret_cast< sxtwl::JieQiInfo * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *JieQiInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_sxtwl__JieQiInfo, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *JieQiInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_fromSolar(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + int val1 ; + int ecode1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + Day *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "fromSolar", 3, 3, swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fromSolar" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fromSolar" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fromSolar" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (Day *)sxtwl::fromSolar(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Day, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_fromLunar__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + bool arg4 ; + int val1 ; + int ecode1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + Day *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fromLunar" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fromLunar" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fromLunar" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fromLunar" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + result = (Day *)sxtwl::fromLunar(arg1,arg2,arg3,arg4); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Day, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_fromLunar__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + uint8_t arg2 ; + int arg3 ; + int val1 ; + int ecode1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + Day *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fromLunar" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fromLunar" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fromLunar" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (Day *)sxtwl::fromLunar(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Day, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_fromLunar(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "fromLunar", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_fromLunar__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_fromLunar__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fromLunar'.\n" + " Possible C/C++ prototypes are:\n" + " sxtwl::fromLunar(int,uint8_t,int,bool)\n" + " sxtwl::fromLunar(int,uint8_t,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_siZhu2Year(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + GZ arg1 ; + GZ arg2 ; + GZ arg3 ; + GZ arg4 ; + int arg5 ; + int arg6 ; + void *argp1 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 ; + int res4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject *swig_obj[6] ; + std::vector< double,std::allocator< double > > result; + + if (!SWIG_Python_UnpackTuple(args, "siZhu2Year", 6, 6, swig_obj)) SWIG_fail; + { + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GZ, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "siZhu2Year" "', argument " "1"" of type '" "GZ""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "siZhu2Year" "', argument " "1"" of type '" "GZ""'"); + } else { + GZ * temp = reinterpret_cast< GZ * >(argp1); + arg1 = *temp; + if (SWIG_IsNewObj(res1)) delete temp; + } + } + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_GZ, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "siZhu2Year" "', argument " "2"" of type '" "GZ""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "siZhu2Year" "', argument " "2"" of type '" "GZ""'"); + } else { + GZ * temp = reinterpret_cast< GZ * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_GZ, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "siZhu2Year" "', argument " "3"" of type '" "GZ""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "siZhu2Year" "', argument " "3"" of type '" "GZ""'"); + } else { + GZ * temp = reinterpret_cast< GZ * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_GZ, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "siZhu2Year" "', argument " "4"" of type '" "GZ""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "siZhu2Year" "', argument " "4"" of type '" "GZ""'"); + } else { + GZ * temp = reinterpret_cast< GZ * >(argp4); + arg4 = *temp; + if (SWIG_IsNewObj(res4)) delete temp; + } + } + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "siZhu2Year" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "siZhu2Year" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + result = sxtwl::siZhu2Year(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,arg6); + resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_getShiGz__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uint8_t arg1 ; + uint8_t arg2 ; + bool arg3 ; + unsigned char val1 ; + int ecode1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + GZ result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getShiGz" "', argument " "1"" of type '" "uint8_t""'"); + } + arg1 = static_cast< uint8_t >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getShiGz" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "getShiGz" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + result = sxtwl::getShiGz(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj((new GZ(result)), SWIGTYPE_p_GZ, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_getShiGz__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uint8_t arg1 ; + uint8_t arg2 ; + unsigned char val1 ; + int ecode1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + GZ result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getShiGz" "', argument " "1"" of type '" "uint8_t""'"); + } + arg1 = static_cast< uint8_t >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getShiGz" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + result = sxtwl::getShiGz(arg1,arg2); + resultobj = SWIG_NewPointerObj((new GZ(result)), SWIGTYPE_p_GZ, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_getShiGz(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "getShiGz", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_AsVal_unsigned_SS_char(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_getShiGz__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + { + int res = SWIG_AsVal_unsigned_SS_char(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_getShiGz__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'getShiGz'.\n" + " Possible C/C++ prototypes are:\n" + " sxtwl::getShiGz(uint8_t,uint8_t,bool)\n" + " sxtwl::getShiGz(uint8_t,uint8_t)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_getRunMonth(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + uint8_t result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getRunMonth" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + result = (uint8_t)sxtwl::getRunMonth(arg1); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_getLunarMonthNum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + uint8_t arg2 ; + bool arg3 ; + int val1 ; + int ecode1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + uint8_t result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getLunarMonthNum" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getLunarMonthNum" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "getLunarMonthNum" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + result = (uint8_t)sxtwl::getLunarMonthNum(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_getLunarMonthNum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + uint8_t arg2 ; + int val1 ; + int ecode1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + uint8_t result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getLunarMonthNum" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getLunarMonthNum" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + result = (uint8_t)sxtwl::getLunarMonthNum(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_getLunarMonthNum(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "getLunarMonthNum", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_getLunarMonthNum__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_getLunarMonthNum__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'getLunarMonthNum'.\n" + " Possible C/C++ prototypes are:\n" + " sxtwl::getLunarMonthNum(int,uint8_t,bool)\n" + " sxtwl::getLunarMonthNum(int,uint8_t)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_JD2DD(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + double arg1 ; + double val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + Time result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "JD2DD" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + result = sxtwl::JD2DD(arg1); + resultobj = SWIG_NewPointerObj((new Time(result)), SWIGTYPE_p_Time, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_toJD(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + Time *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Time, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "toJD" "', argument " "1"" of type '" "Time &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "toJD" "', argument " "1"" of type '" "Time &""'"); + } + arg1 = reinterpret_cast< Time * >(argp1); + result = (double)sxtwl::toJD(*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_getJieQiByYear(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getJieQiByYear" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + result = sxtwl::getJieQiByYear(arg1); + resultobj = swig::from(static_cast< std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > >(result)); + return resultobj; +fail: + return NULL; +} + + +static PyMethodDef SwigMethods[] = { + { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, NULL}, + { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, NULL}, + { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL}, + { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL}, + { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL}, + { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL}, + { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, NULL}, + { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, NULL}, + { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, NULL}, + { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, NULL}, + { "SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL}, + { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL}, + { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL}, + { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL}, + { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL}, + { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL}, + { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL}, + { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL}, + { "JDList_iterator", _wrap_JDList_iterator, METH_O, NULL}, + { "JDList___nonzero__", _wrap_JDList___nonzero__, METH_O, NULL}, + { "JDList___bool__", _wrap_JDList___bool__, METH_O, NULL}, + { "JDList___len__", _wrap_JDList___len__, METH_O, NULL}, + { "JDList___getslice__", _wrap_JDList___getslice__, METH_VARARGS, NULL}, + { "JDList___setslice__", _wrap_JDList___setslice__, METH_VARARGS, NULL}, + { "JDList___delslice__", _wrap_JDList___delslice__, METH_VARARGS, NULL}, + { "JDList___delitem__", _wrap_JDList___delitem__, METH_VARARGS, NULL}, + { "JDList___getitem__", _wrap_JDList___getitem__, METH_VARARGS, NULL}, + { "JDList___setitem__", _wrap_JDList___setitem__, METH_VARARGS, NULL}, + { "JDList_pop", _wrap_JDList_pop, METH_O, NULL}, + { "JDList_append", _wrap_JDList_append, METH_VARARGS, NULL}, + { "JDList_empty", _wrap_JDList_empty, METH_O, NULL}, + { "JDList_size", _wrap_JDList_size, METH_O, NULL}, + { "JDList_swap", _wrap_JDList_swap, METH_VARARGS, NULL}, + { "JDList_begin", _wrap_JDList_begin, METH_O, NULL}, + { "JDList_end", _wrap_JDList_end, METH_O, NULL}, + { "JDList_rbegin", _wrap_JDList_rbegin, METH_O, NULL}, + { "JDList_rend", _wrap_JDList_rend, METH_O, NULL}, + { "JDList_clear", _wrap_JDList_clear, METH_O, NULL}, + { "JDList_get_allocator", _wrap_JDList_get_allocator, METH_O, NULL}, + { "JDList_pop_back", _wrap_JDList_pop_back, METH_O, NULL}, + { "JDList_erase", _wrap_JDList_erase, METH_VARARGS, NULL}, + { "new_JDList", _wrap_new_JDList, METH_VARARGS, NULL}, + { "JDList_push_back", _wrap_JDList_push_back, METH_VARARGS, NULL}, + { "JDList_front", _wrap_JDList_front, METH_O, NULL}, + { "JDList_back", _wrap_JDList_back, METH_O, NULL}, + { "JDList_assign", _wrap_JDList_assign, METH_VARARGS, NULL}, + { "JDList_resize", _wrap_JDList_resize, METH_VARARGS, NULL}, + { "JDList_insert", _wrap_JDList_insert, METH_VARARGS, NULL}, + { "JDList_reserve", _wrap_JDList_reserve, METH_VARARGS, NULL}, + { "JDList_capacity", _wrap_JDList_capacity, METH_O, NULL}, + { "delete_JDList", _wrap_delete_JDList, METH_O, NULL}, + { "JDList_swigregister", JDList_swigregister, METH_O, NULL}, + { "JDList_swiginit", JDList_swiginit, METH_VARARGS, NULL}, + { "JQList_iterator", _wrap_JQList_iterator, METH_O, NULL}, + { "JQList___nonzero__", _wrap_JQList___nonzero__, METH_O, NULL}, + { "JQList___bool__", _wrap_JQList___bool__, METH_O, NULL}, + { "JQList___len__", _wrap_JQList___len__, METH_O, NULL}, + { "JQList___getslice__", _wrap_JQList___getslice__, METH_VARARGS, NULL}, + { "JQList___setslice__", _wrap_JQList___setslice__, METH_VARARGS, NULL}, + { "JQList___delslice__", _wrap_JQList___delslice__, METH_VARARGS, NULL}, + { "JQList___delitem__", _wrap_JQList___delitem__, METH_VARARGS, NULL}, + { "JQList___getitem__", _wrap_JQList___getitem__, METH_VARARGS, NULL}, + { "JQList___setitem__", _wrap_JQList___setitem__, METH_VARARGS, NULL}, + { "JQList_pop", _wrap_JQList_pop, METH_O, NULL}, + { "JQList_append", _wrap_JQList_append, METH_VARARGS, NULL}, + { "JQList_empty", _wrap_JQList_empty, METH_O, NULL}, + { "JQList_size", _wrap_JQList_size, METH_O, NULL}, + { "JQList_swap", _wrap_JQList_swap, METH_VARARGS, NULL}, + { "JQList_begin", _wrap_JQList_begin, METH_O, NULL}, + { "JQList_end", _wrap_JQList_end, METH_O, NULL}, + { "JQList_rbegin", _wrap_JQList_rbegin, METH_O, NULL}, + { "JQList_rend", _wrap_JQList_rend, METH_O, NULL}, + { "JQList_clear", _wrap_JQList_clear, METH_O, NULL}, + { "JQList_get_allocator", _wrap_JQList_get_allocator, METH_O, NULL}, + { "JQList_pop_back", _wrap_JQList_pop_back, METH_O, NULL}, + { "JQList_erase", _wrap_JQList_erase, METH_VARARGS, NULL}, + { "new_JQList", _wrap_new_JQList, METH_VARARGS, NULL}, + { "JQList_push_back", _wrap_JQList_push_back, METH_VARARGS, NULL}, + { "JQList_front", _wrap_JQList_front, METH_O, NULL}, + { "JQList_back", _wrap_JQList_back, METH_O, NULL}, + { "JQList_assign", _wrap_JQList_assign, METH_VARARGS, NULL}, + { "JQList_resize", _wrap_JQList_resize, METH_VARARGS, NULL}, + { "JQList_insert", _wrap_JQList_insert, METH_VARARGS, NULL}, + { "JQList_reserve", _wrap_JQList_reserve, METH_VARARGS, NULL}, + { "JQList_capacity", _wrap_JQList_capacity, METH_O, NULL}, + { "delete_JQList", _wrap_delete_JQList, METH_O, NULL}, + { "JQList_swigregister", JQList_swigregister, METH_O, NULL}, + { "JQList_swiginit", JQList_swiginit, METH_VARARGS, NULL}, + { "new_Time", _wrap_new_Time, METH_VARARGS, NULL}, + { "Time_Y_set", _wrap_Time_Y_set, METH_VARARGS, NULL}, + { "Time_Y_get", _wrap_Time_Y_get, METH_O, NULL}, + { "Time_M_set", _wrap_Time_M_set, METH_VARARGS, NULL}, + { "Time_M_get", _wrap_Time_M_get, METH_O, NULL}, + { "Time_D_set", _wrap_Time_D_set, METH_VARARGS, NULL}, + { "Time_D_get", _wrap_Time_D_get, METH_O, NULL}, + { "Time_h_set", _wrap_Time_h_set, METH_VARARGS, NULL}, + { "Time_h_get", _wrap_Time_h_get, METH_O, NULL}, + { "Time_m_set", _wrap_Time_m_set, METH_VARARGS, NULL}, + { "Time_m_get", _wrap_Time_m_get, METH_O, NULL}, + { "Time_s_set", _wrap_Time_s_set, METH_VARARGS, NULL}, + { "Time_s_get", _wrap_Time_s_get, METH_O, NULL}, + { "Time_getYear", _wrap_Time_getYear, METH_O, NULL}, + { "Time_setYear", _wrap_Time_setYear, METH_VARARGS, NULL}, + { "Time_setMonth", _wrap_Time_setMonth, METH_VARARGS, NULL}, + { "Time_getMonth", _wrap_Time_getMonth, METH_O, NULL}, + { "Time_getDay", _wrap_Time_getDay, METH_O, NULL}, + { "Time_setDay", _wrap_Time_setDay, METH_VARARGS, NULL}, + { "Time_getHour", _wrap_Time_getHour, METH_O, NULL}, + { "Time_setHour", _wrap_Time_setHour, METH_VARARGS, NULL}, + { "Time_getMin", _wrap_Time_getMin, METH_O, NULL}, + { "Time_setMour", _wrap_Time_setMour, METH_VARARGS, NULL}, + { "Time_getSec", _wrap_Time_getSec, METH_O, NULL}, + { "Time_setSec", _wrap_Time_setSec, METH_VARARGS, NULL}, + { "delete_Time", _wrap_delete_Time, METH_O, NULL}, + { "Time_swigregister", Time_swigregister, METH_O, NULL}, + { "Time_swiginit", Time_swiginit, METH_VARARGS, NULL}, + { "new_GZ", _wrap_new_GZ, METH_VARARGS, NULL}, + { "GZ_tg_set", _wrap_GZ_tg_set, METH_VARARGS, NULL}, + { "GZ_tg_get", _wrap_GZ_tg_get, METH_O, NULL}, + { "GZ_dz_set", _wrap_GZ_dz_set, METH_VARARGS, NULL}, + { "GZ_dz_get", _wrap_GZ_dz_get, METH_O, NULL}, + { "delete_GZ", _wrap_delete_GZ, METH_O, NULL}, + { "GZ_swigregister", GZ_swigregister, METH_O, NULL}, + { "GZ_swiginit", GZ_swiginit, METH_VARARGS, NULL}, + { "Day_fromSolar", _wrap_Day_fromSolar, METH_VARARGS, NULL}, + { "Day_fromLunar", _wrap_Day_fromLunar, METH_VARARGS, NULL}, + { "Day_after", _wrap_Day_after, METH_VARARGS, NULL}, + { "Day_before", _wrap_Day_before, METH_VARARGS, NULL}, + { "Day_getLunarDay", _wrap_Day_getLunarDay, METH_O, NULL}, + { "Day_getLunarMonth", _wrap_Day_getLunarMonth, METH_O, NULL}, + { "Day_getLunarYear", _wrap_Day_getLunarYear, METH_VARARGS, NULL}, + { "Day_getYearGZ", _wrap_Day_getYearGZ, METH_VARARGS, NULL}, + { "Day_getMonthGZ", _wrap_Day_getMonthGZ, METH_O, NULL}, + { "Day_getDayGZ", _wrap_Day_getDayGZ, METH_O, NULL}, + { "Day_getHourGZ", _wrap_Day_getHourGZ, METH_VARARGS, NULL}, + { "Day_isLunarLeap", _wrap_Day_isLunarLeap, METH_O, NULL}, + { "Day_getSolarYear", _wrap_Day_getSolarYear, METH_O, NULL}, + { "Day_getSolarMonth", _wrap_Day_getSolarMonth, METH_O, NULL}, + { "Day_getSolarDay", _wrap_Day_getSolarDay, METH_O, NULL}, + { "Day_getWeek", _wrap_Day_getWeek, METH_O, NULL}, + { "Day_getWeekIndex", _wrap_Day_getWeekIndex, METH_O, NULL}, + { "Day_hasJieQi", _wrap_Day_hasJieQi, METH_O, NULL}, + { "Day_getJieQi", _wrap_Day_getJieQi, METH_O, NULL}, + { "Day_getJieQiJD", _wrap_Day_getJieQiJD, METH_O, NULL}, + { "Day_getConstellation", _wrap_Day_getConstellation, METH_O, NULL}, + { "delete_Day", _wrap_delete_Day, METH_O, NULL}, + { "Day_swigregister", Day_swigregister, METH_O, NULL}, + { "JieQiInfo_jd_set", _wrap_JieQiInfo_jd_set, METH_VARARGS, NULL}, + { "JieQiInfo_jd_get", _wrap_JieQiInfo_jd_get, METH_O, NULL}, + { "JieQiInfo_jqIndex_set", _wrap_JieQiInfo_jqIndex_set, METH_VARARGS, NULL}, + { "JieQiInfo_jqIndex_get", _wrap_JieQiInfo_jqIndex_get, METH_O, NULL}, + { "new_JieQiInfo", _wrap_new_JieQiInfo, METH_NOARGS, NULL}, + { "delete_JieQiInfo", _wrap_delete_JieQiInfo, METH_O, NULL}, + { "JieQiInfo_swigregister", JieQiInfo_swigregister, METH_O, NULL}, + { "JieQiInfo_swiginit", JieQiInfo_swiginit, METH_VARARGS, NULL}, + { "fromSolar", _wrap_fromSolar, METH_VARARGS, NULL}, + { "fromLunar", _wrap_fromLunar, METH_VARARGS, NULL}, + { "siZhu2Year", _wrap_siZhu2Year, METH_VARARGS, NULL}, + { "getShiGz", _wrap_getShiGz, METH_VARARGS, NULL}, + { "getRunMonth", _wrap_getRunMonth, METH_O, NULL}, + { "getLunarMonthNum", _wrap_getLunarMonthNum, METH_VARARGS, NULL}, + { "JD2DD", _wrap_JD2DD, METH_O, NULL}, + { "toJD", _wrap_toJD, METH_O, NULL}, + { "getJieQiByYear", _wrap_getJieQiByYear, METH_O, NULL}, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static swig_type_info _swigt__p_Day = {"_p_Day", "Day *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_GZ = {"_p_GZ", "GZ *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_Time = {"_p_Time", "Time *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 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_difference_type = {"_p_difference_type", "difference_type *", 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_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_PyObject = {"_p_p_PyObject", "PyObject **", 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_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__allocatorT_double_t = {"_p_std__allocatorT_double_t", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__allocatorT_sxtwl__JieQiInfo_t = {"_p_std__allocatorT_sxtwl__JieQiInfo_t", "std::vector< sxtwl::JieQiInfo >::allocator_type *|std::allocator< sxtwl::JieQiInfo > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t = {"_p_std__vectorT_double_std__allocatorT_double_t_t", "std::vector< double,std::allocator< double > > *|std::vector< double > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t = {"_p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t", "std::vector< sxtwl::JieQiInfo,std::allocator< sxtwl::JieQiInfo > > *|std::vector< sxtwl::JieQiInfo > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_sxtwl__JieQiInfo = {"_p_sxtwl__JieQiInfo", "std::vector< sxtwl::JieQiInfo >::value_type *|sxtwl::JieQiInfo *", 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 _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_Day, + &_swigt__p_GZ, + &_swigt__p_Time, + &_swigt__p_allocator_type, + &_swigt__p_char, + &_swigt__p_difference_type, + &_swigt__p_int, + &_swigt__p_long_long, + &_swigt__p_p_PyObject, + &_swigt__p_short, + &_swigt__p_signed_char, + &_swigt__p_size_type, + &_swigt__p_std__allocatorT_double_t, + &_swigt__p_std__allocatorT_sxtwl__JieQiInfo_t, + &_swigt__p_std__invalid_argument, + &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, + &_swigt__p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, + &_swigt__p_swig__SwigPyIterator, + &_swigt__p_sxtwl__JieQiInfo, + &_swigt__p_unsigned_char, + &_swigt__p_unsigned_int, + &_swigt__p_unsigned_long_long, + &_swigt__p_unsigned_short, + &_swigt__p_value_type, +}; + +static swig_cast_info _swigc__p_Day[] = { {&_swigt__p_Day, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_GZ[] = { {&_swigt__p_GZ, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_Time[] = { {&_swigt__p_Time, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 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_difference_type[] = { {&_swigt__p_difference_type, 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_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 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_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__allocatorT_double_t[] = { {&_swigt__p_std__allocatorT_double_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__allocatorT_sxtwl__JieQiInfo_t[] = { {&_swigt__p_std__allocatorT_sxtwl__JieQiInfo_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t[] = { {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t[] = { {&_swigt__p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_swig__SwigPyIterator[] = { {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sxtwl__JieQiInfo[] = { {&_swigt__p_sxtwl__JieQiInfo, 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 _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_Day, + _swigc__p_GZ, + _swigc__p_Time, + _swigc__p_allocator_type, + _swigc__p_char, + _swigc__p_difference_type, + _swigc__p_int, + _swigc__p_long_long, + _swigc__p_p_PyObject, + _swigc__p_short, + _swigc__p_signed_char, + _swigc__p_size_type, + _swigc__p_std__allocatorT_double_t, + _swigc__p_std__allocatorT_sxtwl__JieQiInfo_t, + _swigc__p_std__invalid_argument, + _swigc__p_std__vectorT_double_std__allocatorT_double_t_t, + _swigc__p_std__vectorT_sxtwl__JieQiInfo_std__allocatorT_sxtwl__JieQiInfo_t_t, + _swigc__p_swig__SwigPyIterator, + _swigc__p_sxtwl__JieQiInfo, + _swigc__p_unsigned_char, + _swigc__p_unsigned_int, + _swigc__p_unsigned_long_long, + _swigc__p_unsigned_short, + _swigc__p_value_type, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +static swig_const_info swig_const_table[] = { +{0, 0, 0, 0.0, 0, 0}}; + +#ifdef __cplusplus +} +#endif +/* ----------------------------------------------------------------------------- + * 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); + + + // thread safe initialization + swig::container_owner_attribute(); + + SWIG_Python_SetConstant(d, "J2000",SWIG_From_int(static_cast< int >(2451545))); +#if PY_VERSION_HEX >= 0x03000000 + return m; +#else + return; +#endif +} + diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 0000000..29b539f --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,34 @@ +cmake_minimum_required(VERSION 3.6) +project(sxtwl) + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_C_STANDARD 11) + +file(GLOB SRC_FILES "*.cpp" ) + +if(UNIX) + add_compile_options(-fPIC) +elseif(MSVC) + ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS) +endif() + +add_library(sxtwl STATIC ${SRC_FILES}) + +# 安装库文件 +install(TARGETS sxtwl + RUNTIME DESTINATION bin + LIBRARY DESTINATION lib + ARCHIVE DESTINATION lib +) + +# 安装头文件 +install(FILES + ${CMAKE_CURRENT_SOURCE_DIR}/const.h + ${CMAKE_CURRENT_SOURCE_DIR}/day.h + ${CMAKE_CURRENT_SOURCE_DIR}/eph.h + ${CMAKE_CURRENT_SOURCE_DIR}/JD.h + ${CMAKE_CURRENT_SOURCE_DIR}/SSQ.h + ${CMAKE_CURRENT_SOURCE_DIR}/sxtwl.h + ${CMAKE_CURRENT_SOURCE_DIR}/XL.h + DESTINATION include +) diff --git a/src/JD.cpp b/src/JD.cpp new file mode 100644 index 0000000..f7f9810 --- /dev/null +++ b/src/JD.cpp @@ -0,0 +1,89 @@ +#include "JD.h" +#include "const.h" +#include +#include + + +//https://github.com/guolisen/YiEngine/blob/2ce67dc91fd5fea8e394a5af60dc1e56c5044452/src/DateTime/JulianDay.cpp +//公历转儒略日 +double JD::DD2JD(int y, uint8_t m, double d) +{ + int n = 0, G = 0; + //判断是否为格里高利历日1582*372+10*31+15 + if (y * 372 + m * 31 + (int)(d) >= 588829) + { + G = 1; + } + if (m <= 2) + { + m += 12, y--; + } + //加百年闰 + if (G) + { + n = int2(y / 100), n = 2 - n + int(n / 4); + } + + return int2(365.25*(y + 4716)) + int2(30.6001*(m + 1)) + d + n - 1524.5; + +} + +//儒略日数转公历 +Time JD::JD2DD(double jd) +{ + Time r; + int D = int2(jd + 0.5); + float F = jd + 0.5 - D, c; //取得日数的整数部份A及小数部分F + if (D >= 2299161) + { + c = int((D - 1867216.25) / 36524.25), D += 1 + c - int2(c / 4); + } + D += 1524; r.Y = int2((D - 122.1) / 365.25);//年数 + D -= int2(365.25*r.Y); r.M = int2(D / 30.601); //月数 + D -= int2(30.601*r.M); r.D = D; //日数 + if (r.M > 13) + { + r.M -= 13, r.Y -= 4715; + } + else + { + r.M -= 1, r.Y -= 4716; + } + //日的小数转为时分秒 + F *= 24; r.h = int2(F); F -= r.h; + F *= 60; r.m = int2(F); F -= r.m; + F *= 60; r.s = F; + return r; +} + +double JD::toJD(Time& time) +{ + return JD::DD2JD(time.Y, time.M, time.D + ((time.s / 60 + time.m) / 60 + time.h) / 24); +} + +//提取jd中的时间(去除日期); +std::string JD::timeStr(double jd) +{ + int h, m, s; + jd += 0.5; jd = (jd - int2(jd)); + s = int2(jd * 86400 + 0.5); + h = int2(s / 3600); s -= h * 3600; + m = int2(s / 60); s -= m * 60; + std::string ret = ""; + char buff[11]; + memset(buff, 0, 11); + std::snprintf(buff, sizeof(buff), "0%d", h); + ret.append(buff + strlen(buff) - 2); + ret += ":"; + + memset(buff, 0, 11); + std::snprintf(buff, sizeof(buff), "0%d", m); + ret.append(buff + strlen(buff) - 2); + ret += ":"; + + memset(buff, 0, 11); + std::snprintf(buff, sizeof(buff), "0%d", s); + ret.append(buff + strlen(buff) - 2); + + return ret; +} diff --git a/src/JD.h b/src/JD.h new file mode 100644 index 0000000..c8e349a --- /dev/null +++ b/src/JD.h @@ -0,0 +1,84 @@ +#pragma once +#include +#include +#include +#include + +struct Time +{ + int Y, M, D; + double h, m, s; + Time(){}; + Time(int year, int month, int day, double hour, double min, double sec){ + this->Y = year; this->M = month; this->D = day; + this->h = hour; this->m = min; this->s = sec; + } + + int getYear() { + return Y; + } + + void setYear(int year) { + Y = year; + } + + void setMonth(int month) { + M = month; + } + + int getMonth() { + return M; + } + + int getDay() { + return D; + } + + void setDay(int day) { + D = day; + } + + double getHour() { + return h; + } + + void setHour(double hour) { + h = hour; + } + + double getMin() { + return m; + } + + void setMour(double min) { + m = min; + } + + + double getSec() { + return s; + } + + void setSec(double sec) { + s = sec; + } + + std::string toStr() { + std::stringstream ss; + ss << getYear() << "-" << getMonth() << "-" << getDay() << ' ' + << getHour() << ":" << getMin() << ":" << (int)getSec(); + return ss.str(); + } +}; + + +class JD +{ +public : + //公历转儒略日 + static double DD2JD(int y, uint8_t m, double d); + static Time JD2DD(double jd); + + static double toJD(Time& time); + static std::string timeStr( double jd); +}; diff --git a/src/SSQ.cpp b/src/SSQ.cpp new file mode 100644 index 0000000..709ae9c --- /dev/null +++ b/src/SSQ.cpp @@ -0,0 +1,374 @@ +#include "SSQ.h" +#include +#include "const.h" +#include "eph.h" + +SSQ::SSQ() +{ + + std::string suoS = "", qiS = ""; + // 619-01-21开始16598个朔日修正表 d0=1947168 + suoS = "EqoFscDcrFpmEsF2DfFideFelFpFfFfFiaipqti1ksttikptikqckstekqttgkqttgkqteksttikptikq2fjstgjqttjkqttgkqt"; + suoS += "ekstfkptikq2tijstgjiFkirFsAeACoFsiDaDiADc1AFbBfgdfikijFifegF1FhaikgFag1E2btaieeibggiffdeigFfqDfaiBkF"; + suoS += "1kEaikhkigeidhhdiegcFfakF1ggkidbiaedksaFffckekidhhdhdikcikiakicjF1deedFhFccgicdekgiFbiaikcfi1kbFibef"; + suoS += "gEgFdcFkFeFkdcfkF1kfkcickEiFkDacFiEfbiaejcFfffkhkdgkaiei1ehigikhdFikfckF1dhhdikcfgjikhfjicjicgiehdik"; + suoS += "cikggcifgiejF1jkieFhegikggcikFegiegkfjebhigikggcikdgkaFkijcfkcikfkcifikiggkaeeigefkcdfcfkhkdgkegieid"; + suoS += "hijcFfakhfgeidieidiegikhfkfckfcjbdehdikggikgkfkicjicjF1dbidikFiggcifgiejkiegkigcdiegfggcikdbgfgefjF1"; + suoS += "kfegikggcikdgFkeeijcfkcikfkekcikdgkabhkFikaffcfkhkdgkegbiaekfkiakicjhfgqdq2fkiakgkfkhfkfcjiekgFebicg"; + suoS += "gbedF1jikejbbbiakgbgkacgiejkijjgigfiakggfggcibFifjefjF1kfekdgjcibFeFkijcfkfhkfkeaieigekgbhkfikidfcje"; + suoS += "aibgekgdkiffiffkiakF1jhbakgdki1dj1ikfkicjicjieeFkgdkicggkighdF1jfgkgfgbdkicggfggkidFkiekgijkeigfiski"; + suoS += "ggfaidheigF1jekijcikickiggkidhhdbgcfkFikikhkigeidieFikggikhkffaffijhidhhakgdkhkijF1kiakF1kfheakgdkif"; + suoS += "iggkigicjiejkieedikgdfcggkigieeiejfgkgkigbgikicggkiaideeijkefjeijikhkiggkiaidheigcikaikffikijgkiahi1"; + suoS += "hhdikgjfifaakekighie1hiaikggikhkffakicjhiahaikggikhkijF1kfejfeFhidikggiffiggkigicjiekgieeigikggiffig"; + suoS += "gkidheigkgfjkeigiegikifiggkidhedeijcfkFikikhkiggkidhh1ehigcikaffkhkiggkidhh1hhigikekfiFkFikcidhh1hit"; + suoS += "cikggikhkfkicjicghiediaikggikhkijbjfejfeFhaikggifikiggkigiejkikgkgieeigikggiffiggkigieeigekijcijikgg"; + suoS += "ifikiggkideedeijkefkfckikhkiggkidhh1ehijcikaffkhkiggkidhh1hhigikhkikFikfckcidhh1hiaikgjikhfjicjicgie"; + suoS += "hdikcikggifikigiejfejkieFhegikggifikiggfghigkfjeijkhigikggifikiggkigieeijcijcikfksikifikiggkidehdeij"; + suoS += "cfdckikhkiggkhghh1ehijikifffffkhsFngErD1pAfBoDd1BlEtFqA2AqoEpDqElAEsEeB2BmADlDkqBtC1FnEpDqnEmFsFsAFn"; + suoS += "llBbFmDsDiCtDmAB2BmtCgpEplCpAEiBiEoFqFtEqsDcCnFtADnFlEgdkEgmEtEsCtDmADqFtAFrAtEcCqAE1BoFqC1F1DrFtBmF"; + suoS += "tAC2ACnFaoCgADcADcCcFfoFtDlAFgmFqBq2bpEoAEmkqnEeCtAE1bAEqgDfFfCrgEcBrACfAAABqAAB1AAClEnFeCtCgAADqDoB"; + suoS += "mtAAACbFiAAADsEtBqAB2FsDqpFqEmFsCeDtFlCeDtoEpClEqAAFrAFoCgFmFsFqEnAEcCqFeCtFtEnAEeFtAAEkFnErAABbFkAD"; + suoS += "nAAeCtFeAfBoAEpFtAABtFqAApDcCGJ"; + + //1645-09-23开始7567个节气修正表 + qiS = "FrcFs22AFsckF2tsDtFqEtF1posFdFgiFseFtmelpsEfhkF2anmelpFlF1ikrotcnEqEq2FfqmcDsrFor22FgFrcgDscFs22FgEe"; + qiS += "FtE2sfFs22sCoEsaF2tsD1FpeE2eFsssEciFsFnmelpFcFhkF2tcnEqEpFgkrotcnEqrEtFermcDsrE222FgBmcmr22DaEfnaF22"; + qiS += "2sD1FpeForeF2tssEfiFpEoeFssD1iFstEqFppDgFstcnEqEpFg11FscnEqrAoAF2ClAEsDmDtCtBaDlAFbAEpAAAAAD2FgBiBqo"; + qiS += "BbnBaBoAAAAAAAEgDqAdBqAFrBaBoACdAAf1AACgAAAeBbCamDgEifAE2AABa1C1BgFdiAAACoCeE1ADiEifDaAEqAAFe1AcFbcA"; + qiS += "AAAAF1iFaAAACpACmFmAAAAAAAACrDaAAADG0"; + + + + SB = jieya(suoS); //定朔修正表解压 + QB = jieya(qiS); //定气修正表解压 + + + //朔直线拟合参数 + long double suoKBTmp[] = { + 1457698.231017,29.53067166, // -721-12-17 h=0.00032 古历·春秋 + 1546082.512234,29.53085106, // -479-12-11 h=0.00053 古历·战国 + 1640640.735300,29.53060000, // -221-10-31 h=0.01010 古历·秦汉 + 1642472.151543,29.53085439, // -216-11-04 h=0.00040 古历·秦汉 + + 1683430.509300,29.53086148, // -104-12-25 h=0.00313 汉书·律历志(太初历)平气平朔 + 1752148.041079,29.53085097, // 85-02-13 h=0.00049 后汉书·律历志(四分历) + 1807665.420323,29.53059851, // 237-02-12 h=0.00033 晋书·律历志(景初历) + 1883618.114100,29.53060000, // 445-01-24 h=0.00030 宋书·律历志(何承天元嘉历) + 1907360.704700,29.53060000, // 510-01-26 h=0.00030 宋书·律历志(祖冲之大明历) + 1936596.224900,29.53060000, // 590-02-10 h=0.01010 随书·律历志(开皇历) + 1939135.675300,29.53060000, // 597-01-24 h=0.00890 随书·律历志(大业历) + 1947168.00// 619-01-21 + }; + + suoKB = new std::vector(suoKBTmp, suoKBTmp + sizeof(suoKBTmp) / sizeof(long double)); + + long double qiKBTmp[] = { + 1640650.479938,15.21842500, // -221-11-09 h=0.01709 古历·秦汉 + 1642476.703182,15.21874996, // -216-11-09 h=0.01557 古历·秦汉 + + 1683430.515601,15.218750011, // -104-12-25 h=0.01560 汉书·律历志(太初历)平气平朔 回归年=365.25000 + 1752157.640664,15.218749978, // 85-02-23 h=0.01559 后汉书·律历志(四分历) 回归年=365.25000 + 1807675.003759,15.218620279, // 237-02-22 h=0.00010 晋书·律历志(景初历) 回归年=365.24689 + 1883627.765182,15.218612292, // 445-02-03 h=0.00026 宋书·律历志(何承天元嘉历) 回归年=365.24670 + 1907369.128100,15.218449176, // 510-02-03 h=0.00027 宋书·律历志(祖冲之大明历) 回归年=365.24278 + 1936603.140413,15.218425000, // 590-02-17 h=0.00149 随书·律历志(开皇历) 回归年=365.24220 + 1939145.524180,15.218466998, // 597-02-03 h=0.00121 随书·律历志(大业历) 回归年=365.24321 + 1947180.798300,15.218524844, // 619-02-03 h=0.00052 新唐书·历志(戊寅元历)平气定朔 回归年=365.24460 + 1964362.041824,15.218533526, // 666-02-17 h=0.00059 新唐书·历志(麟德历) 回归年=365.24480 + 1987372.340971,15.218513908, // 729-02-16 h=0.00096 新唐书·历志(大衍历,至德历) 回归年=365.24433 + 1999653.819126,15.218530782, // 762-10-03 h=0.00093 新唐书·历志(五纪历) 回归年=365.24474 + 2007445.469786,15.218535181, // 784-02-01 h=0.00059 新唐书·历志(正元历,观象历) 回归年=365.24484 + 2021324.917146,15.218526248, // 822-02-01 h=0.00022 新唐书·历志(宣明历) 回归年=365.24463 + 2047257.232342,15.218519654, // 893-01-31 h=0.00015 新唐书·历志(崇玄历) 回归年=365.24447 + 2070282.898213,15.218425000, // 956-02-16 h=0.00149 旧五代·历志(钦天历) 回归年=365.24220 + 2073204.872850,15.218515221, // 964-02-16 h=0.00166 宋史·律历志(应天历) 回归年=365.24437 + 2080144.500926,15.218530782, // 983-02-16 h=0.00093 宋史·律历志(乾元历) 回归年=365.24474 + 2086703.688963,15.218523776, // 1001-01-31 h=0.00067 宋史·律历志(仪天历,崇天历) 回归年=365.24457 + 2110033.182763,15.218425000, // 1064-12-15 h=0.00669 宋史·律历志(明天历) 回归年=365.24220 + 2111190.300888,15.218425000, // 1068-02-15 h=0.00149 宋史·律历志(崇天历) 回归年=365.24220 + 2113731.271005,15.218515671, // 1075-01-30 h=0.00038 李锐补修(奉元历) 回归年=365.24438 + 2120670.840263,15.218425000, // 1094-01-30 h=0.00149 宋史·律历志 回归年=365.24220 + 2123973.309063,15.218425000, // 1103-02-14 h=0.00669 李锐补修(占天历) 回归年=365.24220 + 2125068.997336,15.218477932, // 1106-02-14 h=0.00056 宋史·律历志(纪元历) 回归年=365.24347 + 2136026.312633,15.218472436, // 1136-02-14 h=0.00088 宋史·律历志(统元历,乾道历,淳熙历) 回归年=365.24334 + 2156099.495538,15.218425000, // 1191-01-29 h=0.00149 宋史·律历志(会元历) 回归年=365.24220 + 2159021.324663,15.218425000, // 1199-01-29 h=0.00149 宋史·律历志(统天历) 回归年=365.24220 + 2162308.575254,15.218461742, // 1208-01-30 h=0.00146 宋史·律历志(开禧历) 回归年=365.24308 + 2178485.706538,15.218425000, // 1252-05-15 h=0.04606 淳祐历 回归年=365.24220 + 2178759.662849,15.218445786, // 1253-02-13 h=0.00231 会天历 回归年=365.24270 + 2185334.020800,15.218425000, // 1271-02-13 h=0.00520 宋史·律历志(成天历) 回归年=365.24220 + 2187525.481425,15.218425000, // 1277-02-12 h=0.00520 本天历 回归年=365.24220 + 2188621.191481,15.218437494, // 1280-02-13 h=0.00015 元史·历志(郭守敬授时历) 回归年=365.24250 + 2322147.76// 1645-09-21 + }; + + qiKB = new std::vector(qiKBTmp, qiKBTmp + sizeof(qiKBTmp) / sizeof(long double)); +} + +SSQ::~SSQ() +{ + delete suoKB; + delete qiKB; +} + +void str_replace(std::string & str, const std::string strsrc, const std::string strdst) +{ + std::string::size_type pos = 0;//位置 + std::string::size_type srclen = strsrc.size();//要替换的字符串大小 + std::string::size_type dstlen = strdst.size();//目标字符串大小 + while ((pos = str.find(strsrc, pos)) != std::string::npos) + { + str.replace(pos, srclen, strdst); + pos += dstlen; + } +} + + +std::string SSQ::jieya(std::string s) { //气朔解压缩 + std::string o = "0000000000", o2 = o + o; + str_replace(s, "J", "00"); + str_replace(s, "I", "000"); + str_replace(s, "H", "0000"); + str_replace(s, "G", "00000"); + str_replace(s, "t", "02"); + str_replace(s, "s", "002"); + str_replace(s, "r", "0002"); + str_replace(s, "q", "00002"); + str_replace(s, "p", "000002"); + str_replace(s, "o", "0000002"); + str_replace(s, "n", "00000002"); + str_replace(s, "m", "000000002"); + str_replace(s, "l", "0000000002"); + str_replace(s, "k", "01"); + str_replace(s, "j", "0101"); + str_replace(s, "i", "001"); + str_replace(s, "h", "001001"); + str_replace(s, "g", "0001"); + str_replace(s, "f", "00001"); + str_replace(s, "e", "000001"); + str_replace(s, "d", "0000001"); + str_replace(s, "c", "00000001"); + str_replace(s, "b", "000000001"); + str_replace(s, "a", "0000000001"); + str_replace(s, "A", o2 + o2 + o2); + str_replace(s, "B", o2 + o2 + o); + str_replace(s, "C", o2 + o2); + str_replace(s, "D", o2 + o); + str_replace(s, "E", o2); + str_replace(s, "F", o); + return s; +} + +int SSQ::calc(long double jd, QSType qs) +{ + jd += 2451545; + int i; + long double D; + std::string n; + std::vector B = *suoKB; + long double pc = 14; + //如果查的是气朔 + if (qs == QType) + { + B = *qiKB, pc = 7; + } + + long double f1 = B[0] - pc, f2 = B[B.size() - 1] - pc, f3 = 2436935; + + if (jd < f1 || jd >= f3) + { + //平气朔表中首个之前，使用现代天文算法。1960.1.1以后，使用现代天文算法 (这一部分调用了qi_high和so_high,所以需星历表支持) + if (qs == QType) + { + return floor(qi_high(floor((jd + pc - 2451259) / 365.2422 * 24) * PI / 12) + 0.5); //2451259是1999.3.21,太阳视黄经为0,春分.定气计算 + } + else + { + return floor(so_high(floor((jd + pc - 2451551) / 29.5306) * PI * 2) + 0.5); //2451551是2000.1.7的那个朔日,黄经差为0.定朔计算 + } + } + + if (jd >= f1 && jd < f2) { //平气或平朔 + for (i = 0; i < B.size(); i += 2) if (jd + pc < B[i + 2]) break; + D = B[i] + B[i + 1] * floor((jd + pc - B[i]) / B[i + 1]); + D = floor(D + 0.5); + if (D == 1683460) D++; //如果使用太初历计算-103年1月24日的朔日,结果得到的是23日,这里修正为24日(实历)。修正后仍不影响-103的无中置闰。如果使用秦汉历，得到的是24日，本行D不会被执行。 + return D - 2451545; + } + + if (jd >= f2 && jd < f3) { //定气或定朔 + if (qs == QType) { + D = floor(qi_low(floor((jd + pc - 2451259) / 365.2422 * 24) * PI / 12) + 0.5); //2451259是1999.3.21,太阳视黄经为0,春分.定气计算 + n = QB.substr(floor((jd - f2) / 365.2422 * 24), 1); //找定气修正值 + } + else { + D = floor(so_low(floor((jd + pc - 2451551) / 29.5306) * PI * 2) + 0.5); //2451551是2000.1.7的那个朔日,黄经差为0.定朔计算 + n = SB.substr(floor((jd - f2) / 29.5306), 1); //找定朔修正值 + } + if (n == "1") return D + 1; + if (n == "2") return D - 1; + return D; + } + return 0; +} + + +long double SSQ::qi_high(long double W) +{ + long double t = XL::S_aLon_t2(W) * 36525; + t = t - dt_T(t) + 8.0 / 24.0; + long double v = fmod(t + 0.5, 1) * 86400; + if (v < 1200 || v >86400 - 1200) t = XL::S_aLon_t(W) * 36525 - dt_T(t) + 8.0 / 24.0; + return t; +} + + +long double SSQ::so_high(long double W) +{ //较高精度朔 + long double t = XL::MS_aLon_t2(W) * 36525; + t = t - dt_T(t) + 8.0 / 24.0; + long double v = fmod(t + 0.5, 1) * 86400; + if (v < 1800 || v >86400 - 1800) t = XL::MS_aLon_t(W) * 36525 - dt_T(t) + 8.0 / 24.0; + return t; +} + +long double SSQ::so_low(long double W) { //低精度定朔计算,在2000年至600，误差在2小时以内(仍比古代日历精准很多) + long double v = 7771.37714500204; + long double t = (W + 1.08472) / v, L; + t -= (-0.0000331*t*t + + 0.10976 *cos(0.785 + 8328.6914*t) + + 0.02224 *cos(0.187 + 7214.0629*t) + - 0.03342 *cos(4.669 + 628.3076*t)) / v + + (32 * (t + 1.8)*(t + 1.8) - 20) / 86400 / 36525; + return t * 36525 + 8.0 / 24.0; +} + +long double SSQ::qi_low(long double W) { //最大误差小于30分钟，平均5分 + long double t, L, v = 628.3319653318; + t = (W - 4.895062166) / v; //第一次估算,误差2天以内 + t -= (53 * t*t + 334116 * cos(4.67 + 628.307585*t) + 2061 * cos(2.678 + 628.3076*t)*t) / v / 10000000; //第二次估算,误差2小时以内 + + L = 48950621.66 + 6283319653.318*t + 53 * t*t //平黄经 + + 334166 * cos(4.669257 + 628.307585*t) //地球椭圆轨道级数展开 + + 3489 * cos(4.6261 + 1256.61517*t) //地球椭圆轨道级数展开 + + 2060.6 * cos(2.67823 + 628.307585*t) * t //一次泊松项 + - 994 - 834 * sin(2.1824 - 33.75705*t); //光行差与章动修正 + + t -= (L / 10000000 - W) / 628.332 + (32 * (t + 1.8)*(t + 1.8) - 20) / 86400 / 36525; + return t * 36525 + 8.0 / 24.0; +} + + +//农历排月序计算,可定出农历,有效范围：两个冬至之间(冬至一 <= d < 冬至二) +void SSQ::calcY(int jd) { + std::vector& A = ZQ; + std::vector& B = HS; //中气表,日月合朔表(整日) + int i, k; + long double W, w; + + //该年的气 + + W = int2((jd - 355 + 183) / 365.2422)*365.2422 + 355; //355是2000.12冬至,得到较靠近jd的冬至估计值 + if (calc(W, QType) > jd) + { + W -= 365.2422; + } + + //25个节气时刻(北京时间),从冬至开始到下一个冬至以后; + A.clear(); + for (i = 0; i < 25; i++) + { + int t = calc(W + 15.2184*i, QType); + A.push_back(t); + } + + ZQ_pe1 = calc(W - 15.2, QType); ZQ_pe2 = calc(W - 30.4, QType); //补算二气,确保一年中所有月份的“气”全部被计算在内 + //今年"首朔"的日月黄经差w + w = calc(A[0], SType); //求较靠近冬至的朔日 + if (w > A[0]) + { + w -= 29.53; + } + + //该年所有朔,包含14个月的始末 + B.clear(); + for (i = 0; i < 15; i++) + { + B.push_back( calc(w + 29.5306*i, SType) ); + } + + + //月大小 + leap = 0; + dx.clear(); + ym.clear(); + for (i = 0; i < 14; i++) { + dx.push_back( HS[i + 1] - HS[i] ); //月大小 + ym.push_back(i); //月序初始化 + } + + + //-721年至-104年的后九月及月建问题,与朔有关，与气无关 + int YY = int2((ZQ[0] + 10 + 180) / 365.2422) + 2000; //确定年份 + if (YY >= -721 && YY <= -104) { + int ns[12]; + int yy; + for (i = 0; i < 3; i++) { + yy = YY + i - 1; + //颁行历年首, 闰月名称, 月建 + if (yy >= -721) + { + ns[i] = calc(1457698 - J2000 + int2(0.342 + (yy + 721)*12.368422)*29.5306, SType); + //ns[i + 3] = '十三'; + ns[i + 6] = 2; //春秋历,ly为-722.12.17 + } + + if (yy >= -479) + { + + ns[i] = calc(1546083 - J2000 + int2(0.500 + (yy + 479)*12.368422)*29.5306, SType); + //ns[i + 3] = '十三'; + ns[i + 6] = 2; //战国历,ly为-480.12.11 + } + if (yy >= -220) { + ns[i] = calc(1640641 - J2000 + int2(0.866 + (yy + 220)*12.369000)*29.5306, SType); + // ns[i + 3] = '后九'; + ns[i + 6] = 11; //秦汉历,ly为-221.10.31 + } + } + + int nn, f1; + for (i = 0; i < 14; i++) { + for (nn = 2; nn >= 0; nn--) if (HS[i] >= ns[nn]) break; + f1 = int2((HS[i] - ns[nn] + 15) / 29.5306); //该月积数 + if (f1 < 12) ym[i] = (f1 + ns[nn + 6]) % 12; else ym[i] = ns[nn + 3]; + } + return; + } + + + //无中气置闰法确定闰月,(气朔结合法,数据源需有冬至开始的的气和朔) + if (B[13] <= A[24]) { //第13月的月末没有超过冬至(不含冬至),说明今年含有13个月 + for (i = 1; B[i + 1] > A[2 * i] && i < 13; i++); //在13个月中找第1个没有中气的月份 + leap = i; + for (; i < 14; i++) ym[i]--; + } + + //名称转换(月建别名) + for (i = 0; i < 14; i++) { + int Dm = HS[i] + J2000, v2 = ym[i]; //Dm初一的儒略日,v2为月建序号 + int mc = v2 % 12; //月建对应的默认月名称：建子十一,建丑十二,建寅为正…… + if (Dm >= 1724360 && Dm <= 1729794) mc = (v2 + 1) % 12; // 8.01.15至 23.12.02 建子为十二,其它顺推 + else if (Dm >= 1807724 && Dm <= 1808699) mc = (v2 + 1) % 12; //237.04.12至239.12.13 建子为十二,其它顺推 + else if (Dm >= 1999349 && Dm <= 1999467) mc = (v2 + 2) % 12; //761.12.02至762.03.30 建子为正月,其它顺推 + else if (Dm >= 1973067 && Dm <= 1977052) { if (v2 % 12 == 0) mc = 2; if (v2 == 2) mc = 2; } //689.12.18至700.11.15 建子为正月,建寅为一月,其它不变 + + if (Dm == 1729794 || Dm == 1808699) + { + mc = 12; + // mc = '拾贰'; //239.12.13及23.12.02均为十二月,为避免两个连续十二月，此处改名 + } + ym[i] = mc; + } +} + diff --git a/src/SSQ.h b/src/SSQ.h new file mode 100644 index 0000000..ed95877 --- /dev/null +++ b/src/SSQ.h @@ -0,0 +1,38 @@ +#pragma once +#include +#include +typedef enum +{ + QType, //气 + SType //朔 +} QSType; + +class SSQ +{ +public: + SSQ(); + ~SSQ(); + int calc(long double jd, QSType type); + //较高精度气; + long double qi_high(long double); + //较高精度朔 + long double so_high(long double); + long double so_low(long double W); + long double qi_low(long double W); + + void calcY(int jd); + + std::string jieya(std::string s); + + std::vector* suoKB; + std::vector* qiKB; + + + std::vector ZQ; + long double ZQ_pe1, ZQ_pe2; + std::vector HS; + std::vector ym; + std::vector dx; + int leap; + std::string SB, QB; +}; diff --git a/src/XL.cpp b/src/XL.cpp new file mode 100644 index 0000000..fefef31 --- /dev/null +++ b/src/XL.cpp @@ -0,0 +1,75 @@ +//#include "XL.h" +//#include "const.h" +//#include +// +//long double XL::S_aLon_t(long double W) +//{ +// long double t, v = 628.3319653318; +// t = (W - 1.75347 - PI) / v; v = E_v(t); //v的精度0.03%，详见原文 +// t += (W - S_aLon(t, 10)) / v; v = E_v(t); //再算一次v有助于提高精度,不算也可以 +// t += (W - S_aLon(t, -1)) / v; +// return t; +//} +// +////地球速度,t是世纪数,误差小于万分3 +//long double XL::E_v(long double t) +//{ +// long double f = 628.307585*t; +// return 628.332 + 21 * sin(1.527 + f) + 0.44 * sin(1.48 + f * 2) +// + 0.129*sin(5.82 + f)*t + 0.00055*sin(4.21 + f)*t*t; +//} +// +////太阳视黄经 +//long double XL::S_aLon(long double t, long double n) { +// return E_Lon(t, n) + nutationLon2(t) + gxc_sunLon(t) + PI; //注意，这里的章动计算很耗时 +//}; +// +//long double XL::E_Lon(long double t, long double n) +//{ +// return XL0_calc(0, 0, t, n); +//} +// +//long double XL::XL0_calc(long double xt, int zn, long double t, int n) +//{ +// static long double XL0_xzb[] = { //行星星历修正表 +// //经(角秒),纬(角秒), 距(10-6AU) +// -0.08631, +0.00039, -0.00008, //水星 +// -0.07447, +0.00006, +0.00017, //金星 +// -0.07135, -0.00026, -0.00176, //火星 +// -0.20239, +0.00273, -0.00347, //木星 +// -0.25486, +0.00276, +0.42926, //土星 +// +0.24588, +0.00345, -14.46266, //天王星 +// -0.95116, +0.02481, +58.30651 //海王星 +// }; +// +// t /= 10; //转为儒略千年数 +// int i, j, v = 0, tn = 1, c; +// long double F = XL0[xt], n1, n2, N; +// var n0, pn = zn * 6 + 1, N0 = F[pn + 1] - F[pn]; //N0序列总数 +// for (i = 0; i < 6; i++, tn *= t) { +// n1 = F[pn + i], n2 = F[pn + 1 + i], n0 = n2 - n1; +// if (!n0) continue; +// if (n < 0) N = n2; //确定项数 +// else { N = int2(3 * n*n0 / N0 + 0.5) + n1; if (i) N += 3; if (N > n2) N = n2; } +// for (j = n1, c = 0; j < N; j += 3) c += F[j] * Math.cos(F[j + 1] + t*F[j + 2]); +// v += c*tn; +// } +// v /= F[0]; +// if (xt == 0) { //地球 +// var t2 = t*t, t3 = t2*t; //千年数的各次方 +// if (zn == 0) v += (-0.0728 - 2.7702*t - 1.1019*t2 - 0.0996*t3) / rad; +// if (zn == 1) v += (+0.0000 + 0.0004*t + 0.0004*t2 - 0.0026*t3) / rad; +// if (zn == 2) v += (-0.0020 + 0.0044*t + 0.0213*t2 - 0.0250*t3) / 1000000; +// } +// else { //其它行星 +// var dv = XL0_xzb[(xt - 1) * 3 + zn]; +// if (zn == 0) v += -3 * t / rad; +// if (zn == 2) v += dv / 1000000; +// else v += dv / rad; +// } +// return v; +//} +// +// +// +// diff --git a/src/XL.h b/src/XL.h new file mode 100644 index 0000000..af2a193 --- /dev/null +++ b/src/XL.h @@ -0,0 +1,22 @@ +#pragma once + +class XL +{ +public: + //已知太阳视黄经反求时间 + static long double S_aLon_t(long double W); + + //地球速度,t是世纪数,误差小于万分3 + static long double E_v(long double t); + + //太阳视黄经 + static long double S_aLon(long double t, long double n); + + //地球经度计算,返回Date分点黄经,传入世纪数、取项数 + static long double E_Lon(long double t, long double n); + + //xt星体,zn坐标号,t儒略世纪数,n计算项数 + static long double XL0_calc(long double xt, int zn, long double t, int n); + + +}; \ No newline at end of file diff --git a/src/const.h b/src/const.h new file mode 100644 index 0000000..64f3b9e --- /dev/null +++ b/src/const.h @@ -0,0 +1,46 @@ +#pragma once +#include + +//PI +#define PI (3.141592653589793) + +//地球赤道半径(千米) +#define cs_rEar (6378.1366) +//平均半径 +#define cs_rEarA (0.99834*cs_rEar) +//地球极赤半径比 +#define cs_ba (0.99664719) +//地球极赤半径比的平方 +#define cs_ba2 (cs_ba*cs_ba) +//天文单位长度(千米) +#define cs_AU (1.49597870691e8) +//sin(太阳视差) +#define cs_sinP (cs_rEar / cs_AU) +//太阳视差 +#define cs_PI ( Math.asin(cs_sinP)) +//光速(行米/秒) +#define cs_GS ( 299792.458) +//每天文单位的光行时间(儒略世纪) +#define cs_Agx ( cs_AU / cs_GS / 86400 / 36525) +//#define cs_xxHH ( new Array(116, 584, 780, 399, 378, 370, 367, 367)) //行星会合周期 +//#define xxName ( new Array('地球', '水星', '金星', '火星', '木星', '土星', '天王星', '海王星', '冥王星')) +//每弧度的角秒数 +#define rad ( 180 * 3600 / PI) +//每弧度的度数 +#define radd ( 180 / PI) +#define pi2 ( PI * 2) +#define pi_2 ( PI / 2) +#define J2000 ( 2451545) +// +#define cs_k ( 0.2725076) //月亮与地球的半径比(用于半影计算) +#define cs_k2 ( 0.2722810) //月亮与地球的半径比(用于本影计算) +#define cs_k0 ( 109.1222) //太阳与地球的半径比(对应959.64) +#define cs_sMoon ( cs_k*cs_rEar*1.0000036*rad) //用于月亮视半径计算 +#define cs_sMoon2 ( cs_k2*cs_rEar*1.0000036*rad) //用于月亮视半径计算 +#define cs_sSun ( 959.64) //用于太阳视半径计算 + +//转整型 +//#define int2(v) ((v)>=0?(int)(v):((int)(v)-1)) +#define int2(v) ((int)floor(v)) +//求余 +#define fmod2(v, n) ((v%n + n) % n) diff --git a/src/day.cpp b/src/day.cpp new file mode 100644 index 0000000..9f5a48b --- /dev/null +++ b/src/day.cpp @@ -0,0 +1,330 @@ +#include "day.h" +#include "eph.h" +#include "JD.h" + +namespace sxtwl +{ + GZ getShiGz(uint8_t dayTg, uint8_t hour, bool isZaoWanZiShi = true); +}; + +void Day::checkSSQ() +{ + if (!SSQPtr->ZQ.size() || this->d0 < SSQPtr->ZQ[0] || this->d0 >= SSQPtr->ZQ[24]) + { + SSQPtr->calcY(this->d0); + } +} + +/** + * 确定已经计算过阴历信息 + */ +void Day::checkLunarData() +{ + // 已经计算过了 + if (this->Ldn != 0) + { + return; + } + this->checkSSQ(); + + int mk = int2((this->d0 - SSQPtr->HS[0]) / 30); + if (mk < 13 && SSQPtr->HS[mk + 1] <= this->d0) + { + mk++; //农历所在月的序数 + } + + //if (this.d0 == SSQPtr->HS[mk]) { //月的信息 + this->Lmc = SSQPtr->ym[mk]; //月名称 + this->Ldn = SSQPtr->dx[mk]; //月大小 + this->Lleap = (SSQPtr->leap != 0 && SSQPtr->leap == mk); //闰状况 + //} + + // 阴历所处的日 + this->Ldi = this->d0 - SSQPtr->HS[mk]; +} + +void Day::checkSolarData() +{ + if (this->m != 0) + { + return; + } + + Time t = JD::JD2DD(this->d0 + J2000); + this->y = t.Y; + this->d = t.D; + this->m = t.M; +} + +/** + * 计算节气数据 + */ +void Day::checkJQData() +{ + if (this->qk != -2) + { + return; + } + + this->qk = -1; + this->getJieQiJD(); + + //this->checkSSQ(); + + //int qk = int2((this->d0 - SSQPtr->ZQ[0] - 7) / 15.2184); + //////节气的取值范围是0-23 + //if (qk < 23 && this->d0 >= SSQPtr->ZQ[qk + 1]) + //{ + // qk++; + //} + + //this->qk = -1; + //if (this->d0 == SSQPtr->ZQ[qk]) + //{ + // this->qk = qk; + //} +} + +Day *Day::after(int day) +{ + return new Day(this->d0 + day); +} + +Day *Day::before(int day) +{ + return new Day(this->d0 - day); +} + +/** + * 获取阴历日期 + */ +int Day::getLunarDay() +{ + this->checkLunarData(); + return this->Ldi + 1; +} + +/** + * 获取阴历月 + */ +uint8_t Day::getLunarMonth() +{ + this->checkLunarData(); + static const int yueIndex[12] = { 11, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + return yueIndex[this->Lmc]; +} + +int Day::getLunarYear(bool chineseNewYearBoundary) +{ + // 以立春为界 + if (chineseNewYearBoundary == false) + { + if (this->Lyear == 0) + { + this->checkSSQ(); + long double D = SSQPtr->ZQ[3] + (this->d0 < SSQPtr->ZQ[3] ? -365 : 0) + 365.25 * 16 - 35; //以立春为界定纪年 + this->Lyear = int2(D / 365.2422 + 0.5); + } + return this->Lyear + 1984; + } + // 以春节为界 + if (this->Lyear0 == 0) + { + this->checkSSQ(); + int D = SSQPtr->HS[2]; //一般第3个月为春节 + for (int j = 0; j < 14; j++) + { //找春节 + if (SSQPtr->ym[j] != 2 || SSQPtr->leap == j && j) + continue; + D = SSQPtr->HS[j]; + if (this->d0 < D) + { + D -= 365; + break; + } //无需再找下一个正月 + } + D = D + 5810; //计算该年春节与1984年平均春节(立春附近)相差天数估计 + this->Lyear0 = int2(D / 365.2422 + 0.5); + } + return this->Lyear0 + 1984; +} + +GZ Day::getYearGZ(bool chineseNewYearBoundary) +{ + //以春节为界 + if (chineseNewYearBoundary) + { + if (this->Lyear3 == NULL) + { + int year = this->getLunarYear(chineseNewYearBoundary) - 1984; + int D = year + 12000; + this->Lyear3 = new GZ(D % 10, D % 12); + } + return *(this->Lyear3); + } + + // 以立春为界 + if (this->Lyear2 == NULL) + { + int year = this->getLunarYear(false) - 1984; + int D = year + 12000; + this->Lyear2 = new GZ(D % 10, D % 12); + } + return *(this->Lyear2); +} + +GZ Day::getMonthGZ() +{ + if (this->Lmonth2 == NULL) + { + this->checkSSQ(); + int mk = int2((this->d0 - SSQPtr->ZQ[0]) / 30.43685); + //相对大雪的月数计算,mk的取值范围0-12 + if (mk < 12 && this->d0 >= SSQPtr->ZQ[2 * mk + 1]) + mk++; + //相对于1998年12月7(大雪)的月数,900000为正数基数 + int D = mk + int2((SSQPtr->ZQ[12] + 390) / 365.2422) * 12 + 900000; + this->Lmonth2 = new GZ(D % 10, D % 12); + } + return *(this->Lmonth2); +} + +GZ Day::getDayGZ() +{ + if (this->Lday2 == NULL) + { + int D = this->d0 - 6 + 9000000; + this->Lday2 = new GZ(D % 10, D % 12); + } + return *(this->Lday2); +} + +GZ Day::getHourGZ(uint8_t hour, bool isZaoWanZiShi) +{ + GZ dayGZ = this->getDayGZ(); + return sxtwl::getShiGz(dayGZ.tg, hour, isZaoWanZiShi); +} + +bool Day::isLunarLeap() +{ + this->checkLunarData(); + return this->Lleap; +} + +int Day::getSolarYear() +{ + this->checkSolarData(); + return this->y; +} + +uint8_t Day::getSolarMonth() +{ + this->checkSolarData(); + return this->m; +} + +int Day::getSolarDay() +{ + this->checkSolarData(); + return this->d; +} + +uint8_t Day::getWeek() +{ + if (this->week == 0xFF) + { + this->week = (this->d0 + J2000 + 1 + 7000000) % 7; + } + return this->week; +} + +// 处于该月的第几周 +uint8_t Day::getWeekIndex() +{ + int i = (this->getSolarDay() - 1) % 7; + + int w0 = 0; + if (this->getWeek() >= i) + { + w0 = this->getWeek() - i; + } + else + { + w0 = this->getWeek() + 7 - i; + } + return int2((w0 + this->getSolarDay() - 1) / 7) + 1; +} +//是否有节气 +bool Day::hasJieQi() +{ + this->checkJQData(); + return this->qk != -1; +} +// 获取节气 +uint8_t Day::getJieQi() +{ + this->checkJQData(); + return this->qk; +} + + + +double Day::getJieQiJD() +{ + if (this->jqjd != 0) + { + return this->jqjd; + } + + long double d, xn, jd2 = this->d0 + dt_T(this->d0) - (long double)8 / (long double)24; + long double w = XL::S_aLon(jd2 / 36525, 3); + w = int2((w - 0.13) / pi2 * 24) * pi2 / 24; + int D = 0; + + do + { + d = qi_accurate(w); + D = int2(d + 0.5); + // 计算出的节令值 + xn = int2(w / pi2 * 24 + 24000006.01) % 24; + w += pi2 / 24; + if (D > this->d0) + break; + if (D < this->d0) + continue; + if (D == this->d0) + { + Time t1 = JD::JD2DD(d); + Time t2 = JD::JD2DD(D + J2000); + + t2.h = t1.h; + t2.m = t1.m; + t2.s = t1.s; + + auto jd = JD::toJD(t2); + + this->jqjd = jd; + this->qk = xn; + break; + } + } while (D + 12 < this->d0); + + return this->jqjd; //+ J2000; +} + +// 获取星座 +uint8_t Day::getConstellation() +{ + if (this->XiZ == 0xFF) + { + this->checkSSQ(); + int mk = int2((this->d0 - SSQPtr->ZQ[0] - 15) / 30.43685); + //星座所在月的序数,(如果j=13,ob.d0不会超过第14号中气) + if (mk < 11 && this->d0 >= SSQPtr->ZQ[2 * mk + 2]) + { + mk++; + } + this->XiZ = (mk + 12) % 12; + } + return this->XiZ; +} diff --git a/src/day.h b/src/day.h new file mode 100644 index 0000000..ece5389 --- /dev/null +++ b/src/day.h @@ -0,0 +1,216 @@ +#pragma once + +#include +#include +#include "JD.h" +#include "const.h" +#include "SSQ.h" + +static std::unique_ptr SSQPtr(new SSQ()); + +struct GZ +{ + GZ(){}; + GZ(uint8_t tg, uint8_t dz) : tg(tg), dz(dz) + { + } + uint8_t tg; + uint8_t dz; +}; + +class Day +{ +private: + int d0; //儒略日 + + int y; //公历年 + uint8_t m; //公历月 + int d; + + int Lmc; //阴历月的月 + uint8_t Ldi; //阴历月的日 + int Ldn; //该阴历月的总天数 + bool Lleap; //是不是阴历的润月 + + int Lyear; //以立春为界， 定农历纪年(10进制,1984年起算) + int Lyear0; //以正月初一为界，农历纪年(10进制,1984年起算) + + uint8_t week; //星期几 + int8_t qk; //节令值 + uint8_t XiZ; //星座 + double jqjd; //节气最体的时间 + + GZ *Lyear2; //干支纪年(立春) + GZ *Lyear3; //干支纪年(正月 春节) + GZ *Lmonth2; //月天干地支 + GZ *Lday2; // 日天干地支 + +private: + Day(int d0) + { + this->d0 = d0; + this->Ldn = 0; + this->m = 0; + this->qk = -2; + this->Lyear = 0; + this->Lyear0 = 0; + + this->Lyear2 = NULL; + this->Lyear3 = NULL; + this->Lmonth2 = NULL; + this->Lday2 = NULL; + + this->week = 0xFF; + this->XiZ = 0xFF; + this->jqjd = 0; + }; + + void checkSSQ(); + void checkLunarData(); + void checkSolarData(); + void checkJQData(); + +public: + virtual ~Day() + { + if (this->Lyear2) + { + delete this->Lyear2; + this->Lyear2 = NULL; + } + + if (this->Lyear3) + { + delete this->Lyear3; + this->Lyear3 = NULL; + } + + if (this->Lmonth2) + { + delete this->Lmonth2; + this->Lmonth2 = NULL; + } + + if (this->Lday2) + { + delete this->Lday2; + this->Lday2 = NULL; + } + } + + Day *after(int day); + Day *before(int day); + // 获取阴历日期 + int getLunarDay(); + //获取阴历月 + uint8_t getLunarMonth(); + //获取阴历年 chineseNewYearBoundary是否以春节为界 + int getLunarYear(bool chineseNewYearBoundary = true); + //获取阴历年干支 chineseNewYearBoundary是否以春节为界 + GZ getYearGZ(bool chineseNewYearBoundary = false); + GZ getMonthGZ(); + GZ getDayGZ(); + // 注意非早晚子时的时候，day要算第二天 + GZ getHourGZ(uint8_t hour, bool isZaoWanZiShi = true); + bool isLunarLeap(); + + int getSolarYear(); + uint8_t getSolarMonth(); + int getSolarDay() ; + uint8_t getWeek(); + // 处于该月的第几周 + uint8_t getWeekIndex(); + //是否有节气 + bool hasJieQi(); + // 获取节气 + uint8_t getJieQi() ; + double getJieQiJD(); + // 获取星座 + uint8_t getConstellation(); +public: + static Day *fromSolar(int _year, uint8_t _month, int _day) + { + Time *t = new Time(); + t->h = 12, t->m = 0, t->s = 0.1; + t->Y = _year; + t->M = _month; + t->D = _day; + int d0 = int2(JD::toJD(*t)) - J2000; + return new Day(d0); + } + + static Day *fromLunar(int year, uint8_t month, int day, bool isRun = false) + { + Time *t = new Time(); + t->h = 12, t->m = 0, t->s = 0.1; + t->Y = year; + t->M = 1; + t->D = 1; + if (month > 10) + { + t->Y = year + 1; + } + + int Bd0 = int2(JD::toJD(*t)) - J2000; + if (!SSQPtr->ZQ.size() || Bd0 < SSQPtr->ZQ[0] || Bd0 >= SSQPtr->ZQ[24]) + { + SSQPtr->calcY(Bd0); + } + + static const int yueIndex[12] = {11, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + int yue = 0; + + for (int i = 0; i < sizeof(yueIndex); ++i) + { + if (yueIndex[i] == month) + { + yue = i; + break; + } + } + + int mk = 0; + int leap = SSQPtr->leap - 1; + + for (int i = 0; i < SSQPtr->ym.size(); ++i) + { + int it = SSQPtr->ym[i]; + if (leap < 0) + { + if (it == yue) + { + break; + } + } + else + { + if (yue < leap && it == yue) + { + break; + } + + if (yue == leap && it == yue && isRun) + { + ++mk; + break; + } + + if (yue == leap && it == yue && !isRun) + { + break; + } + + if (yue > leap && it == yue) + { + break; + } + } + ++mk; + } + + int bdi = SSQPtr->HS[mk]; + int jd = bdi + day - 1; + + return new Day(jd); + } +}; diff --git a/src/eph.cpp b/src/eph.cpp new file mode 100644 index 0000000..8c30637 --- /dev/null +++ b/src/eph.cpp @@ -0,0 +1,1170 @@ +#include "eph.h" +#include "const.h" +#include +#include +//=================================数学工具========================================= +//对超过0-2PI的角度转为0-2PI; +long double rad2mrad(long double v) +{ + v = fmod(v, (2 * PI)); + if (v < 0) return v + 2 * PI; + return v; +} + +//对超过-PI到PI的角度转为-PI到PI; +long double rad2rrad(long double v) +{ + v = fmod(v, (2 * PI)); + if (v <= -PI) return v + 2 * PI; + if (v > PI) return v - 2 * PI; + return v; +} + +//临界余数(a与最近的整倍数b相差的距离); +long double mod2(long double a, long double b) +{ + long double c = a / b; + c -= floor(c); + if (c > 0.5) c -= 1; + return c*b; +} + +//球面转直角坐标; +Vector3 llr2xyz(Vector3 JW) +{ + Vector3 r; + long double J = JW.x, W = JW.y, R = JW.z; + r.x = R*cos(W)*cos(J); + r.y = R*cos(W)*sin(J); + r.z = R*sin(W); + return r; +} + +//直角坐标转球; +Vector3 xyz2llr(Vector3 xyz) { + Vector3 r; + long double x = xyz.x, y = xyz.y, z = xyz.z; + r.z = sqrt(x*x + y*y + z*z); + r.y = asin(z / r.z); + r.x = rad2mrad(atan2(y, x)); + return r; +} + +//球面坐标旋转; +Vector3 llrConv(Vector3 JW, long double E) { + Vector3 r; + long double J = JW.x, W = JW.y; + r.x = atan2(sin(J)*cos(E) - tan(W)*sin(E), cos(J)); + r.y = asin(cos(E)*sin(W) + sin(E)*cos(W)*sin(J)); + r.z = JW.z; + r.x = rad2mrad(r.x); + return r; +} + +//赤道坐标转为地平坐标; +Vector3 CD2DP(Vector3 z, long double L, long double fa, long double gst) +{ + //转到相对于地平赤道分点的赤道坐标; + Vector3 a(z.x + PI / 2 - gst - L, z.y, z.z); + a = llrConv(a, PI / 2 - fa); + a.x = rad2mrad(PI / 2 - a.x); + return a; +} + +//求角度差; +long double j1_j2(long double J1, long double W1, long double J2, long double W2) { + long double dJ = rad2rrad(J1 - J2), dW = W1 - W2; + if (fabs(dJ) < 1 / 1000 && fabs(dW) < 1 / 1000) { + dJ *= cos((W1 + W2) / 2); + return sqrt(dJ*dJ + dW*dW); + } + return acos(sin(W1)* sin(W2) + cos(W1)*cos(W2)*cos(dJ)); +} + +//日心球面转地心球面,Z星体球面坐标,A地球球面坐标; +//本含数是通用的球面坐标中心平移函数,行星计算中将反复使用; +Vector3 h2g(Vector3 z, Vector3 a) { + a = llr2xyz(a); //地球 + z = llr2xyz(z); //星体 + z.x -= a.x; z.y -= a.y; z.z -= a.z; + return xyz2llr(z); +} + +//视差角(不是视差); +long double shiChaJ(long double gst, long double L, long double fa, long double J, long double W) { + long double H = gst + L - J; //天体的时角; + return rad2mrad(atan2(sin(H), tan(fa)*cos(W) - sin(W)*cos(H))); +} + +//=================================deltat T计算===================================== +static constexpr long double dt_at[] = { // TD - UT1 计算表 + -4000, 108371.7, -13036.80, 392.000, 0.0000, + -500, 17201.0, -627.82, 16.170, -0.3413, + -150, 12200.6, -346.41, 5.403, -0.1593, + 150, 9113.8, -328.13, -1.647, 0.0377, + 500, 5707.5, -391.41, 0.915, 0.3145, + 900, 2203.4, -283.45, 13.034, -0.1778, + 1300, 490.1, -57.35, 2.085, -0.0072, + 1600, 120.0, -9.81, -1.532, 0.1403, + 1700, 10.2, -0.91, 0.510, -0.0370, + 1800, 13.4, -0.72, 0.202, -0.0193, + 1830, 7.8, -1.81, 0.416, -0.0247, + 1860, 8.3, -0.13, -0.406, 0.0292, + 1880, -5.4, 0.32, -0.183, 0.0173, + 1900, -2.3, 2.06, 0.169, -0.0135, + 1920, 21.2, 1.69, -0.304, 0.0167, + 1940, 24.2, 1.22, -0.064, 0.0031, + 1960, 33.2, 0.51, 0.231, -0.0109, + 1980, 51.0, 1.29, -0.026, 0.0032, + 2000, 63.87, 0.1, 0, 0, + 2005, 64.7, 0.4, 0, 0, //一次项记为x,则 10x=0.4秒/年*(2015-2005),解得x=0.4 + 2015, 69 +}; + +long double dt_ext(long double y, int jsd) { long double dy = (y - 1820) / 100; return -20 + jsd*dy*dy; } //二次曲线外推 + +long double dt_calc(long double y) { //计算世界时与原子时之差,传入年 + + int dt_at_length = sizeof(dt_at) / sizeof(long double); + + long double y0 = dt_at[dt_at_length - 2]; //表中最后一年 + long double t0 = dt_at[dt_at_length - 1]; //表中最后一年的deltatT + if (y >= y0) { + int jsd = 31; //sjd是y1年之后的加速度估计。瑞士星历表jsd=31,NASA网站jsd=32,skmap的jsd=29 + if (y > y0 + 100) return dt_ext(y, jsd); + long double v = dt_ext(y, jsd); //二次曲线外推 + long double dv = dt_ext(y0, jsd) - t0; //ye年的二次外推与te的差 + return v - dv*(y0 + 100 - y) / 100; + } + int i; + const long double* d = dt_at; + for (i = 0; i < dt_at_length; i += 5) + { + if (y < d[i + 5]) break; + } + + long double t1 = (y - d[i]) / (d[i + 5] - d[i]) * 10, t2 = t1*t1, t3 = t2*t1; + return d[i + 1] + d[i + 2] * t1 + d[i + 3] * t2 + d[i + 4] * t3; +} + +//传入儒略日(J2000起算),计算TD-UT(单位:日) +long double dt_T(long double t) +{ + return dt_calc(t / 365.2425 + 2000) / 86400.0; +} + +//=================================岁差计算========================================= +//IAU1976岁差表 +static constexpr long double preceTab_IAU1976[] = { + 0, 5038.7784, -1.07259, -0.001147, //fi + 84381.448, 0, +0.05127, -0.007726, //w + 0, +4.1976, +0.19447, -0.000179, //P + 0, -46.8150, +0.05059, +0.000344, //Q + 84381.448, -46.8150, -0.00059, +0.001813, //E + 0, +10.5526, -2.38064, -0.001125, //x + 0, 47.0028, -0.03301, +0.000057, //pi(自导出),根据P=sin(pi)*sin(II) + 629554.886, -869.8192, +0.03666, -0.001504, //II(自导出),根据Q=sin(pi)*cos(II) + 0, 5029.0966, +1.11113, +0.000006, //p + 0, 2004.3109, -0.42665, -0.041833, //th + 0, 2306.2181, +0.30188, +0.017998, //Z + 0, 2306.2181, +1.09468, +0.018203 //z +}; + +//IAU2000岁差表 +static constexpr long double preceTab_IAU2000[] = { + 0, 5038.478750, -1.07259, -0.001147, 0, 0, //fi + 84381.448, -0.025240, +0.05127, -0.007726, 0, 0, //w, + 0, +4.1976, +0.19447, -0.000179, 0, 0, //P, + 0, -46.8150, +0.05059, +0.000344, 0, 0, //Q, + 84381.448, -46.84024, -0.00059, +0.001813, 0, 0, //E, + 0, +10.5526, -2.38064, -0.001125, 0, 0, //x + 0, 47.0028, -0.03301, +0.000057, 0, 0, //pi(自导出) + 629554.886, -869.8192, +0.03666, -0.001504, 0, 0, //II(自导出) + 0, 5028.79695, +1.11113, +0.000006, 0, 0, //p + 0, 2004.1917476, -0.4269353, -0.0418251, -0.0000601, -0.0000001, //th + +2.5976176, 2306.0809506, +0.3019015, +0.0179663, -0.0000327, -0.0000002, //Z + -2.5976176, 2306.0803226, +1.0947790, +0.0182273, +0.0000470, -0.0000003 //z +}; + +static constexpr long double preceTab_P03[] = { + 0, 5038.481507, -1.0790069, -0.00114045, +0.000132851, -9.51e-8, //fi + 84381.406000, -0.025754, +0.0512623, -0.00772503, -4.67e-7, +3.337e-7, //w + 0, 4.199094, +0.1939873, -0.00022466, -9.12e-7, +1.20e-8, //P + 0, -46.811015, +0.0510283, +0.00052413, -6.46e-7, -1.72e-8, //Q + 84381.406000, -46.836769, -0.0001831, +0.00200340, -5.76e-7, -4.34e-8, //E + 0, 10.556403, -2.3814292, -0.00121197, +0.000170663, -5.60e-8, //x + 0, 46.998973, -0.0334926, -0.00012559, +1.13e-7, -2.2e-9, //pi + 629546.7936, -867.95758, +0.157992, -0.0005371, -0.00004797, +7.2e-8, //II + 0, 5028.796195, +1.1054348, +0.00007964, -0.000023857, +3.83e-8, //p + 0, 2004.191903, -0.4294934, -0.04182264, -7.089e-6, -1.274e-7, //th + 2.650545, 2306.083227, +0.2988499, +0.01801828, -5.971e-6, -3.173e-7, //Z + -2.650545, 2306.077181, +1.0927348, +0.01826837, -0.000028596, -2.904e-7 //z +}; + +//t是儒略世纪数,sc是岁差量名称,mx是模型 +long double prece(long double t, std::string sc, std::string mx) { + int i, tn = 1, c = 0, n; + const long double* p = NULL; + if (mx == "IAU1976") n = 4, p = preceTab_IAU1976; + if (mx == "IAU2000") n = 6, p = preceTab_IAU2000; + if (mx == "P03") n = 6, p = preceTab_P03; + int isc = std::string("fi w P Q E x pi II p th Z z ").find(sc + ' ') / 3; + for (i = 0; i < n; i++, tn *= t) c += p[isc*n + i] * tn; + return c / rad; +} + + +//返回P03黄赤交角,t是世纪数 +long double hcjj(long double t) { + long double t2 = t*t, t3 = t2*t, t4 = t3*t, t5 = t4*t; + return (84381.4060 - 46.836769*t - 0.0001831*t2 + 0.00200340*t3 - 5.76e-7*t4 - 4.34e-8*t5) / rad; +} + +//=================================岁差旋转========================================= +//J2000赤道转Date赤道 +Vector3 CDllr_J2D(long double t, Vector3 llr, std::string mx) +{ + long double Z = prece(t, "Z", mx) + llr.x; + long double z = prece(t, "z", mx); + long double th = prece(t, "th", mx); + long double cosW = cos(llr.y), cosH = cos(th); + long double sinW = sin(llr.y), sinH = sin(th); + long double A = cosW*sin(Z); + long double B = cosH*cosW*cos(Z) - sinH*sinW; + long double C = sinH*cosW*cos(Z) + cosH*sinW; + return Vector3(rad2mrad(atan2(A, B) + z), asin(C), llr.z); +} +//Date赤道转J2000赤道 +Vector3 CDllr_D2J(long double t, Vector3 llr, std::string mx) +{ + long double Z = -prece(t, "z", mx) + llr[0]; + long double z = -prece(t, "Z", mx); + long double th = -prece(t, "th", mx); + long double cosW = cos(llr.y), cosH = cos(th); + long double sinW = sin(llr.y), sinH = sin(th); + long double A = cosW*sin(Z); + long double B = cosH*cosW*cos(Z) - sinH*sinW; + long double C = sinH*cosW*cos(Z) + cosH*sinW; + return Vector3(rad2mrad(atan2(A, B) + z), asin(C), llr.z); +} + +//黄道球面坐标_J2000转Date分点,t为儒略世纪数 +Vector3 HDllr_J2D(long double t, Vector3 llr, std::string mx) { + //J2000黄道旋转到Date黄道(球面对球面),也可直接由利用球面旋转函数计算,但交角接近为0时精度很低 + Vector3 r(llr.x, llr.y, llr.z); + r.x += prece(t, "fi", mx); r = llrConv(r, prece(t, "w", mx)); + r.x -= prece(t, "x", mx); r = llrConv(r, -prece(t, "E", mx)); + return r; +} + +//黄道球面坐标_Date分点转J2000,t为儒略世纪数 +Vector3 HDllr_D2J(long double t, Vector3 llr, std::string mx) +{ + Vector3 r(llr.x, llr.y, llr.z); + r = llrConv(r, prece(t, "E", mx)); r.x += prece(t, "x", mx); + r = llrConv(r, -prece(t, "w", mx)); r.x -= prece(t, "fi", mx); + r.x = rad2mrad(r.x); + return r; +} + +//=================================章动计算========================================= +//================================================================================== +static constexpr long double nuTab[] = { //IAU2000B章动序列 + //l l' F D Om A A' A" B B' B" + 0, 0, 0, 0, 1, -172064161, -174666, 33386, 92052331, 9086, 15377, + 0, 0, 2, -2, 2, -13170906, -1675, -13696, 5730336, -3015, -4587, + 0, 0, 2, 0, 2, -2276413, -234, 2796, 978459, -485, 1374, + 0, 0, 0, 0, 2, 2074554, 207, -698, -897492, 470, -291, + 0, 1, 0, 0, 0, 1475877, -3633, 11817, 73871, -184, -1924, + 0, 1, 2, -2, 2, -516821, 1226, -524, 224386, -677, -174, + 1, 0, 0, 0, 0, 711159, 73, -872, -6750, 0, 358, + 0, 0, 2, 0, 1, -387298, -367, 380, 200728, 18, 318, + 1, 0, 2, 0, 2, -301461, -36, 816, 129025, -63, 367, + 0, -1, 2, -2, 2, 215829, -494, 111, -95929, 299, 132, + + 0, 0, 2, -2, 1, 128227, 137, 181, -68982, -9, 39, + -1, 0, 2, 0, 2, 123457, 11, 19, -53311, 32, -4, + -1, 0, 0, 2, 0, 156994, 10, -168, -1235, 0, 82, + 1, 0, 0, 0, 1, 63110, 63, 27, -33228, 0, -9, + -1, 0, 0, 0, 1, -57976, -63, -189, 31429, 0, -75, + -1, 0, 2, 2, 2, -59641, -11, 149, 25543, -11, 66, + 1, 0, 2, 0, 1, -51613, -42, 129, 26366, 0, 78, + -2, 0, 2, 0, 1, 45893, 50, 31, -24236, -10, 20, + 0, 0, 0, 2, 0, 63384, 11, -150, -1220, 0, 29, + 0, 0, 2, 2, 2, -38571, -1, 158, 16452, -11, 68, + + 0, -2, 2, -2, 2, 32481, 0, 0, -13870, 0, 0, + -2, 0, 0, 2, 0, -47722, 0, -18, 477, 0, -25, + 2, 0, 2, 0, 2, -31046, -1, 131, 13238, -11, 59, + 1, 0, 2, -2, 2, 28593, 0, -1, -12338, 10, -3, + -1, 0, 2, 0, 1, 20441, 21, 10, -10758, 0, -3, + 2, 0, 0, 0, 0, 29243, 0, -74, -609, 0, 13, + 0, 0, 2, 0, 0, 25887, 0, -66, -550, 0, 11, + 0, 1, 0, 0, 1, -14053, -25, 79, 8551, -2, -45, + -1, 0, 0, 2, 1, 15164, 10, 11, -8001, 0, -1, + 0, 2, 2, -2, 2, -15794, 72, -16, 6850, -42, -5, + + 0, 0, -2, 2, 0, 21783, 0, 13, -167, 0, 13, + 1, 0, 0, -2, 1, -12873, -10, -37, 6953, 0, -14, + 0, -1, 0, 0, 1, -12654, 11, 63, 6415, 0, 26, + -1, 0, 2, 2, 1, -10204, 0, 25, 5222, 0, 15, + 0, 2, 0, 0, 0, 16707, -85, -10, 168, -1, 10, + 1, 0, 2, 2, 2, -7691, 0, 44, 3268, 0, 19, + -2, 0, 2, 0, 0, -11024, 0, -14, 104, 0, 2, + 0, 1, 2, 0, 2, 7566, -21, -11, -3250, 0, -5, + 0, 0, 2, 2, 1, -6637, -11, 25, 3353, 0, 14, + 0, -1, 2, 0, 2, -7141, 21, 8, 3070, 0, 4, + + 0, 0, 0, 2, 1, -6302, -11, 2, 3272, 0, 4, + 1, 0, 2, -2, 1, 5800, 10, 2, -3045, 0, -1, + 2, 0, 2, -2, 2, 6443, 0, -7, -2768, 0, -4, + -2, 0, 0, 2, 1, -5774, -11, -15, 3041, 0, -5, + 2, 0, 2, 0, 1, -5350, 0, 21, 2695, 0, 12, + 0, -1, 2, -2, 1, -4752, -11, -3, 2719, 0, -3, + 0, 0, 0, -2, 1, -4940, -11, -21, 2720, 0, -9, + -1, -1, 0, 2, 0, 7350, 0, -8, -51, 0, 4, + 2, 0, 0, -2, 1, 4065, 0, 6, -2206, 0, 1, + 1, 0, 0, 2, 0, 6579, 0, -24, -199, 0, 2, + + 0, 1, 2, -2, 1, 3579, 0, 5, -1900, 0, 1, + 1, -1, 0, 0, 0, 4725, 0, -6, -41, 0, 3, + -2, 0, 2, 0, 2, -3075, 0, -2, 1313, 0, -1, + 3, 0, 2, 0, 2, -2904, 0, 15, 1233, 0, 7, + 0, -1, 0, 2, 0, 4348, 0, -10, -81, 0, 2, + 1, -1, 2, 0, 2, -2878, 0, 8, 1232, 0, 4, + 0, 0, 0, 1, 0, -4230, 0, 5, -20, 0, -2, + -1, -1, 2, 2, 2, -2819, 0, 7, 1207, 0, 3, + -1, 0, 2, 0, 0, -4056, 0, 5, 40, 0, -2, + 0, -1, 2, 2, 2, -2647, 0, 11, 1129, 0, 5, + + -2, 0, 0, 0, 1, -2294, 0, -10, 1266, 0, -4, + 1, 1, 2, 0, 2, 2481, 0, -7, -1062, 0, -3, + 2, 0, 0, 0, 1, 2179, 0, -2, -1129, 0, -2, + -1, 1, 0, 1, 0, 3276, 0, 1, -9, 0, 0, + 1, 1, 0, 0, 0, -3389, 0, 5, 35, 0, -2, + 1, 0, 2, 0, 0, 3339, 0, -13, -107, 0, 1, + -1, 0, 2, -2, 1, -1987, 0, -6, 1073, 0, -2, + 1, 0, 0, 0, 2, -1981, 0, 0, 854, 0, 0, + -1, 0, 0, 1, 0, 4026, 0, -353, -553, 0, -139, + 0, 0, 2, 1, 2, 1660, 0, -5, -710, 0, -2, + + -1, 0, 2, 4, 2, -1521, 0, 9, 647, 0, 4, + -1, 1, 0, 1, 1, 1314, 0, 0, -700, 0, 0, + 0, -2, 2, -2, 1, -1283, 0, 0, 672, 0, 0, + 1, 0, 2, 2, 1, -1331, 0, 8, 663, 0, 4, + -2, 0, 2, 2, 2, 1383, 0, -2, -594, 0, -2, + -1, 0, 0, 0, 2, 1405, 0, 4, -610, 0, 2, + 1, 1, 2, -2, 2, 1290, 0, 0, -556, 0, 0 +}; + +//章动计算,t是J2000.0起算的儒略世纪数,zq表示只计算周期大于zq(天)的项 +Vector2 nutation(long double t, long double zq) { + long double t2 = t*t, t3 = t2*t, t4 = t3*t; //t的二、三、四次方 + long double l = 485868.249036 + 1717915923.2178*t + 31.8792*t2 + 0.051635*t3 - 0.00024470*t4; + long double l1 = 1287104.79305 + 129596581.0481*t - 0.5532*t2 - 0.000136*t3 - 0.00001149*t4; + long double F = 335779.526232 + 1739527262.8478*t - 12.7512*t2 - 0.001037*t3 + 0.00000417*t4; + long double D = 1072260.70369 + 1602961601.2090*t - 6.3706*t2 + 0.006593*t3 - 0.00003169*t4; + long double Om = 450160.398036 - 6962890.5431*t + 7.4722*t2 + 0.007702*t3 - 0.00005939*t4; + long double dL = 0, dE = 0, c; + const long double* B = nuTab; + long double q; + for (int i = 0; i < 77 * 11; i += 11) { //周期项取和计算 + c = (B[i] * l + B[i + 1] * l1 + B[i + 2] * F + B[i + 3] * D + B[i + 4] * Om) / rad; + if (zq) { //只算周期大于zq天的项 + q = 36526 * 2 * PI*rad / (1717915923.2178*B[i] + 129596581.0481*B[i + 1] + 1739527262.8478*B[i + 2] + 1602961601.2090*B[i + 3] + 6962890.5431*B[i + 4]); + if (q < zq) continue; + } + dL += (B[i + 5] + B[i + 6] * t) * sin(c) + B[i + 7] * cos(c); + dE += (B[i + 8] + B[i + 9] * t) * cos(c) + B[i + 10] * sin(c); + } + return Vector2(dL /= 10000000 * rad, dE /= 10000000 * rad); //返回IAU2000B章动值, dL是黄经章动,dE是交角章动 +} + +//本函数计算赤经章动及赤纬章动 +Vector3 CDnutation(Vector3 z, long double E, long double dL, long double dE) +{ + Vector3 r(z); + r[0] += (cos(E) + sin(E)*sin(z[0])*tan(z[1]))*dL - cos(z[0])*tan(z[1])*dE; //赤经章动 + r[1] += sin(E)*cos(z[0])*dL + sin(z[0])*dE; //赤纬章动 + r[0] = rad2mrad(r[0]); + return r; +} + +//中精度章动计算表 +static constexpr long double nutB[] = { + 2.1824, -33.75705, 36e-6, -1720, 920, + 3.5069, 1256.66393, 11e-6, -132, 57, + 1.3375, 16799.4182, -51e-6, -23, 10, + 4.3649, -67.5141, 72e-6, 21, -9, + 0.04, -628.302, 0, -14, 0, + 2.36, 8328.691, 0, 7, 0, + 3.46, 1884.966, 0, -5, 2, + 5.44, 16833.175, 0, -4, 2, + 3.69, 25128.110, 0, -3, 0, + 3.55, 628.362, 0, 2, 0 +}; + +Vector2 nutation2(long double t) { //中精度章动计算,t是世纪数 + long double c, a, t2 = t*t; + const long double* B = nutB; + long double dL = 0, dE = 0; + for (int i = 0; i < sizeof(nutB) / sizeof(long double); i += 5) { + c = B[i] + B[i + 1] * t + B[i + 2] * t2; + if (i == 0) a = -1.742*t; else a = 0; + dL += (B[i + 3] + a)*sin(c); + dE += B[i + 4] * cos(c); + } + return Vector2(dL / 100 / rad, dE / 100 / rad); //黄经章动,交角章动 +} + +long double nutationLon2(long double t) { //只计算黄经章动 + long double a, t2 = t*t, dL = 0; + const long double* B = nutB; + for (int i = 0; i < sizeof(nutB) / sizeof(long double); i += 5) { + if (i == 0) a = -1.742*t; else a = 0; + dL += (B[i + 3] + a) * sin(B[i] + B[i + 1] * t + B[i + 2] * t2); + } + return dL / 100 / rad; +} + +//=================================蒙气改正========================================= +//================================================================================== +long double MQC(long double h) { return 0.0002967 / tan(h + 0.003138 / (h + 0.08919)); } //大气折射,h是真高度 +long double MQC2(long double ho) { return -0.0002909 / tan(ho + 0.002227 / (ho + 0.07679)); } //大气折射,ho是视高度 + + //=================================视差改正========================================= + //================================================================================== +void parallax(Vector3 z, long double H, long double fa, long double high) { //视差修正 + //z赤道坐标,fa地理纬度,H时角,high海拔(千米) + long double dw = 1; if (z[2] < 500) dw = cs_AU; + z[2] *= dw; + long double r0, x0, y0, z0, f = cs_ba, u = atan(f*tan(fa)), g = z[0] + H; + r0 = cs_rEar*cos(u) + high*cos(fa); //站点与地地心向径的赤道投影长度 + z0 = cs_rEar*sin(u)*f + high*sin(fa); //站点与地地心向径的轴向投影长度 + x0 = r0*cos(g); + y0 = r0*sin(g); + + Vector3 s = llr2xyz(z); + s[0] -= x0, s[1] -= y0, s[2] -= z0; + s = xyz2llr(s); + z[0] = s[0], z[1] = s[1], z[2] = s[2] / dw; +} +//=================================星历数据========================================= +//================================================================================== + +/******************************** +8行星星历数据表,及数据表的计算 +********************************/ + +//Dear精度:J2000+-4千年 黄经0.1角秒 黄纬0.1角秒 距离0.1AU/10^6 +static constexpr long double XL0_0[] = { + 10000000000,//A的倍率 + 20, 578, 920, 1100, 1124, 1136, 1148, 1217, 1226, 1229, 1229, 1229, 1229, 1937, 2363, 2618, 2633, 2660, 2666,//位置索引表 + /*L0*/ 17534704567, 0.00000000000, 0.00000000000, 334165646, 4.669256804, 6283.075849991, 3489428, 4.6261024, 12566.1517000, 349706, 2.744118, 5753.384885, 341757, 2.828866, 3.523118, 313590, 3.627670, 77713.771468, 267622, 4.418084, 7860.419392, 234269, 6.135162, 3930.209696, 132429, 0.742464, 11506.769770, 127317, 2.037097, 529.690965, 119917, 1.109629, 1577.343542, 99025, 5.23268, 5884.92685, 90186, 2.04505, 26.29832, 85722, 3.50849, 398.14900, 77979, 1.17883, 5223.69392, 75314, 2.53339, 5507.55324, 50526, 4.58293, 18849.22755, 49238, 4.20507, 775.52261, 35666, 2.91954, 0.06731, 31709, 5.84902, 11790.62909, 28413, 1.89869, 796.29801, 27104, 0.31489, 10977.07880, 24281, 0.34481, 5486.77784, 20616, 4.80647, 2544.31442, 20539, 1.86948, 5573.14280, 20226, 2.45768, 6069.77675, 15552, 0.83306, 213.29910, 13221, 3.41118, 2942.46342, 12618, 1.08303, 20.77540, 11513, 0.64545, 0.98032, 10285, 0.63600, 4694.00295, 10190, 0.97569, 15720.83878, 10172, 4.26680, 7.11355, 9921, 6.2099, 2146.1654, 9761, 0.6810, 155.4204, 8580, 5.9832, 161000.6857, 8513, 1.2987, 6275.9623, 8471, 3.6708, 71430.6956, 7964, 1.8079, 17260.1547, 7876, 3.0370, 12036.4607, 7465, 1.7551, 5088.6288, 7387, 3.5032, 3154.6871, 7355, 4.6793, 801.8209, 6963, 0.8330, 9437.7629, 6245, 3.9776, 8827.3903, 6115, 1.8184, 7084.8968, 5696, 2.7843, 6286.5990, 5612, 4.3869, 14143.4952, 5558, 3.4701, 6279.5527, 5199, 0.1891, 12139.5535, 5161, 1.3328, 1748.0164, 5115, 0.2831, 5856.4777, 4900, 0.4874, 1194.4470, 4104, 5.3682, 8429.2413, 4094, 2.3985, 19651.0485, 3920, 6.1683, 10447.3878, 3677, 6.0413, 10213.2855, 3660, 2.5696, 1059.3819, 3595, 1.7088, 2352.8662, 3557, 1.7760, 6812.7668, 3329, 0.5931, 17789.8456, 3041, 0.4429, 83996.8473, 3005, 2.7398, 1349.8674, 2535, 3.1647, 4690.4798, 2474, 0.2148, 3.5904, 2366, 0.4847, 8031.0923, 2357, 2.0653, 3340.6124, 2282, 5.2220, 4705.7323, 2189, 5.5559, 553.5694, 2142, 1.4256, 16730.4637, 2109, 4.1483, 951.7184, 2030, 0.3713, 283.8593, 1992, 5.2221, 12168.0027, 1986, 5.7747, 6309.3742, 1912, 3.8222, 23581.2582, 1889, 5.3863, 149854.4001, 1790, 2.2149, 13367.9726, 1748, 4.5605, 135.0651, 1622, 5.9884, 11769.8537, 1508, 4.1957, 6256.7775, 1442, 4.1932, 242.7286, 1435, 3.7236, 38.0277, 1397, 4.4014, 6681.2249, 1362, 1.8893, 7632.9433, 1250, 1.1305, 5.5229, 1205, 2.6223, 955.5997, 1200, 1.0035, 632.7837, 1129, 0.1774, 4164.3120, 1083, 0.3273, 103.0928, 1052, 0.9387, 11926.2544, 1050, 5.3591, 1592.5960, 1033, 6.1998, 6438.4962, 1001, 6.0291, 5746.2713, 980, 0.999, 11371.705, 980, 5.244, 27511.468, 938, 2.624, 5760.498, 923, 0.483, 522.577, 922, 4.571, 4292.331, 905, 5.337, 6386.169, 862, 4.165, 7058.598, 841, 3.299, 7234.794, 836, 4.539, 25132.303, 813, 6.112, 4732.031, 812, 6.271, 426.598, 801, 5.821, 28.449, 787, 0.996, 5643.179, 776, 2.957, 23013.540, 769, 3.121, 7238.676, 758, 3.974, 11499.656, 735, 4.386, 316.392, 731, 0.607, 11513.883, 719, 3.998, 74.782, 706, 0.323, 263.084, 676, 5.911, 90955.552, 663, 3.665, 17298.182, 653, 5.791, 18073.705, 630, 4.717, 6836.645, 615, 1.458, 233141.314, 612, 1.075, 19804.827, 596, 3.321, 6283.009, 596, 2.876, 6283.143, 555, 2.452, 12352.853, 541, 5.392, 419.485, 531, 0.382, 31441.678, 519, 4.065, 6208.294, 513, 2.361, 10973.556, 494, 5.737, 9917.697, 450, 3.272, 11015.106, 449, 3.653, 206.186, 447, 2.064, 7079.374, 435, 4.423, 5216.580, 421, 1.906, 245.832, 413, 0.921, 3738.761, 402, 0.840, 20.355, 387, 1.826, 11856.219, 379, 2.344, 3.881, 374, 2.954, 3128.389, 370, 5.031, 536.805, 365, 1.018, 16200.773, 365, 1.083, 88860.057, 352, 5.978, 3894.182, 352, 2.056, 244287.600, 351, 3.713, 6290.189, 340, 1.106, 14712.317, 339, 0.978, 8635.942, 339, 3.202, 5120.601, 333, 0.837, 6496.375, 325, 3.479, 6133.513, 316, 5.089, 21228.392, 316, 1.328, 10873.986, 309, 3.646, 10.637, 303, 1.802, 35371.887, 296, 3.397, 9225.539, 288, 6.026, 154717.610, 281, 2.585, 14314.168, 262, 3.856, 266.607, 262, 2.579, 22483.849, 257, 1.561, 23543.231, 255, 3.949, 1990.745, 251, 3.744, 10575.407, 240, 1.161, 10984.192, 238, 0.106, 7.046, 236, 4.272, 6040.347, 234, 3.577, 10969.965, 211, 3.714, 65147.620, 210, 0.754, 13521.751, 207, 4.228, 5650.292, 202, 0.814, 170.673, 201, 4.629, 6037.244, 200, 0.381, 6172.870, 199, 3.933, 6206.810, 199, 5.197, 6262.300, 197, 1.046, 18209.330, 195, 1.070, 5230.807, 195, 4.869, 36.028, 194, 4.313, 6244.943, 192, 1.229, 709.933, 192, 5.595, 6282.096, 192, 0.602, 6284.056, 189, 3.744, 23.878, 188, 1.904, 15.252, 188, 0.867, 22003.915, 182, 3.681, 15110.466, 181, 0.491, 1.484, 179, 3.222, 39302.097, 179, 1.259, 12559.038, + /*L1*/ 62833196674749, 0.000000000000, 0.000000000000, 20605886, 2.67823456, 6283.07584999, 430343, 2.635127, 12566.151700, 42526, 1.59047, 3.52312, 11926, 5.79557, 26.29832, 10898, 2.96618, 1577.34354, 9348, 2.5921, 18849.2275, 7212, 1.1385, 529.6910, 6777, 1.8747, 398.1490, 6733, 4.4092, 5507.5532, 5903, 2.8880, 5223.6939, 5598, 2.1747, 155.4204, 4541, 0.3980, 796.2980, 3637, 0.4662, 775.5226, 2896, 2.6471, 7.1135, 2084, 5.3414, 0.9803, 1910, 1.8463, 5486.7778, 1851, 4.9686, 213.2991, 1729, 2.9912, 6275.9623, 1623, 0.0322, 2544.3144, 1583, 1.4305, 2146.1654, 1462, 1.2053, 10977.0788, 1246, 2.8343, 1748.0164, 1188, 3.2580, 5088.6288, 1181, 5.2738, 1194.4470, 1151, 2.0750, 4694.0030, 1064, 0.7661, 553.5694, 997, 1.303, 6286.599, 972, 4.239, 1349.867, 945, 2.700, 242.729, 858, 5.645, 951.718, 758, 5.301, 2352.866, 639, 2.650, 9437.763, 610, 4.666, 4690.480, 583, 1.766, 1059.382, 531, 0.909, 3154.687, 522, 5.661, 71430.696, 520, 1.854, 801.821, 504, 1.425, 6438.496, 433, 0.241, 6812.767, 426, 0.774, 10447.388, 413, 5.240, 7084.897, 374, 2.001, 8031.092, 356, 2.429, 14143.495, 350, 4.800, 6279.553, 337, 0.888, 12036.461, 337, 3.862, 1592.596, 325, 3.400, 7632.943, 322, 0.616, 8429.241, 318, 3.188, 4705.732, 297, 6.070, 4292.331, 295, 1.431, 5746.271, 290, 2.325, 20.355, 275, 0.935, 5760.498, 270, 4.804, 7234.794, 253, 6.223, 6836.645, 228, 5.003, 17789.846, 225, 5.672, 11499.656, 215, 5.202, 11513.883, 208, 3.955, 10213.286, 208, 2.268, 522.577, 206, 2.224, 5856.478, 206, 2.550, 25132.303, 203, 0.910, 6256.778, 189, 0.532, 3340.612, 188, 4.735, 83996.847, 179, 1.474, 4164.312, 178, 3.025, 5.523, 177, 3.026, 5753.385, 159, 4.637, 3.286, 157, 6.124, 5216.580, 155, 3.077, 6681.225, 154, 4.200, 13367.973, 143, 1.191, 3894.182, 138, 3.093, 135.065, 136, 4.245, 426.598, 134, 5.765, 6040.347, 128, 3.085, 5643.179, 127, 2.092, 6290.189, 125, 3.077, 11926.254, 125, 3.445, 536.805, 114, 3.244, 12168.003, 112, 2.318, 16730.464, 111, 3.901, 11506.770, 111, 5.320, 23.878, 105, 3.750, 7860.419, 103, 2.447, 1990.745, 96, 0.82, 3.88, 96, 4.08, 6127.66, 91, 5.42, 206.19, 91, 0.42, 7079.37, 88, 5.17, 11790.63, 81, 0.34, 9917.70, 80, 3.89, 10973.56, 78, 2.40, 1589.07, 78, 2.58, 11371.70, 77, 3.98, 955.60, 77, 3.36, 36.03, 76, 1.30, 103.09, 75, 5.18, 10969.97, 75, 4.96, 6496.37, 73, 5.21, 38.03, 72, 2.65, 6309.37, 70, 5.61, 3738.76, 69, 2.60, 3496.03, 69, 0.39, 15.25, 69, 2.78, 20.78, 65, 1.13, 7058.60, 64, 4.28, 28.45, 61, 5.63, 10984.19, 60, 0.73, 419.48, 60, 5.28, 10575.41, 58, 5.55, 17298.18, 58, 3.19, 4732.03, + /*L2*/ 5291887, 0.0000000, 0.0000000, 871984, 1.072097, 6283.075850, 30913, 0.86729, 12566.15170, 2734, 0.0530, 3.5231, 1633, 5.1883, 26.2983, 1575, 3.6846, 155.4204, 954, 0.757, 18849.228, 894, 2.057, 77713.771, 695, 0.827, 775.523, 506, 4.663, 1577.344, 406, 1.031, 7.114, 381, 3.441, 5573.143, 346, 5.141, 796.298, 317, 6.053, 5507.553, 302, 1.192, 242.729, 289, 6.117, 529.691, 271, 0.306, 398.149, 254, 2.280, 553.569, 237, 4.381, 5223.694, 208, 3.754, 0.980, 168, 0.902, 951.718, 153, 5.759, 1349.867, 145, 4.364, 1748.016, 134, 3.721, 1194.447, 125, 2.948, 6438.496, 122, 2.973, 2146.165, 110, 1.271, 161000.686, 104, 0.604, 3154.687, 100, 5.986, 6286.599, 92, 4.80, 5088.63, 89, 5.23, 7084.90, 83, 3.31, 213.30, 76, 3.42, 5486.78, 71, 6.19, 4690.48, 68, 3.43, 4694.00, 65, 1.60, 2544.31, 64, 1.98, 801.82, 61, 2.48, 10977.08, 50, 1.44, 6836.65, 49, 2.34, 1592.60, 46, 1.31, 4292.33, 46, 3.81, 149854.40, 43, 0.04, 7234.79, 40, 4.94, 7632.94, 39, 1.57, 71430.70, 38, 3.17, 6309.37, 35, 0.99, 6040.35, 35, 0.67, 1059.38, 31, 3.18, 2352.87, 31, 3.55, 8031.09, 30, 1.92, 10447.39, 30, 2.52, 6127.66, 28, 4.42, 9437.76, 28, 2.71, 3894.18, 27, 0.67, 25132.30, 26, 5.27, 6812.77, 25, 0.55, 6279.55, 23, 1.38, 4705.73, 22, 0.64, 6256.78, 20, 6.07, 640.88, + /*L3*/ 28923, 5.84384, 6283.07585, 3496, 0.0000, 0.0000, 1682, 5.4877, 12566.1517, 296, 5.196, 155.420, 129, 4.722, 3.523, 71, 5.30, 18849.23, 64, 5.97, 242.73, 40, 3.79, 553.57, + /*L4*/ 11408, 3.14159, 0.00000, 772, 4.134, 6283.076, 77, 3.84, 12566.15, 42, 0.42, 155.42, + /*L5*/ 88, 3.14, 0.00, 17, 2.77, 6283.08, 5, 2.01, 155.42, 3, 2.21, 12566.15, + /*B0*/ 27962, 3.19870, 84334.66158, 10164, 5.42249, 5507.55324, 8045, 3.8801, 5223.6939, 4381, 3.7044, 2352.8662, 3193, 4.0003, 1577.3435, 2272, 3.9847, 1047.7473, 1814, 4.9837, 6283.0758, 1639, 3.5646, 5856.4777, 1444, 3.7028, 9437.7629, 1430, 3.4112, 10213.2855, 1125, 4.8282, 14143.4952, 1090, 2.0857, 6812.7668, 1037, 4.0566, 71092.8814, 971, 3.473, 4694.003, 915, 1.142, 6620.890, 878, 4.440, 5753.385, 837, 4.993, 7084.897, 770, 5.554, 167621.576, 719, 3.602, 529.691, 692, 4.326, 6275.962, 558, 4.410, 7860.419, 529, 2.484, 4705.732, 521, 6.250, 18073.705, + /*B1*/ 903, 3.897, 5507.553, 618, 1.730, 5223.694, 380, 5.244, 2352.866, + /*B2*/ 166, 1.627, 84334.662, + /*R0*/ 10001398880, 0.00000000000, 0.00000000000, 167069963, 3.098463508, 6283.075849991, 1395602, 3.0552461, 12566.1517000, 308372, 5.198467, 77713.771468, 162846, 1.173877, 5753.384885, 157557, 2.846852, 7860.419392, 92480, 5.45292, 11506.76977, 54244, 4.56409, 3930.20970, 47211, 3.66100, 5884.92685, 34598, 0.96369, 5507.55324, 32878, 5.89984, 5223.69392, 30678, 0.29867, 5573.14280, 24319, 4.27350, 11790.62909, 21183, 5.84715, 1577.34354, 18575, 5.02194, 10977.07880, 17484, 3.01194, 18849.22755, 10984, 5.05511, 5486.77784, 9832, 0.8868, 6069.7768, 8650, 5.6896, 15720.8388, 8583, 1.2708, 161000.6857, 6490, 0.2725, 17260.1547, 6292, 0.9218, 529.6910, 5706, 2.0137, 83996.8473, 5574, 5.2416, 71430.6956, 4938, 3.2450, 2544.3144, 4696, 2.5781, 775.5226, 4466, 5.5372, 9437.7629, 4252, 6.0111, 6275.9623, 3897, 5.3607, 4694.0030, 3825, 2.3926, 8827.3903, 3749, 0.8295, 19651.0485, 3696, 4.9011, 12139.5535, 3566, 1.6747, 12036.4607, 3454, 1.8427, 2942.4634, 3319, 0.2437, 7084.8968, 3192, 0.1837, 5088.6288, 3185, 1.7778, 398.1490, 2846, 1.2134, 6286.5990, 2779, 1.8993, 6279.5527, 2628, 4.5890, 10447.3878, 2460, 3.7866, 8429.2413, 2393, 4.9960, 5856.4777, 2359, 0.2687, 796.2980, 2329, 2.8078, 14143.4952, 2210, 1.9500, 3154.6871, 2035, 4.6527, 2146.1654, 1951, 5.3823, 2352.8662, 1883, 0.6731, 149854.4001, 1833, 2.2535, 23581.2582, 1796, 0.1987, 6812.7668, 1731, 6.1520, 16730.4637, 1717, 4.4332, 10213.2855, 1619, 5.2316, 17789.8456, 1381, 5.1896, 8031.0923, 1364, 3.6852, 4705.7323, 1314, 0.6529, 13367.9726, 1041, 4.3329, 11769.8537, 1017, 1.5939, 4690.4798, 998, 4.201, 6309.374, 966, 3.676, 27511.468, 874, 6.064, 1748.016, 779, 3.674, 12168.003, 771, 0.312, 7632.943, 756, 2.626, 6256.778, 746, 5.648, 11926.254, 693, 2.924, 6681.225, 680, 1.423, 23013.540, 674, 0.563, 3340.612, 663, 5.661, 11371.705, 659, 3.136, 801.821, 648, 2.650, 19804.827, 615, 3.029, 233141.314, 612, 5.134, 1194.447, 563, 4.341, 90955.552, 552, 2.091, 17298.182, 534, 5.100, 31441.678, 531, 2.407, 11499.656, 523, 4.624, 6438.496, 513, 5.324, 11513.883, 477, 0.256, 11856.219, 461, 1.722, 7234.794, 458, 3.766, 6386.169, 458, 4.466, 5746.271, 423, 1.055, 5760.498, 422, 1.557, 7238.676, 415, 2.599, 7058.598, 401, 3.030, 1059.382, 397, 1.201, 1349.867, 379, 4.907, 4164.312, 360, 5.707, 5643.179, 352, 3.626, 244287.600, 348, 0.761, 10973.556, 342, 3.001, 4292.331, 336, 4.546, 4732.031, 334, 3.138, 6836.645, 324, 4.164, 9917.697, 316, 1.691, 11015.106, 307, 0.238, 35371.887, 298, 1.306, 6283.143, 298, 1.750, 6283.009, 293, 5.738, 16200.773, 286, 5.928, 14712.317, 281, 3.515, 21228.392, 280, 5.663, 8635.942, 277, 0.513, 26.298, 268, 4.207, 18073.705, 266, 0.900, 12352.853, 260, 2.962, 25132.303, 255, 2.477, 6208.294, 242, 2.800, 709.933, 231, 1.054, 22483.849, 229, 1.070, 14314.168, 216, 1.314, 154717.610, 215, 6.038, 10873.986, 200, 0.561, 7079.374, 198, 2.614, 951.718, 197, 4.369, 167283.762, 186, 2.861, 5216.580, 183, 1.660, 39302.097, 183, 5.912, 3738.761, 175, 2.145, 6290.189, 173, 2.168, 10575.407, 171, 3.702, 1592.596, 171, 1.343, 3128.389, 164, 5.550, 6496.375, 164, 5.856, 10984.192, 161, 1.998, 10969.965, 161, 1.909, 6133.513, 157, 4.955, 25158.602, 154, 6.216, 23543.231, 153, 5.357, 13521.751, 150, 5.770, 18209.330, 150, 5.439, 155.420, 139, 1.778, 9225.539, 139, 1.626, 5120.601, 128, 2.460, 13916.019, 123, 0.717, 143571.324, 122, 2.654, 88860.057, 121, 4.414, 3894.182, 121, 1.192, 3.523, 120, 4.030, 553.569, 119, 1.513, 17654.781, 117, 3.117, 14945.316, 113, 2.698, 6040.347, 110, 3.085, 43232.307, 109, 0.998, 955.600, 108, 2.939, 17256.632, 107, 5.285, 65147.620, 103, 0.139, 11712.955, 103, 5.850, 213.299, 102, 3.046, 6037.244, 101, 2.842, 8662.240, 100, 3.626, 6262.300, 98, 2.36, 6206.81, 98, 5.11, 6172.87, 98, 2.00, 15110.47, 97, 2.67, 5650.29, 97, 2.75, 6244.94, 96, 4.02, 6282.10, 96, 5.31, 6284.06, 92, 0.10, 29088.81, 85, 3.26, 20426.57, 84, 2.60, 28766.92, 81, 3.58, 10177.26, 80, 5.81, 5230.81, 78, 2.53, 16496.36, 77, 4.06, 6127.66, 73, 0.04, 5481.25, 72, 5.96, 12559.04, 72, 5.92, 4136.91, 71, 5.49, 22003.91, 70, 3.41, 7.11, 69, 0.62, 11403.68, 69, 3.90, 1589.07, 69, 1.96, 12416.59, 69, 4.51, 426.60, 67, 1.61, 11087.29, 66, 4.50, 47162.52, 66, 5.08, 283.86, 66, 4.32, 16858.48, 65, 1.04, 6062.66, 64, 1.59, 18319.54, 63, 5.70, 45892.73, 63, 4.60, 66567.49, 63, 3.82, 13517.87, 62, 2.62, 11190.38, 61, 1.54, 33019.02, 60, 5.58, 10344.30, 60, 5.38, 316428.23, 60, 5.78, 632.78, 59, 6.12, 9623.69, 57, 0.16, 17267.27, 57, 3.86, 6076.89, 57, 1.98, 7668.64, 56, 4.78, 20199.09, 55, 4.56, 18875.53, 55, 3.51, 17253.04, 54, 3.07, 226858.24, 54, 4.83, 18422.63, 53, 5.02, 12132.44, 52, 3.63, 5333.90, 52, 0.97, 155427.54, 51, 3.36, 20597.24, 50, 0.99, 11609.86, 50, 2.21, 1990.75, 48, 1.62, 12146.67, 48, 1.17, 12569.67, 47, 4.62, 5436.99, 47, 1.81, 12562.63, 47, 0.59, 21954.16, 47, 0.76, 7342.46, 46, 0.27, 4590.91, 46, 3.77, 156137.48, 45, 5.66, 10454.50, 44, 5.84, 3496.03, 43, 0.24, 17996.03, 41, 5.93, 51092.73, 41, 4.21, 12592.45, 40, 5.14, 1551.05, 40, 5.28, 15671.08, 39, 3.69, 18052.93, 39, 4.94, 24356.78, 38, 2.72, 11933.37, 38, 5.23, 7477.52, 38, 4.99, 9779.11, 37, 3.70, 9388.01, 37, 4.44, 4535.06, 36, 2.16, 28237.23, 36, 2.54, 242.73, 36, 0.22, 5429.88, 35, 6.15, 19800.95, 35, 2.92, 36949.23, 34, 5.63, 2379.16, 34, 5.73, 16460.33, 34, 5.11, 5849.36, 33, 6.19, 6268.85, + /*R1*/ 10301861, 1.10748970, 6283.07584999, 172124, 1.064423, 12566.151700, 70222, 3.14159, 0.00000, 3235, 1.0217, 18849.2275, 3080, 2.8435, 5507.5532, 2497, 1.3191, 5223.6939, 1849, 1.4243, 1577.3435, 1008, 5.9138, 10977.0788, 865, 1.420, 6275.962, 863, 0.271, 5486.778, 507, 1.686, 5088.629, 499, 6.014, 6286.599, 467, 5.987, 529.691, 440, 0.518, 4694.003, 410, 1.084, 9437.763, 387, 4.750, 2544.314, 375, 5.071, 796.298, 352, 0.023, 83996.847, 344, 0.949, 71430.696, 341, 5.412, 775.523, 322, 6.156, 2146.165, 286, 5.484, 10447.388, 284, 3.420, 2352.866, 255, 6.132, 6438.496, 252, 0.243, 398.149, 243, 3.092, 4690.480, 225, 3.689, 7084.897, 220, 4.952, 6812.767, 219, 0.420, 8031.092, 209, 1.282, 1748.016, 193, 5.314, 8429.241, 185, 1.820, 7632.943, 175, 3.229, 6279.553, 173, 1.537, 4705.732, 158, 4.097, 11499.656, 158, 5.539, 3154.687, 150, 3.633, 11513.883, 148, 3.222, 7234.794, 147, 3.653, 1194.447, 144, 0.817, 14143.495, 135, 6.151, 5746.271, 134, 4.644, 6836.645, 128, 2.693, 1349.867, 123, 5.650, 5760.498, 118, 2.577, 13367.973, 113, 3.357, 17789.846, 110, 4.497, 4292.331, 108, 5.828, 12036.461, 102, 5.621, 6256.778, 99, 1.14, 1059.38, 98, 0.66, 5856.48, 93, 2.32, 10213.29, 92, 0.77, 16730.46, 88, 1.50, 11926.25, 86, 1.42, 5753.38, 85, 0.66, 155.42, 81, 1.64, 6681.22, 80, 4.11, 951.72, 66, 4.55, 5216.58, 65, 0.98, 25132.30, 64, 4.19, 6040.35, 64, 0.52, 6290.19, 63, 1.51, 5643.18, 59, 6.18, 4164.31, 57, 2.30, 10973.56, 55, 2.32, 11506.77, 55, 2.20, 1592.60, 55, 5.27, 3340.61, 54, 5.54, 553.57, 53, 5.04, 9917.70, 53, 0.92, 11371.70, 52, 3.98, 17298.18, 52, 3.60, 10969.97, 49, 5.91, 3894.18, 49, 2.51, 6127.66, 48, 1.67, 12168.00, 46, 0.31, 801.82, 42, 3.70, 10575.41, 42, 4.05, 10984.19, 40, 2.17, 7860.42, 40, 4.17, 26.30, 38, 5.82, 7058.60, 37, 3.39, 6496.37, 36, 1.08, 6309.37, 36, 5.34, 7079.37, 34, 3.62, 11790.63, 32, 0.32, 16200.77, 31, 4.24, 3738.76, 29, 4.55, 11856.22, 29, 1.26, 8635.94, 27, 3.45, 5884.93, 26, 5.08, 10177.26, 26, 5.38, 21228.39, 24, 2.26, 11712.96, 24, 1.05, 242.73, 24, 5.59, 6069.78, 23, 3.63, 6284.06, 23, 1.64, 4732.03, 22, 3.46, 213.30, 21, 1.05, 3496.03, 21, 3.92, 13916.02, 21, 4.01, 5230.81, 20, 5.16, 12352.85, 20, 0.69, 1990.75, 19, 2.73, 6062.66, 19, 5.01, 11015.11, 18, 6.04, 6283.01, 18, 2.85, 7238.68, 18, 5.60, 6283.14, 18, 5.16, 17253.04, 18, 2.54, 14314.17, 17, 1.58, 7.11, 17, 0.98, 3930.21, 17, 4.75, 17267.27, 16, 2.19, 6076.89, 16, 2.19, 18073.70, 16, 6.12, 3.52, 16, 4.61, 9623.69, 16, 3.40, 16496.36, 15, 0.19, 9779.11, 15, 5.30, 13517.87, 15, 4.26, 3128.39, 15, 0.81, 709.93, 14, 0.50, 25158.60, 14, 4.38, 4136.91, 13, 0.98, 65147.62, 13, 3.31, 154717.61, 13, 2.11, 1589.07, 13, 1.92, 22483.85, 12, 6.03, 9225.54, 12, 1.53, 12559.04, 12, 5.82, 6282.10, 12, 5.61, 5642.20, 12, 2.38, 167283.76, 12, 0.39, 12132.44, 12, 3.98, 4686.89, 12, 5.81, 12569.67, 12, 0.56, 5849.36, 11, 0.45, 6172.87, 11, 5.80, 16858.48, 11, 6.22, 12146.67, 11, 2.27, 5429.88, + /*R2*/ 435939, 5.784551, 6283.075850, 12363, 5.57935, 12566.15170, 1234, 3.1416, 0.0000, 879, 3.628, 77713.771, 569, 1.870, 5573.143, 330, 5.470, 18849.228, 147, 4.480, 5507.553, 110, 2.842, 161000.686, 101, 2.815, 5223.694, 85, 3.11, 1577.34, 65, 5.47, 775.52, 61, 1.38, 6438.50, 50, 4.42, 6286.60, 47, 3.66, 7084.90, 46, 5.39, 149854.40, 42, 0.90, 10977.08, 40, 3.20, 5088.63, 35, 1.81, 5486.78, 32, 5.35, 3154.69, 30, 3.52, 796.30, 29, 4.62, 4690.48, 28, 1.84, 4694.00, 27, 3.14, 71430.70, 27, 6.17, 6836.65, 26, 1.42, 2146.17, 25, 2.81, 1748.02, 24, 2.18, 155.42, 23, 4.76, 7234.79, 21, 3.38, 7632.94, 21, 0.22, 4705.73, 20, 4.22, 1349.87, 20, 2.01, 1194.45, 20, 4.58, 529.69, 19, 1.59, 6309.37, 18, 5.70, 6040.35, 18, 6.03, 4292.33, 17, 2.90, 9437.76, 17, 2.00, 8031.09, 17, 5.78, 83996.85, 16, 0.05, 2544.31, 15, 0.95, 6127.66, 14, 0.36, 10447.39, 14, 1.48, 2352.87, 13, 0.77, 553.57, 13, 5.48, 951.72, 13, 5.27, 6279.55, 13, 3.76, 6812.77, 11, 5.41, 6256.78, 10, 0.68, 1592.60, 10, 4.95, 398.15, 10, 1.15, 3894.18, 10, 5.20, 244287.60, 10, 1.94, 11856.22, 9, 5.39, 25132.30, 8, 6.18, 1059.38, 8, 0.69, 8429.24, 8, 5.85, 242.73, 7, 5.26, 14143.50, 7, 0.52, 801.82, 6, 2.24, 8635.94, 6, 4.00, 13367.97, 6, 2.77, 90955.55, 6, 5.17, 7058.60, 5, 1.46, 233141.31, 5, 4.13, 7860.42, 5, 3.91, 26.30, 5, 3.89, 12036.46, 5, 5.58, 6290.19, 5, 5.54, 1990.75, 5, 0.83, 11506.77, 5, 6.22, 6681.22, 4, 5.26, 10575.41, 4, 1.91, 7477.52, 4, 0.43, 10213.29, 4, 1.09, 709.93, 4, 5.09, 11015.11, 4, 4.22, 88860.06, 4, 3.57, 7079.37, 4, 1.98, 6284.06, 4, 3.93, 10973.56, 4, 6.18, 9917.70, 4, 0.36, 10177.26, 4, 2.75, 3738.76, 4, 3.33, 5643.18, 4, 5.36, 25158.60, + /*R3*/ 14459, 4.27319, 6283.07585, 673, 3.917, 12566.152, 77, 0.00, 0.00, 25, 3.73, 18849.23, 4, 2.80, 6286.60, + /*R4*/ 386, 2.564, 6283.076, 31, 2.27, 12566.15, 5, 3.44, 5573.14, 2, 2.05, 18849.23, 1, 2.06, 77713.77, 1, 4.41, 161000.69, 1, 3.82, 149854.40, 1, 4.08, 6127.66, 1, 5.26, 6438.50, + /*R5*/ 9, 1.22, 6283.08, 1, 0.66, 12566.15 }; + +//Dmer精度:J2000+-4千年 黄经0.2角秒 黄纬0.2角秒 距离0.2AU/10^6 +static constexpr long double XL0_1[] = { + 1000000000,//A的倍率 + 20, 443, 710, 761, 791, 818, 824, 1043, 1106, 1142, 1169, 1190, 1196, 1550, 1742, 1781, 1808, 1823, 1823,//位置索引表 + /*L0*/ 4402507101, 0.0000000000, 0.0000000000, 409894150, 1.483020342, 26087.903141574, 50462942, 4.47785490, 52175.80628315, 8553468, 1.1652032, 78263.7094247, 1655904, 4.1196916, 104351.6125663, 345619, 0.779308, 130439.515708, 75835, 3.71348, 156527.41885, 35597, 1.51203, 1109.37855, 18035, 4.10333, 5661.33205, 17260, 0.35832, 182615.32199, 15899, 2.99510, 25028.52121, 13647, 4.59918, 27197.28169, 10173, 0.88031, 31749.23519, 7142, 1.5414, 24978.5246, 6438, 5.3027, 21535.9496, 4511, 6.0499, 51116.4244, 4042, 3.2823, 208703.2251, 3524, 5.2416, 20426.5711, 3452, 2.7921, 15874.6176, 3433, 5.7653, 955.5997, 3392, 5.8633, 25558.2122, 3253, 1.3367, 53285.1848, 2729, 2.4945, 529.6910, 2643, 3.9171, 57837.1383, 2596, 0.9873, 4551.9535, 2388, 0.1134, 1059.3819, 2348, 0.2667, 11322.6641, 2166, 0.6599, 13521.7514, 2090, 2.0918, 47623.8528, 1834, 2.6288, 27043.5029, 1816, 2.4341, 25661.3050, 1760, 4.5364, 51066.4277, 1726, 2.4520, 24498.8302, 1423, 3.3600, 37410.5672, 1379, 0.2910, 10213.2855, 1252, 3.7208, 39609.6546, 1182, 2.7815, 77204.3275, 1064, 4.2057, 19804.8273, 969, 6.204, 234791.128, 900, 5.852, 41962.521, 883, 5.413, 26617.594, 868, 2.642, 51646.115, 867, 1.960, 46514.474, 850, 4.331, 79373.088, 697, 3.572, 25132.303, 692, 4.194, 19.670, 685, 0.634, 83925.041, 648, 0.048, 33326.579, 635, 3.147, 7238.676, 595, 2.747, 16983.996, 565, 5.119, 73711.756, 554, 4.053, 30639.857, 544, 3.143, 27147.285, 515, 5.478, 50586.733, 496, 3.990, 6770.711, 480, 5.493, 51749.208, 476, 5.497, 3.881, 447, 1.224, 77154.331, 419, 5.193, 6283.076, 418, 5.642, 53131.406, 380, 2.431, 12566.152, 360, 1.424, 2218.757, 356, 0.814, 32858.614, 354, 3.370, 36301.189, 340, 0.475, 65697.558, 340, 2.786, 14765.239, 308, 5.770, 103292.231, 306, 5.840, 43071.899, 295, 0.698, 213.299, 285, 0.650, 426.598, 275, 0.980, 45892.730, 271, 0.085, 63498.470, 268, 1.061, 3442.575, 263, 0.648, 1589.073, 262, 5.242, 22645.328, 243, 4.400, 7.114, 237, 2.842, 260879.031, 229, 2.585, 68050.424, 224, 1.025, 105460.991, 223, 5.653, 77734.018, 223, 2.179, 52705.497, 222, 3.224, 25448.006, 220, 4.934, 72602.377, 186, 4.527, 28306.660, 178, 3.612, 110012.945, 176, 4.717, 25874.604, 172, 0.284, 51220.207, 172, 3.261, 153.779, 149, 1.835, 99799.659, 144, 0.966, 26107.573, 144, 1.910, 23969.139, 142, 5.142, 26068.233, 142, 6.124, 53235.188, 140, 2.302, 76674.637, 134, 4.518, 26080.790, 134, 0.766, 56727.760, 124, 2.223, 77837.111, 120, 6.205, 18849.228, 116, 2.385, 79219.309, 115, 4.178, 103242.234, 112, 2.048, 32370.979, 111, 3.783, 26301.202, 100, 2.046, 48733.231, 98, 2.27, 26091.78, 97, 3.84, 26084.02, 97, 2.99, 59414.48, 97, 5.78, 25938.34, 94, 5.44, 38654.05, 93, 4.03, 467.96, 90, 6.23, 25021.41, 90, 3.48, 91785.46, 90, 0.11, 62389.09, 89, 2.85, 25035.63, 83, 5.34, 19317.19, 82, 5.78, 40853.14, 81, 1.12, 26095.02, 80, 2.46, 129380.13, 76, 0.18, 12432.04, 74, 4.71, 6.63, 70, 3.99, 71980.63, 70, 1.63, 23869.15, 66, 3.66, 26514.50, 61, 3.67, 27676.98, 60, 0.00, 51535.91, 59, 3.99, 131548.89, 59, 4.12, 29530.48, 59, 5.57, 94138.33, 59, 5.76, 286966.93, 59, 6.13, 26011.64, 59, 2.14, 20760.43, 58, 2.35, 103821.92, 58, 4.45, 19406.68, 57, 3.02, 89586.37, 57, 5.18, 78793.40, 57, 1.61, 98690.28, 52, 3.29, 38519.95, 51, 3.78, 58946.52, 46, 0.29, 136100.85, 45, 1.50, 51962.51, 45, 4.89, 50057.04, 44, 3.25, 77308.11, + /*L1*/ 26088147062227, 0.000000000000, 0.000000000000, 11260078, 6.21703971, 26087.90314157, 3034714, 3.0556547, 52175.8062831, 805385, 6.104547, 78263.709425, 212450, 2.835319, 104351.612566, 55921, 5.82676, 130439.51571, 14722, 2.51845, 156527.41885, 3883, 5.4804, 182615.3220, 3522, 3.0524, 1109.3786, 1027, 2.1488, 208703.2251, 935, 6.118, 27197.282, 906, 0.000, 24978.525, 519, 5.621, 5661.332, 444, 4.573, 25028.521, 281, 3.042, 51066.428, 273, 5.092, 234791.128, 220, 0.865, 955.600, 204, 3.715, 20426.571, 202, 0.519, 21535.950, 175, 5.727, 4551.953, 167, 1.351, 529.691, 154, 5.743, 19.670, 153, 1.792, 11322.664, 140, 3.594, 24498.830, 128, 2.696, 53285.185, 126, 3.895, 3.881, 126, 4.705, 1059.382, 86, 6.06, 77154.33, 80, 3.93, 27043.50, 80, 4.18, 26617.59, 79, 0.50, 46514.47, 77, 2.48, 57837.14, 73, 1.75, 260879.03, 72, 2.98, 2218.76, 68, 2.77, 7.11, 66, 5.53, 6770.71, 64, 2.14, 25132.30, 59, 2.20, 13521.75, 58, 4.28, 16984.00, 50, 3.94, 25661.30, 50, 2.48, 30639.86, 49, 4.85, 37410.57, 46, 0.82, 25558.21, 46, 1.56, 27147.29, 45, 5.79, 3442.57, 44, 4.94, 213.30, 43, 5.09, 10213.29, 42, 5.54, 83925.04, 37, 1.40, 77204.33, 36, 2.34, 32858.61, 35, 3.59, 26068.23, 34, 0.50, 22645.33, 33, 5.23, 25448.01, 32, 1.26, 14765.24, 31, 6.21, 26080.79, 31, 6.07, 28306.66, 30, 4.45, 7238.68, 30, 0.14, 50586.73, 29, 1.64, 25021.41, 29, 0.67, 26091.78, 28, 2.51, 26107.57, 28, 3.54, 72602.38, 27, 5.64, 1589.07, 27, 0.88, 52705.50, 26, 2.78, 103242.23, 25, 5.80, 26095.02, 25, 4.35, 41962.52, 24, 1.16, 25035.63, 23, 5.44, 26084.02, 23, 1.85, 36301.19, 21, 5.16, 51220.21, 21, 1.07, 43071.90, 20, 2.96, 23969.14, 20, 4.44, 103292.23, 20, 0.84, 12566.15, 20, 4.68, 286966.93, 18, 1.81, 26301.20, 18, 5.18, 426.60, 17, 2.29, 110012.94, 17, 4.63, 53235.19, 17, 1.26, 33326.58, 16, 5.53, 56727.76, 16, 0.08, 23869.15, 16, 4.66, 79373.09, 16, 3.76, 73711.76, 14, 1.14, 68050.42, 14, 1.45, 51646.12, 13, 3.80, 19317.19, 13, 1.73, 12432.04, + /*L2*/ 530498, 0.000000, 0.000000, 169037, 4.690723, 26087.903142, 73967, 1.34736, 52175.80628, 30183, 4.45644, 78263.70942, 11074, 1.26227, 104351.61257, 3782, 4.3200, 130439.5157, 1230, 1.0687, 156527.4188, 387, 4.080, 182615.322, 149, 4.633, 1109.379, 119, 0.792, 208703.225, 52, 4.72, 24978.52, 36, 3.77, 234791.13, 26, 1.44, 27197.28, 20, 1.50, 51066.43, 11, 0.46, 260879.03, 10, 1.80, 955.60, 8, 4.54, 77154.33, + /*L3*/ 1881, 0.0347, 52175.8063, 1422, 3.1251, 26087.9031, 969, 3.004, 78263.709, 437, 6.019, 104351.613, 354, 0.000, 0.000, 180, 2.775, 130439.516, 70, 5.82, 156527.42, 26, 2.57, 182615.32, 9, 5.59, 208703.23, 3, 2.32, 234791.13, + /*L4*/ 1141, 3.1416, 0.0000, 32, 2.03, 26087.90, 19, 1.42, 78263.71, 17, 4.50, 52175.81, 12, 4.50, 104351.61, 6, 1.27, 130439.52, 3, 4.31, 156527.42, 1, 1.06, 182615.32, 1, 4.09, 208703.23, + /*L5*/ 9, 3.14, 0.00, 1, 3.38, 52175.81, + /*B0*/ 117375290, 1.983574988, 26087.903141574, 23880770, 5.03738960, 52175.80628315, 12228395, 3.14159265, 0.00000000, 5432518, 1.7964436, 78263.7094247, 1297788, 4.8323250, 104351.6125663, 318669, 1.580885, 130439.515708, 79633, 4.60972, 156527.41885, 20142, 1.35324, 182615.32199, 5140, 4.3784, 208703.2251, 2086, 2.0202, 24978.5246, 2077, 4.9177, 27197.2817, 1320, 1.1191, 234791.1283, 1214, 1.8127, 53285.1848, 1005, 5.6568, 20426.5711, 992, 0.094, 51116.424, 946, 1.242, 31749.235, 916, 2.282, 25028.521, 843, 5.085, 51066.428, 788, 4.407, 57837.138, 777, 0.526, 1059.382, 499, 3.498, 5661.332, 465, 3.237, 77204.327, 448, 4.878, 79373.088, 408, 2.466, 46514.474, 374, 4.458, 4551.953, 359, 1.091, 1109.379, 341, 4.142, 260879.031, 320, 1.185, 83925.041, 318, 2.415, 47623.853, 310, 3.503, 21535.950, 287, 1.848, 77154.331, 258, 2.776, 27043.503, 252, 3.591, 27147.285, 202, 3.068, 51646.115, 201, 4.066, 25132.303, 186, 5.584, 73711.756, 170, 6.137, 41962.521, 170, 0.028, 103292.231, 158, 3.796, 529.691, 156, 6.077, 53131.406, 150, 1.647, 105460.991, 142, 0.331, 10213.286, 140, 5.528, 72602.377, 130, 3.480, 37410.567, 129, 4.817, 30639.857, 124, 4.051, 39609.655, 123, 3.166, 14765.239, 113, 0.113, 13521.751, 112, 0.557, 63498.470, 110, 5.797, 51749.208, 110, 4.232, 110012.945, 107, 1.537, 25661.305, 105, 5.830, 50586.733, 102, 2.879, 12566.152, 99, 0.95, 65697.56, 98, 1.66, 24498.83, 94, 1.82, 15874.62, 92, 6.16, 77734.02, 91, 4.89, 103242.23, 90, 1.04, 426.60, 89, 0.40, 53235.19, 88, 0.88, 286966.93, 88, 5.81, 11322.66, 87, 3.04, 68050.42, 85, 1.05, 1589.07, 83, 5.27, 25558.21, 82, 0.84, 51220.21, 76, 3.44, 36301.19, 73, 2.37, 99799.66, 71, 5.74, 26617.59, 66, 2.67, 52705.50, 58, 6.25, 33326.58, 57, 2.87, 79219.31, + /*B1*/ 4291514, 3.5016978, 26087.9031416, 1462337, 3.1415927, 0.0000000, 226753, 0.015154, 52175.806283, 108950, 0.485402, 78263.709425, 63535, 3.42944, 104351.61257, 24957, 0.16051, 130439.51571, 8596, 3.1845, 156527.4188, 2775, 6.2102, 182615.3220, 862, 2.952, 208703.225, 277, 0.291, 27197.282, 261, 5.977, 234791.128, 128, 3.377, 53285.185, 127, 0.538, 24978.525, 78, 2.72, 260879.03, 75, 3.58, 51066.43, 62, 2.92, 31749.24, 55, 1.97, 51116.42, 35, 0.11, 79373.09, 34, 0.35, 77154.33, 29, 5.95, 57837.14, 27, 0.99, 25028.52, + /*B2*/ 118309, 4.790656, 26087.903142, 19135, 0.00000, 0.00000, 10448, 1.21217, 52175.80628, 2662, 4.4342, 78263.7094, 1703, 1.6226, 104351.6126, 963, 4.800, 130439.516, 447, 1.608, 156527.419, 183, 4.669, 182615.322, 69, 1.43, 208703.23, 25, 4.47, 234791.13, 17, 1.83, 27197.28, 9, 1.23, 260879.03, + /*B3*/ 2354, 0.3539, 26087.9031, 1605, 0.0000, 0.0000, 189, 4.363, 52175.806, 64, 2.51, 78263.71, 46, 6.14, 104351.61, 31, 3.12, 130439.52, 17, 6.27, 156527.42, 9, 3.08, 182615.32, 4, 6.15, 208703.23, + /*B4*/ 43, 1.75, 26087.90, 10, 3.14, 0.00, 4, 4.03, 52175.81, 3, 0.21, 78263.71, 1, 3.75, 104351.61, 1, 1.18, 130439.52, 1, 4.55, 156527.42, + /*B5*/ 1, 3.95, 26087.90, 1, 3.14, 0.00, + /*R0*/ 395282717, 0.000000000, 0.000000000, 78341318, 6.19233723, 26087.90314157, 7955256, 2.9598969, 52175.8062831, 1212818, 6.0106415, 78263.7094247, 219220, 2.778201, 104351.612566, 43541, 5.82895, 130439.51571, 9182, 2.5965, 156527.4188, 2900, 1.4244, 25028.5212, 2600, 3.0282, 27197.2817, 2019, 5.6473, 182615.3220, 2015, 5.5923, 31749.2352, 1420, 6.2526, 24978.5246, 1001, 3.7344, 21535.9496, 776, 3.670, 20426.571, 755, 4.474, 51116.424, 668, 2.525, 5661.332, 633, 4.299, 25558.212, 630, 4.766, 1059.382, 483, 6.068, 53285.185, 457, 2.415, 208703.225, 442, 1.220, 15874.618, 408, 2.359, 57837.138, 372, 0.517, 47623.853, 352, 1.059, 27043.503, 339, 0.864, 25661.305, 309, 0.884, 24498.830, 301, 1.795, 37410.567, 284, 3.021, 51066.428, 261, 2.150, 39609.655, 213, 5.369, 13521.751, 194, 4.984, 10213.286, 187, 4.965, 11322.664, 171, 1.241, 77204.327, 169, 3.888, 26617.594, 163, 2.633, 19804.827, 151, 0.445, 46514.474, 150, 4.282, 41962.521, 140, 4.771, 33326.579, 139, 1.626, 27147.285, 139, 2.000, 25132.303, 134, 1.077, 51646.115, 128, 6.064, 1109.379, 128, 2.076, 529.691, 121, 2.850, 79373.088, 119, 2.365, 4551.953, 106, 5.466, 234791.128, 95, 0.84, 12566.15, 94, 5.41, 83925.04, 91, 1.21, 14765.24, 89, 3.88, 50586.73, 85, 3.57, 73711.76, 77, 3.92, 51749.21, 75, 2.45, 30639.86, 75, 5.53, 32858.61, 72, 1.17, 16984.00, 71, 5.33, 426.60, 69, 5.31, 1589.07, 69, 1.82, 36301.19, 66, 4.28, 43071.90, 65, 6.07, 77154.33, 59, 4.07, 53131.41, 54, 5.20, 65697.56, 52, 3.57, 6283.08, 44, 5.69, 45892.73, 41, 1.65, 25448.01, 41, 3.68, 22645.33, 41, 4.29, 103292.23, 36, 2.96, 28306.66, 34, 0.65, 52705.50, 34, 3.49, 72602.38, 33, 3.14, 25874.60, 33, 1.03, 68050.42, 31, 4.13, 77734.02, 30, 5.91, 105460.99, 28, 4.63, 18849.23, 28, 5.05, 51220.21, 28, 5.68, 26107.57, 27, 4.68, 53235.19, 27, 4.75, 63498.47, 27, 3.57, 26068.23, 26, 2.95, 26080.79, 25, 0.35, 23969.14, 25, 2.23, 260879.03, 23, 0.50, 32370.98, 23, 2.18, 110012.94, 21, 0.85, 76674.64, 21, 2.19, 26301.20, 20, 0.34, 99799.66, 20, 0.47, 48733.23, 20, 3.77, 19317.19, 20, 1.37, 7238.68, 19, 2.37, 6770.71, 19, 0.69, 26091.78, 19, 3.93, 38654.05, 19, 2.27, 26084.02, 18, 4.21, 25938.34, 18, 0.92, 79219.31, 18, 5.51, 56727.76, 17, 0.68, 77837.11, 17, 4.29, 40853.14, 17, 2.15, 26514.50, 17, 4.98, 9103.91, 16, 4.66, 25021.41, 16, 1.28, 25035.63, 16, 5.85, 26095.02, 16, 2.84, 103242.23, 15, 1.55, 955.60, 15, 2.16, 27676.98, 14, 0.06, 23869.15, 14, 4.85, 62389.09, 12, 1.97, 91785.46, 12, 1.73, 38519.95, 11, 4.56, 26011.64, 10, 2.78, 213.30, 10, 1.06, 129380.13, 10, 2.44, 71980.63, 10, 4.71, 51535.91, 10, 2.54, 29530.48, + /*R1*/ 2173477, 4.6561716, 26087.9031416, 441418, 1.423855, 52175.806283, 100945, 4.474663, 78263.709425, 24328, 1.24226, 104351.61257, 16244, 0.00000, 0.00000, 6040, 4.2930, 130439.5157, 1529, 1.0606, 156527.4188, 392, 4.111, 182615.322, 180, 4.712, 24978.525, 178, 4.544, 27197.282, 102, 0.879, 208703.225, 81, 3.01, 25028.52, 44, 2.14, 20426.57, 44, 1.48, 51066.43, 35, 3.21, 1059.38, 31, 5.24, 21535.95, 27, 3.93, 234791.13, 25, 2.03, 24498.83, 20, 1.24, 53285.18, 20, 4.05, 5661.33, 15, 2.62, 26617.59, 15, 2.36, 27043.50, 14, 1.38, 1109.38, 13, 5.19, 46514.47, 13, 0.56, 25132.30, 12, 0.21, 11322.66, 12, 4.53, 77154.33, 11, 0.86, 57837.14, 11, 6.24, 27147.29, 10, 3.28, 37410.57, 9, 2.37, 25661.30, 9, 5.55, 25558.21, 8, 5.96, 14765.24, 7, 0.78, 32858.61, 7, 4.07, 1589.07, 7, 2.71, 16984.00, 7, 0.93, 30639.86, 7, 0.70, 260879.03, 7, 2.02, 26068.23, 6, 0.86, 4551.95, 6, 3.66, 25448.01, 6, 4.50, 28306.66, 6, 4.65, 26080.79, 6, 3.50, 10213.29, 6, 0.63, 13521.75, 5, 5.38, 26091.78, 5, 0.94, 26107.57, 5, 5.22, 22645.33, 5, 0.06, 25021.41, 5, 3.89, 83925.04, 5, 4.84, 50586.73, 5, 5.55, 12566.15, 5, 4.24, 26095.02, 5, 6.01, 77204.33, 5, 0.73, 529.69, 4, 3.87, 26084.02, 4, 5.87, 25035.63, 4, 5.79, 43071.90, 4, 0.26, 36301.19, 4, 2.78, 41962.52, 4, 5.60, 52705.50, 4, 3.82, 426.60, 4, 1.96, 72602.38, 4, 6.00, 33326.58, + /*R2*/ 31179, 3.08232, 26087.90314, 12454, 6.15183, 52175.80628, 4248, 2.9258, 78263.7094, 1361, 5.9798, 104351.6126, 422, 2.749, 130439.516, 218, 3.142, 0.000, 128, 5.801, 156527.419, 38, 2.57, 182615.32, 11, 5.62, 208703.23, 10, 3.15, 24978.52, 5, 6.14, 27197.28, 3, 2.39, 234791.13, 3, 6.21, 51066.43, + /*R3*/ 327, 1.680, 26087.903, 242, 4.634, 52175.806, 121, 1.390, 78263.709, 51, 4.44, 104351.61, 20, 1.21, 130439.52, 15, 3.14, 0.00, 7, 4.26, 156527.42, 3, 1.03, 182615.32, 1, 4.08, 208703.23, + /*R4*/ 4, 0.37, 26087.90, 4, 3.19, 52175.81, 3, 6.17, 78263.71, 1, 2.92, 104351.61, 1, 5.96, 130439.52 }; + +//Dven精度:J2000+-4千年 黄经0.2角秒 黄纬0.2角秒 距离0.2AU/10^6 +static constexpr long double XL0_2[] = { + 1000000000,//A的倍率 + 20, 257, 374, 425, 437, 449, 458, 566, 629, 641, 653, 665, 668, 929, 1040, 1082, 1091, 1094, 1094,//位置索引表 + /*L0*/ 3176146668, 0.0000000000, 0.0000000000, 13539684, 5.59313320, 10213.28554621, 898916, 5.306500, 20426.571092, 54772, 4.41631, 7860.41939, 34557, 2.69964, 11790.62909, 23721, 2.99378, 3930.20970, 16641, 4.25019, 1577.34354, 14383, 4.15745, 9683.59458, 13171, 5.18668, 26.29832, 12005, 6.15357, 30639.85664, 7693, 0.8163, 9437.7629, 7614, 1.9501, 529.6910, 7077, 1.0647, 775.5226, 5848, 3.9984, 191.4483, 4999, 4.1234, 15720.8388, 4295, 3.5864, 19367.1892, 3270, 5.6774, 5507.5532, 3262, 4.5906, 10404.7338, 2319, 3.1625, 9153.9036, 1797, 4.6534, 1109.3786, 1555, 5.5704, 19651.0485, 1283, 4.2260, 20.7754, 1279, 0.9621, 5661.3320, 1055, 1.5372, 801.8209, 991, 0.833, 213.299, 988, 5.394, 13367.973, 880, 3.889, 9999.986, 857, 0.356, 3154.687, 821, 3.216, 18837.498, 716, 0.111, 11015.106, 702, 0.675, 23581.258, 561, 4.240, 7.114, 508, 0.245, 11322.664, 461, 5.316, 18073.705, 446, 6.063, 40853.142, 426, 1.800, 7084.897, 426, 5.329, 2352.866, 412, 0.362, 382.897, 357, 2.704, 10206.172, 339, 2.023, 6283.076, 333, 2.100, 27511.468, 302, 4.942, 13745.346, 299, 4.022, 10239.584, 293, 3.514, 283.859, 291, 3.592, 22003.915, 285, 2.224, 1059.382, 263, 0.541, 17298.182, 244, 2.702, 8624.213, 243, 4.278, 5.523, 237, 4.829, 6872.673, 205, 0.585, 38.028, 203, 3.795, 14143.495, 191, 6.120, 29050.784, 190, 4.138, 4551.953, 183, 3.047, 19999.973, 171, 3.522, 31441.678, 159, 1.501, 8635.942, 137, 4.413, 3532.061, 118, 1.913, 21228.392, 116, 5.810, 19896.880, 110, 2.584, 9786.687, 110, 2.846, 18307.807, 106, 0.854, 10596.182, 101, 2.343, 10742.977, 99, 1.09, 7064.12, 94, 4.95, 35371.89, 92, 5.52, 12566.15, 89, 1.97, 10186.99, 82, 1.92, 15.25, 70, 1.00, 632.78, 68, 4.40, 8662.24, 67, 1.55, 14945.32, 64, 2.18, 10988.81, 63, 0.36, 103.09, 60, 5.05, 245.83, 60, 2.97, 4732.03, 58, 1.93, 3340.61, 56, 0.49, 522.58, 55, 3.37, 25158.60, + /*L1*/ 10213529430529, 0.000000000000, 0.000000000000, 957077, 2.464244, 10213.285546, 144450, 0.516246, 20426.571092, 2134, 1.7955, 30639.8566, 1739, 2.6554, 26.2983, 1517, 6.1064, 1577.3435, 822, 5.702, 191.448, 697, 2.681, 9437.763, 524, 3.600, 775.523, 383, 1.034, 529.691, 296, 1.251, 5507.553, 251, 6.107, 10404.734, 178, 6.194, 1109.379, 165, 2.643, 7.114, 142, 5.451, 9153.904, 126, 1.245, 40853.142, 126, 1.881, 382.897, 116, 4.976, 213.299, 89, 0.95, 13367.97, 74, 4.39, 10206.17, 67, 5.06, 801.82, 66, 2.28, 2352.87, 63, 4.08, 3154.69, 49, 3.45, 11015.11, 43, 0.08, 6283.08, 41, 4.12, 18837.50, 37, 2.48, 5661.33, 36, 1.48, 1059.38, 35, 6.20, 5.52, 34, 1.77, 11322.66, 30, 2.24, 18073.70, 30, 0.39, 15.25, 30, 5.35, 7084.90, 28, 1.46, 10239.58, 26, 0.35, 22003.91, 24, 2.36, 10596.18, 23, 2.37, 17298.18, 22, 2.08, 8635.94, 21, 4.47, 8624.21, + /*L2*/ 541271, 0.000000, 0.000000, 38915, 0.34514, 10213.28555, 13379, 2.02011, 20426.57109, 238, 2.046, 26.298, 193, 3.535, 30639.857, 100, 3.971, 775.523, 70, 1.52, 1577.34, 60, 1.00, 191.45, 32, 4.36, 9437.76, 21, 2.66, 40853.14, 19, 3.39, 382.90, 15, 6.05, 529.69, 13, 2.95, 5507.55, 12, 3.73, 3154.69, 10, 3.53, 11015.11, 10, 1.41, 10404.73, 10, 5.11, 801.82, + /*L3*/ 1357, 4.8039, 10213.2855, 778, 3.669, 20426.571, 260, 0.000, 0.000, 12, 5.32, 30639.86, + /*L4*/ 1140, 3.1416, 0.0000, 32, 5.21, 20426.57, 17, 2.51, 10213.29, 1, 0.71, 30639.86, + /*L5*/ 9, 3.14, 0.00, 1, 1.91, 10213.29, 1, 0.55, 20426.57, + /*B0*/ 59236385, 0.26702776, 10213.28554621, 401080, 1.147372, 20426.571092, 328149, 3.141593, 0.000000, 10114, 1.08946, 30639.85664, 1495, 6.2539, 18073.7049, 1378, 0.8602, 1577.3435, 1300, 3.6715, 9437.7629, 1195, 3.7047, 2352.8662, 1080, 4.5390, 22003.9146, 920, 1.540, 9153.904, 530, 2.281, 5507.553, 456, 0.723, 10239.584, 435, 6.140, 11790.629, 417, 5.991, 19896.880, 396, 3.868, 8635.942, 392, 3.950, 529.691, 389, 2.934, 10186.987, 333, 4.832, 14143.495, 237, 2.906, 10988.808, 235, 2.008, 13367.973, 218, 2.697, 19651.048, 207, 0.987, 775.523, 186, 1.805, 40853.142, 178, 5.963, 25934.124, 170, 4.137, 10021.837, 154, 3.296, 11015.106, 149, 5.611, 10404.734, 131, 5.707, 9683.595, 129, 5.427, 29580.475, 120, 3.576, 10742.977, 118, 1.191, 8624.213, 115, 5.128, 6283.076, 98, 0.15, 20618.02, 95, 2.75, 191.45, 86, 0.43, 9786.69, 81, 1.31, 15720.84, + /*B1*/ 5133476, 1.8036431, 10213.2855462, 43801, 3.38616, 20426.57109, 1992, 0.0000, 0.0000, 1966, 2.5300, 30639.8566, 140, 2.271, 9437.763, 130, 1.507, 18073.705, 119, 5.605, 1577.344, 103, 5.242, 2352.866, 93, 6.08, 22003.91, 80, 0.29, 9153.90, 75, 5.08, 10186.99, 74, 1.50, 11790.63, 47, 3.88, 10239.58, 47, 0.75, 5507.55, 44, 3.59, 40853.14, 40, 1.28, 10404.73, 38, 4.33, 19651.05, 36, 1.26, 19896.88, 35, 5.51, 529.69, 34, 4.89, 10988.81, 29, 0.09, 14143.50, + /*B2*/ 223777, 3.385091, 10213.285546, 2817, 0.0000, 0.0000, 1732, 5.2556, 20426.5711, 269, 3.870, 30639.857, + /*B3*/ 6467, 4.9917, 10213.2855, 200, 3.142, 0.000, 55, 0.77, 20426.57, 25, 5.44, 30639.86, + /*B4*/ 141, 0.315, 10213.286, 2, 3.14, 0.00, 2, 2.35, 20426.57, 2, 0.74, 30639.86, + /*B5*/ 2, 2.05, 10213.29, + /*R0*/ 723348209, 0.000000000, 0.000000000, 4898242, 4.0215183, 10213.2855462, 16581, 4.90207, 20426.57109, 16321, 2.84549, 7860.41939, 13780, 1.12847, 11790.62909, 4984, 2.5868, 9683.5946, 3740, 1.4231, 3930.2097, 2636, 5.5294, 9437.7629, 2375, 2.5514, 15720.8388, 2220, 2.0135, 19367.1892, 1259, 2.7277, 1577.3435, 1195, 3.0198, 10404.7338, 853, 3.986, 19651.048, 762, 1.596, 9153.904, 743, 4.120, 5507.553, 425, 3.819, 13367.973, 419, 1.643, 18837.498, 394, 5.390, 23581.258, 313, 2.318, 9999.986, 290, 5.677, 5661.332, 276, 5.724, 775.523, 273, 4.822, 11015.106, 198, 0.532, 27511.468, 197, 4.962, 11322.664, 162, 0.565, 529.691, 136, 3.755, 18073.705, 132, 3.372, 13745.346, 131, 5.244, 17298.182, 129, 1.134, 10206.172, 118, 5.090, 3154.687, 117, 0.234, 7084.897, 114, 4.568, 29050.784, 108, 2.450, 10239.584, 107, 1.955, 31441.678, 104, 1.202, 15874.618, 96, 1.47, 19999.97, 93, 1.62, 2352.87, 91, 3.07, 1109.38, 84, 5.78, 30639.86, 82, 1.95, 22003.91, 76, 1.14, 8624.21, 65, 2.17, 14143.50, 64, 0.84, 6283.08, 62, 3.26, 6872.67, 61, 0.35, 21228.39, 60, 3.38, 35371.89, 59, 0.01, 8635.94, 56, 3.95, 12566.15, 55, 1.27, 18307.81, 45, 4.73, 19896.88, 45, 2.48, 191.45, 43, 2.60, 4551.95, 40, 0.00, 801.82, 39, 5.57, 10596.18, 39, 1.01, 9786.69, 35, 4.80, 39302.10, 33, 0.71, 10742.98, 32, 0.40, 10186.99, 32, 1.81, 25158.60, 31, 6.26, 14945.32, 30, 4.21, 28521.09, 27, 5.80, 7064.12, 25, 0.69, 10988.81, 24, 3.78, 21535.95, 22, 2.83, 8662.24, 21, 6.22, 43232.31, 20, 5.42, 16496.36, 20, 2.21, 19786.67, 19, 2.86, 3532.06, 19, 2.63, 29580.47, 19, 1.50, 10021.84, 18, 3.23, 29088.81, 18, 0.42, 4705.73, 17, 3.68, 26.30, 15, 0.00, 17277.41, 15, 2.48, 31749.24, 14, 5.86, 9676.48, 14, 5.18, 10316.38, 13, 2.49, 9690.71, 13, 1.36, 47162.52, 13, 5.25, 19360.08, 12, 1.88, 19374.30, 12, 5.56, 6770.71, 12, 1.42, 4732.03, 12, 1.43, 18875.53, 11, 5.92, 13936.79, 11, 4.64, 33019.02, + /*R1*/ 345510, 0.891987, 10213.285546, 2342, 1.7722, 20426.5711, 2340, 3.1416, 0.0000, 239, 1.113, 9437.763, 106, 4.592, 1577.344, 91, 4.54, 10404.73, 66, 5.98, 5507.55, 47, 3.88, 9153.90, 38, 5.66, 13367.97, 27, 2.82, 10206.17, 22, 2.05, 775.52, 21, 2.55, 18837.50, 18, 1.88, 11015.11, 18, 2.65, 30639.86, 13, 0.21, 11322.66, 12, 0.79, 17298.18, 11, 4.95, 6283.08, 10, 6.17, 10239.58, 9, 4.60, 1109.38, 9, 0.81, 10596.18, 9, 2.48, 3154.69, 9, 0.67, 18073.70, 8, 5.59, 12566.15, 8, 0.44, 8635.94, 8, 5.49, 529.69, 8, 3.75, 7084.90, 8, 0.90, 5661.33, 7, 2.87, 8624.21, 7, 5.07, 22003.91, 6, 4.10, 191.45, 6, 3.14, 10186.99, 6, 2.25, 21228.39, 6, 2.17, 18307.81, 5, 5.87, 2352.87, 5, 5.33, 14143.50, 5, 4.34, 9786.69, 5, 5.56, 10742.98, + /*R2*/ 14066, 5.06366, 10213.28555, 155, 5.473, 20426.571, 131, 0.000, 0.000, 11, 2.79, 9437.76, 5, 6.28, 1577.34, 4, 1.95, 11015.11, 4, 2.33, 775.52, 4, 6.12, 10404.73, 3, 1.39, 5507.55, 2, 5.63, 10239.58, 2, 6.17, 30639.86, 2, 1.11, 13367.97, 2, 3.64, 7084.90, 2, 2.22, 3154.69, + /*R3*/ 496, 3.223, 10213.286, 8, 3.21, 20426.57, 1, 3.14, 0.00, + /*R4*/ 6, 0.92, 10213.29 }; + +//Dmar精度:J2000+-4千年 黄经0.5角秒 黄纬0.5角秒 距离1AU/10^6 +static constexpr long double XL0_3[] = { + 1000000000,//A的倍率 + 20, 596, 1028, 1289, 1385, 1427, 1454, 1586, 1670, 1694, 1709, 1718, 1724, 2360, 2873, 3155, 3239, 3275, 3287,//位置索引表 + /*L0*/ 6203477116, 0.0000000000, 0.0000000000, 186563681, 5.050371003, 3340.612426700, 11082168, 5.40099837, 6681.22485340, 917984, 5.754787, 10021.837280, 277450, 5.970495, 3.523118, 123159, 0.849561, 2810.921462, 106102, 2.939585, 2281.230497, 89268, 4.15698, 0.01725, 87157, 6.11005, 13362.44971, 77749, 3.33969, 5621.84292, 67976, 0.36462, 398.14900, 41611, 0.22815, 2942.46342, 35751, 1.66187, 2544.31442, 30753, 0.85697, 191.44827, 29375, 6.07894, 0.06731, 26281, 0.64806, 3337.08931, 25798, 0.02997, 3344.13555, 23894, 5.03896, 796.29801, 17988, 0.65634, 529.69097, 15464, 2.91580, 1751.53953, 15281, 1.14979, 6151.53389, 12862, 3.06796, 2146.16542, 12644, 3.62275, 5092.15196, 10249, 3.69334, 8962.45535, 8916, 0.1829, 16703.0621, 8588, 2.4009, 2914.0142, 8327, 4.4950, 3340.6297, 8327, 2.4642, 3340.5952, 7487, 3.8225, 155.4204, 7239, 0.6750, 3738.7614, 7129, 3.6634, 1059.3819, 6552, 0.4886, 3127.3133, 6356, 2.9218, 8432.7644, 5527, 4.4748, 1748.0164, 5505, 3.8100, 0.9803, 4722, 3.6255, 1194.4470, 4260, 0.5537, 6283.0758, 4151, 0.4966, 213.2991, 3121, 0.9985, 6677.7017, 3066, 0.3805, 6684.7480, 3024, 4.4862, 3532.0607, 2994, 2.7832, 6254.6267, 2932, 4.2213, 20.7754, 2836, 5.7689, 3149.1642, 2811, 5.8816, 1349.8674, 2740, 0.1337, 3340.6797, 2740, 0.5422, 3340.5451, 2389, 5.3716, 4136.9104, 2361, 5.7550, 3333.4989, 2312, 1.2824, 3870.3034, 2212, 3.5047, 382.8965, 2042, 2.8213, 1221.8486, 1931, 3.3572, 3.5904, 1886, 1.4910, 9492.1463, 1792, 1.0056, 951.7184, 1741, 2.4136, 553.5694, 1721, 0.4394, 5486.7778, 1600, 3.9485, 4562.4610, 1443, 1.4187, 135.0651, 1399, 3.3259, 2700.7151, 1382, 4.3015, 7.1135, 1310, 4.0449, 12303.0678, 1281, 2.2081, 1592.5960, 1281, 1.8067, 5088.6288, 1169, 3.1281, 7903.0734, 1135, 3.7007, 1589.0729, 1104, 1.0520, 242.7286, 1045, 0.7854, 8827.3903, 1001, 3.2434, 11773.3768, 989, 4.846, 6681.242, 989, 2.815, 6681.208, 956, 0.540, 20043.675, 869, 2.202, 11243.686, 868, 1.021, 7079.374, 842, 3.990, 4399.994, 837, 3.203, 4690.480, 750, 0.766, 6467.926, 735, 2.184, 8429.241, 721, 5.847, 5884.927, 714, 2.803, 3185.192, 690, 3.764, 6041.328, 684, 2.738, 2288.344, 667, 0.736, 3723.509, 653, 2.681, 28.449, 634, 0.913, 3553.912, 633, 4.528, 426.598, 617, 6.168, 2274.117, 566, 5.063, 15.252, 564, 1.687, 6872.673, 559, 3.463, 263.084, 555, 4.606, 4292.331, 523, 0.899, 9623.688, 517, 2.813, 3339.632, 513, 4.148, 3341.593, 485, 3.957, 4535.059, 459, 0.287, 5614.729, 458, 0.788, 1990.745, 442, 3.195, 5628.956, 419, 3.583, 8031.092, 412, 6.020, 3894.182, 407, 3.138, 9595.239, 395, 5.632, 3097.884, 388, 1.352, 10018.314, 384, 5.829, 3191.049, 382, 2.348, 162.467, 381, 0.734, 10025.360, 378, 4.155, 2803.808, 371, 0.685, 2818.035, 367, 2.637, 692.158, 340, 2.595, 11769.854, 336, 6.120, 6489.777, 331, 1.140, 5.523, 326, 0.484, 6681.292, 326, 0.893, 6681.158, 312, 3.982, 20.355, 290, 2.427, 3319.837, 287, 5.721, 7477.523, 276, 1.597, 7210.916, 275, 6.084, 6674.111, 273, 4.556, 3361.388, 264, 1.345, 3496.033, 256, 0.250, 522.577, 255, 3.432, 3443.705, 254, 0.521, 10.637, 246, 4.003, 11371.705, 244, 0.970, 632.784, 238, 1.841, 12832.759, 231, 4.750, 3347.726, 228, 3.526, 1648.447, 227, 4.985, 7632.943, 227, 3.954, 4989.059, 226, 5.241, 3205.547, 225, 5.649, 2388.894, 223, 0.721, 266.607, 215, 6.154, 3264.346, 213, 4.282, 4032.770, 212, 3.118, 2957.716, 210, 4.279, 5099.266, 202, 3.671, 1758.653, 201, 1.082, 7064.121, 198, 2.377, 10713.995, 193, 3.239, 7.046, 184, 4.225, 2787.043, 181, 3.258, 3337.022, 180, 4.254, 2487.416, 177, 3.697, 3344.203, 176, 4.092, 74.782, 168, 5.486, 3.881, 168, 4.397, 15643.680, 166, 2.528, 14584.298, 161, 2.369, 3265.831, 161, 3.794, 2118.764, 160, 1.768, 3475.678, 160, 1.547, 14054.607, 158, 0.569, 103.093, 158, 3.132, 59.374, 146, 3.452, 7373.382, 145, 4.380, 316.392, 142, 0.598, 23.878, 140, 1.442, 10404.734, 139, 5.408, 10973.556, 137, 3.591, 15113.989, 137, 2.541, 4933.208, 135, 4.042, 4929.685, 134, 5.169, 10213.286, 133, 6.178, 1744.426, 128, 0.105, 7234.794, 127, 1.799, 13745.346, 123, 2.521, 2906.901, 123, 3.169, 10021.820, 123, 5.199, 10021.855, 122, 1.731, 36.028, 122, 4.423, 14712.317, 119, 5.480, 2921.128, 119, 4.766, 5828.028, 118, 5.727, 0.420, 109, 0.604, 5085.038, 108, 1.372, 10419.986, 107, 4.339, 7740.607, 106, 5.477, 419.485, 106, 3.450, 639.897, 106, 0.896, 23384.287, 106, 1.091, 12168.003, 100, 1.383, 3583.341, 99, 2.69, 36.61, 98, 5.84, 14314.17, 98, 3.60, 206.19, 97, 6.28, 9225.54, 96, 4.89, 3230.41, 96, 4.33, 131.54, 91, 1.10, 9808.54, 88, 3.97, 170.67, + /*L1*/ 3340856274743, 0.000000000000, 0.000000000000, 14582271, 3.60426054, 3340.61242670, 1649013, 3.9263125, 6681.2248534, 199633, 4.265941, 10021.837280, 34524, 4.73210, 3.52312, 24855, 4.61278, 13362.44971, 8416, 4.4586, 2281.2305, 5376, 5.0159, 398.1490, 5210, 4.9942, 3344.1355, 4326, 2.5607, 191.4483, 4297, 5.3165, 155.4204, 3817, 3.5388, 796.2980, 3141, 4.9634, 16703.0621, 2828, 3.1597, 2544.3144, 2057, 4.5689, 2146.1654, 1688, 1.3289, 3337.0893, 1576, 4.1850, 1751.5395, 1337, 2.2333, 0.9803, 1336, 5.9742, 1748.0164, 1176, 6.0241, 6151.5339, 1166, 2.2135, 1059.3819, 1139, 2.1287, 1194.4470, 1136, 5.4280, 3738.7614, 911, 1.096, 1349.867, 853, 3.909, 553.569, 833, 5.296, 6684.748, 808, 4.428, 529.691, 795, 2.249, 8962.455, 729, 2.502, 951.718, 725, 5.842, 242.729, 715, 3.856, 2914.014, 676, 5.023, 382.897, 651, 1.018, 3340.595, 651, 3.049, 3340.630, 615, 4.152, 3149.164, 565, 3.888, 4136.910, 485, 4.874, 213.299, 476, 1.182, 3333.499, 466, 1.315, 3185.192, 413, 0.714, 1592.596, 403, 2.725, 7.114, 401, 5.316, 20043.675, 329, 5.411, 6283.076, 282, 0.045, 9492.146, 266, 3.890, 1221.849, 266, 5.113, 2700.715, 233, 6.168, 3532.061, 228, 1.545, 2274.117, 226, 0.838, 3097.884, 224, 5.466, 20.355, 223, 5.885, 3870.303, 214, 4.971, 3340.680, 214, 5.379, 3340.545, 211, 3.525, 15.252, 204, 2.364, 1589.073, 202, 3.364, 5088.629, 200, 4.731, 4690.480, 200, 5.787, 7079.374, 197, 2.578, 12303.068, 195, 0.492, 6677.702, 195, 2.531, 4399.994, 185, 5.579, 1990.745, 178, 6.125, 4292.331, 166, 1.255, 3894.182, 165, 2.603, 3341.593, 154, 2.470, 4535.059, 153, 2.265, 3723.509, 150, 1.035, 2288.344, 147, 3.370, 6681.242, 147, 1.339, 6681.208, 136, 1.977, 5614.729, 135, 2.123, 5486.778, 133, 3.422, 5621.843, 130, 1.514, 5628.956, 130, 5.619, 10025.360, 127, 2.950, 3496.033, 119, 5.476, 3553.912, 119, 3.127, 426.598, 118, 2.586, 8432.764, 114, 6.234, 135.065, 111, 5.842, 2803.808, 110, 4.158, 2388.894, 109, 5.282, 2818.035, 105, 2.736, 2787.043, 97, 4.53, 6489.78, 88, 4.23, 7477.52, 87, 4.44, 5092.15, 87, 4.33, 3339.63, 86, 3.16, 162.47, 85, 1.91, 11773.38, 84, 3.16, 3347.73, 83, 2.18, 23.88, 81, 1.61, 2957.72, 80, 5.70, 6041.33, 77, 5.72, 9623.69, 74, 6.18, 3583.34, 67, 5.08, 8031.09, 64, 2.12, 5884.93, 62, 3.54, 692.16, 61, 1.66, 6525.80, 57, 3.68, 8429.24, 55, 2.01, 522.58, 55, 6.13, 2487.42, 55, 0.19, 7632.94, 54, 1.05, 4933.21, 54, 0.18, 2942.46, 53, 2.23, 3127.31, 52, 0.37, 12832.76, 52, 1.15, 28.45, 51, 5.67, 23384.29, 50, 1.51, 1744.43, 50, 2.45, 5099.27, 49, 3.10, 5.52, 49, 5.61, 6467.93, 49, 5.29, 6681.29, 48, 5.70, 6681.16, 47, 0.23, 36.03, 47, 0.03, 7210.92, 45, 4.17, 2906.90, 44, 0.31, 10018.31, 43, 4.43, 640.88, 43, 2.88, 2810.92, 41, 1.60, 7234.79, 41, 3.96, 3.88, 38, 2.26, 2699.73, 37, 2.92, 15643.68, 35, 1.76, 1758.65, 34, 1.53, 6674.11, 34, 2.66, 4929.69, 33, 2.59, 2118.76, 32, 6.14, 10419.99, 32, 2.33, 5085.04, 32, 2.87, 7740.61, 31, 1.76, 9595.24, 31, 2.56, 7064.12, 30, 1.87, 7.05, 29, 1.28, 574.34, 28, 0.99, 3191.05, 28, 0.43, 5828.03, 28, 1.76, 639.90, 27, 3.71, 10021.85, 27, 1.68, 10021.82, 26, 3.12, 6836.65, 26, 3.77, 2921.13, + /*L2*/ 580158, 2.049795, 3340.612427, 541876, 0.000000, 0.000000, 139084, 2.457424, 6681.224853, 24651, 2.80000, 10021.83728, 3984, 3.1412, 13362.4497, 2220, 3.1944, 3.5231, 1210, 0.5433, 155.4204, 615, 3.485, 16703.062, 536, 3.542, 3344.136, 343, 6.002, 2281.230, 317, 4.140, 191.448, 298, 1.999, 796.298, 232, 4.334, 242.729, 217, 3.445, 398.149, 204, 5.422, 553.569, 162, 0.657, 0.980, 160, 6.110, 2146.165, 156, 1.221, 1748.016, 149, 6.095, 3185.192, 144, 4.019, 951.718, 143, 2.619, 1349.867, 134, 0.602, 1194.447, 119, 3.861, 6684.748, 113, 4.718, 2544.314, 104, 0.250, 382.897, 95, 0.68, 1059.38, 92, 3.83, 20043.67, 90, 3.88, 3738.76, 75, 5.46, 1751.54, 69, 2.58, 3149.16, 67, 2.38, 4136.91, 65, 5.48, 1592.60, 63, 2.34, 3097.88, 59, 1.15, 7.11, 48, 2.90, 3333.50, 46, 4.43, 6151.53, 42, 3.69, 5614.73, 40, 6.12, 5628.96, 37, 4.07, 1990.75, 36, 2.47, 529.69, 33, 0.68, 8962.46, 33, 2.80, 3894.18, 31, 4.57, 3496.03, 29, 5.41, 2914.01, 29, 1.23, 2787.04, 29, 3.41, 3337.09, 28, 1.39, 4292.33, 26, 4.68, 3583.34, 26, 1.04, 3341.59, 26, 2.65, 2388.89, 26, 1.50, 3340.63, 26, 5.75, 3340.60, 24, 0.96, 4535.06, 24, 1.05, 4399.99, 24, 4.27, 7079.37, 24, 4.85, 9492.15, 23, 4.18, 10025.36, 23, 0.01, 4690.48, 22, 3.26, 213.30, 22, 0.16, 6525.80, 21, 0.48, 2700.72, 18, 0.97, 1589.07, 18, 2.52, 2810.92, 18, 3.81, 3723.51, 16, 1.11, 12303.07, 16, 4.94, 1221.85, 16, 4.96, 5088.63, 15, 2.93, 640.88, 15, 0.11, 2957.72, 14, 2.98, 6489.78, 14, 1.54, 3347.73, 14, 3.86, 6283.08, 14, 2.73, 7477.52, 14, 4.18, 23384.29, 13, 5.30, 6677.70, 12, 3.77, 2699.73, 12, 6.14, 6681.21, 12, 1.89, 6681.24, 12, 1.51, 426.60, 11, 3.78, 3870.30, 11, 5.05, 5621.84, 11, 3.81, 3553.91, 10, 5.83, 4933.21, 9, 1.91, 3532.06, 9, 3.82, 5092.15, 9, 4.13, 162.47, 9, 3.83, 3340.55, + /*L3*/ 14824, 0.44435, 3340.61243, 6621, 0.8847, 6681.2249, 1883, 1.2880, 10021.8373, 415, 1.649, 13362.450, 260, 0.000, 0.000, 227, 2.053, 155.420, 105, 1.580, 3.523, 80, 2.00, 16703.06, 49, 2.82, 242.73, 38, 2.02, 3344.14, 32, 4.59, 3185.19, 31, 0.65, 553.57, 17, 5.54, 951.72, 15, 5.72, 191.45, 14, 0.46, 796.30, 14, 2.34, 20043.67, 13, 5.36, 0.98, 12, 4.15, 1349.87, 11, 2.38, 6684.75, 10, 1.77, 382.90, 9, 5.34, 1194.45, 8, 2.75, 1748.02, 6, 3.18, 3583.34, 6, 6.11, 3496.03, 6, 5.86, 7.11, 6, 1.85, 398.15, 5, 4.93, 6525.80, 5, 1.01, 3149.16, 5, 0.84, 4136.91, 5, 5.98, 2787.04, 4, 1.27, 2281.23, 4, 2.33, 3738.76, + /*L4*/ 1140, 3.1416, 0.0000, 287, 5.637, 6681.225, 244, 5.139, 3340.612, 112, 6.032, 10021.837, 33, 0.13, 13362.45, 32, 3.56, 155.42, 8, 0.49, 16703.06, 8, 1.32, 242.73, 5, 3.06, 3185.19, 4, 2.16, 553.57, 3, 6.23, 3.52, 2, 0.44, 3344.14, 2, 0.82, 20043.67, 2, 3.74, 3496.03, + /*L5*/ 9, 3.14, 0.00, 7, 4.04, 6681.22, 5, 4.49, 10021.84, 4, 5.07, 155.42, 2, 3.51, 3340.61, 2, 4.85, 13362.45, 1, 6.09, 242.73, 1, 5.19, 16703.06, 1, 1.56, 3185.19, + /*B0*/ 31971350, 3.76832042, 3340.61242670, 2980332, 4.1061700, 6681.2248534, 2891047, 0.0000000, 0.0000000, 313655, 4.446511, 10021.837280, 34841, 4.78813, 13362.44971, 4434, 5.0264, 3344.1355, 4430, 5.6523, 3337.0893, 3991, 5.1306, 16703.0621, 2925, 3.7929, 2281.2305, 1820, 6.1365, 6151.5339, 1632, 4.2640, 529.6910, 1597, 2.2319, 1059.3819, 1493, 2.1650, 5621.8429, 1427, 1.1822, 3340.5952, 1427, 3.2129, 3340.6297, 1393, 2.4180, 8962.4553, 864, 5.744, 3738.761, 833, 5.989, 6677.702, 825, 5.367, 6684.748, 736, 5.092, 398.149, 727, 5.538, 6283.076, 631, 0.730, 5884.927, 623, 4.851, 2942.463, 601, 3.680, 796.298, 472, 4.522, 3149.164, 470, 5.135, 3340.680, 470, 5.543, 3340.545, 466, 5.474, 20043.675, 456, 2.133, 2810.921, 413, 0.200, 9492.146, 385, 4.080, 4136.910, 331, 4.066, 1751.540, 327, 2.621, 2914.014, 297, 5.922, 3532.061, 295, 2.753, 12303.068, 286, 4.947, 3870.303, 282, 2.063, 5486.778, 266, 3.551, 6681.242, 266, 1.520, 6681.208, 261, 2.601, 4399.994, 233, 2.276, 1589.073, 226, 2.275, 1194.447, 199, 2.674, 8432.764, 189, 6.044, 7079.374, + /*B1*/ 3500688, 5.3684784, 3340.6124267, 141160, 3.141593, 0.000000, 96708, 5.47878, 6681.22485, 14719, 3.20206, 10021.83728, 4259, 3.4084, 13362.4497, 1020, 0.7762, 3337.0893, 788, 3.718, 16703.062, 327, 3.458, 5621.843, 262, 2.483, 2281.230, 207, 1.441, 6151.534, 183, 6.031, 529.691, 170, 4.811, 3344.136, 157, 3.931, 8962.455, 156, 2.782, 3340.595, 156, 4.813, 3340.630, 143, 0.246, 2942.463, 138, 1.680, 3532.061, 131, 0.973, 6677.702, 127, 4.045, 20043.675, 125, 2.256, 5884.927, 93, 4.35, 3496.03, 89, 5.95, 2810.92, 88, 0.34, 398.15, 86, 1.75, 2544.31, 81, 0.84, 6283.08, 81, 4.30, 6684.75, 59, 3.70, 5486.78, 58, 3.55, 5092.15, + /*B2*/ 167267, 0.602214, 3340.612427, 49868, 3.14159, 0.00000, 3021, 5.5587, 6681.2249, 258, 1.897, 13362.450, 215, 0.917, 10021.837, 118, 2.242, 3337.089, 80, 2.25, 16703.06, 30, 5.89, 3496.03, + /*B3*/ 6065, 1.9805, 3340.6124, 426, 0.000, 0.000, 137, 1.796, 6681.225, 27, 3.45, 10021.84, 9, 3.75, 3337.09, + /*B4*/ 134, 0.000, 0.000, 113, 3.457, 3340.612, 7, 0.50, 6681.22, + /*B5*/ 5, 4.87, 3340.61, 1, 5.31, 6681.22, + /*R0*/ 1530334883, 0.0000000000, 0.0000000000, 141849532, 3.479712835, 3340.612426700, 6607764, 3.8178344, 6681.2248534, 461791, 4.155953, 10021.837280, 81097, 5.55958, 2810.92146, 74853, 1.77239, 5621.84292, 55232, 1.36436, 2281.23050, 38252, 4.49407, 13362.44971, 24844, 4.92546, 2942.46342, 23065, 0.09082, 2544.31442, 19994, 5.36060, 3337.08931, 19602, 4.74249, 3344.13555, 11671, 2.11262, 5092.15196, 11028, 5.00908, 398.14900, 9923, 5.8386, 6151.5339, 8991, 4.4079, 529.6910, 8073, 2.1022, 1059.3819, 7979, 3.4484, 796.2980, 7410, 1.4991, 2146.1654, 7256, 1.2452, 8432.7644, 6923, 2.1338, 8962.4553, 6331, 0.8935, 3340.5952, 6331, 2.9243, 3340.6297, 6300, 1.2874, 1751.5395, 5744, 0.8290, 2914.0142, 5262, 5.3829, 3738.7614, 4728, 5.1985, 3127.3133, 3481, 4.8322, 16703.0621, 2837, 2.9069, 3532.0607, 2796, 5.2575, 6283.0758, 2755, 1.2177, 6254.6267, 2752, 2.9082, 1748.0164, 2699, 3.7639, 5884.9268, 2391, 2.0367, 1194.4470, 2338, 5.1055, 5486.7778, 2281, 3.2553, 6872.6731, 2232, 4.1986, 3149.1642, 2194, 5.5834, 191.4483, 2083, 4.8463, 3340.6797, 2083, 5.2548, 3340.5451, 1862, 5.6987, 6677.7017, 1827, 5.0806, 6684.7480, 1786, 4.1842, 3333.4989, 1760, 5.9534, 3870.3034, 1635, 3.7989, 4136.9104, 1443, 0.2130, 5088.6288, 1418, 2.4779, 4562.4610, 1331, 1.5391, 7903.0734, 1286, 5.4988, 8827.3903, 1188, 2.1218, 1589.0729, 1149, 4.3175, 1349.8674, 1115, 0.5534, 11243.6858, 1021, 6.1814, 9492.1463, 867, 1.750, 2700.715, 853, 1.616, 4690.480, 845, 0.623, 1592.596, 832, 0.616, 8429.241, 825, 1.622, 11773.377, 718, 2.475, 12303.068, 686, 2.402, 4399.994, 665, 2.213, 6041.328, 636, 2.673, 426.598, 620, 1.101, 1221.849, 590, 3.262, 6681.242, 590, 1.232, 6681.208, 586, 4.721, 213.299, 558, 1.233, 3185.192, 557, 5.447, 3723.509, 550, 5.727, 951.718, 524, 3.024, 4292.331, 516, 5.723, 7079.374, 489, 5.616, 3553.912, 454, 5.433, 6467.926, 446, 2.015, 8031.092, 443, 5.003, 5614.729, 433, 1.037, 11769.854, 424, 2.266, 155.420, 422, 1.633, 5628.956, 392, 1.242, 3339.632, 390, 2.578, 3341.593, 364, 4.439, 3894.182, 360, 1.160, 2288.344, 353, 5.490, 1990.745, 336, 5.170, 20043.675, 331, 0.855, 553.569, 323, 2.382, 4535.059, 320, 1.940, 382.897, 319, 4.593, 2274.117, 319, 4.375, 3.523, 303, 2.442, 11371.705, 294, 4.060, 3097.884, 279, 4.258, 3191.049, 275, 1.577, 9595.239, 262, 5.585, 9623.688, 252, 0.814, 10713.995, 248, 5.390, 2818.035, 247, 2.580, 2803.808, 234, 6.015, 3496.033, 228, 3.417, 7632.943, 221, 0.857, 3319.837, 213, 6.192, 14054.607, 210, 2.385, 4989.059, 206, 2.987, 3361.388, 204, 4.536, 6489.777, 199, 2.735, 5099.266, 197, 1.863, 3443.705, 195, 6.038, 10018.314, 194, 5.185, 6681.292, 194, 5.594, 6681.158, 191, 5.420, 10025.360, 191, 0.226, 13745.346, 186, 4.073, 2388.894, 183, 5.796, 7064.121, 182, 5.613, 7.114, 180, 2.814, 4032.770, 172, 3.671, 3205.547, 172, 3.188, 3347.726, 171, 1.550, 2957.716, 170, 6.155, 10404.734, 167, 4.521, 6674.111, 165, 4.141, 7477.523, 165, 3.845, 10973.556, 165, 2.866, 14712.317, 163, 6.282, 7210.916, 163, 1.923, 7373.382, 161, 0.928, 14584.298, 160, 4.584, 3264.346, 154, 2.208, 2118.764, 151, 2.654, 2787.043, 137, 1.686, 3337.022, 134, 2.128, 3344.203, 131, 4.275, 14314.168, 119, 0.799, 3265.831, 119, 4.821, 7234.794, 118, 0.197, 3475.678, 118, 3.229, 5828.028, 112, 0.239, 12832.759, 110, 0.445, 10213.286, 106, 1.740, 639.897, 102, 5.748, 242.729, 102, 2.665, 2487.416, 101, 5.375, 5085.038, 101, 0.789, 9381.940, 101, 2.451, 4929.685, 90, 0.96, 4933.21, 90, 1.99, 15113.99, 90, 4.18, 9225.54, 83, 1.94, 1648.45, 83, 0.95, 2906.90, 82, 5.25, 10575.41, 80, 3.92, 2921.13, 79, 2.81, 15643.68, 78, 2.05, 1758.65, 75, 5.68, 13916.02, 74, 6.10, 3583.34, 74, 0.84, 692.16, 70, 3.32, 3230.41, 68, 4.69, 17654.78, 65, 6.12, 135.07, 65, 2.74, 7740.61, 64, 4.20, 5202.36, 63, 3.32, 3767.21, 63, 4.50, 8425.65, 62, 6.11, 17256.63, 62, 4.48, 22747.29, 62, 4.59, 6531.66, 62, 1.57, 10021.82, 62, 3.60, 10021.85, 61, 0.00, 6836.65, 57, 0.14, 13524.92, 55, 5.75, 12168.00, 55, 6.06, 10419.99, 54, 5.22, 5305.45, 54, 5.08, 2707.83, 53, 4.55, 1744.43, 52, 2.70, 4459.37, 51, 1.57, 6525.80, 51, 1.29, 8439.88, 50, 2.34, 1052.27, 50, 4.68, 522.58, 47, 0.01, 3325.36, 47, 5.78, 9808.54, 47, 3.06, 5518.75, 47, 5.15, 1066.50, 45, 1.44, 3369.06, 45, 5.95, 6894.52, 44, 5.57, 16865.53, 44, 0.82, 3302.48, 43, 3.11, 4569.57, 43, 2.79, 3503.08, 42, 1.91, 263.08, 41, 4.40, 3074.01, 41, 5.49, 2699.73, 41, 5.47, 3120.20, 40, 1.34, 6247.51, 40, 1.84, 3134.43, 40, 3.83, 3355.86, 39, 1.98, 8969.57, 39, 1.49, 9168.64, 39, 0.38, 10177.26, 39, 1.23, 16858.48, 39, 3.48, 20618.02, 38, 0.80, 13517.87, 38, 0.27, 17395.22, 37, 4.25, 6261.74, 37, 1.58, 6680.24, 36, 2.95, 6144.42, 36, 5.55, 632.78, 36, 2.92, 6682.21, 36, 3.68, 5724.94, 36, 0.15, 2178.14, 35, 1.18, 10184.30, + /*R1*/ 11074333, 2.03250525, 3340.61242670, 1031759, 2.3707185, 6681.2248534, 128772, 0.000000, 0.000000, 108159, 2.708881, 10021.837280, 11946, 3.04702, 13362.44971, 4386, 2.8884, 2281.2305, 3957, 3.4232, 3344.1355, 1826, 1.5843, 2544.3144, 1359, 3.3851, 16703.0621, 1284, 6.0434, 3337.0893, 1282, 0.6299, 1059.3819, 1271, 1.9539, 796.2980, 1184, 2.9976, 2146.1654, 875, 3.421, 398.149, 830, 3.856, 3738.761, 756, 4.451, 6151.534, 720, 2.764, 529.691, 665, 2.549, 1751.540, 664, 4.406, 1748.016, 575, 0.544, 1194.447, 543, 0.678, 8962.455, 510, 3.726, 6684.748, 494, 5.730, 3340.595, 494, 1.477, 3340.630, 483, 2.581, 3149.164, 479, 2.285, 2914.014, 390, 2.319, 4136.910, 372, 5.814, 1349.867, 364, 6.027, 3185.192, 360, 5.895, 3333.499, 311, 0.978, 191.448, 272, 5.414, 1592.596, 243, 3.758, 155.420, 228, 1.748, 5088.629, 223, 0.939, 951.718, 217, 3.836, 6283.076, 216, 4.569, 3532.061, 213, 0.780, 1589.073, 204, 3.135, 4690.480, 182, 0.413, 5486.778, 180, 4.219, 3870.303, 169, 4.537, 4292.331, 168, 5.549, 3097.884, 165, 0.968, 4399.994, 165, 3.539, 2700.715, 163, 3.808, 3340.545, 163, 3.399, 3340.680, 162, 2.349, 553.569, 158, 4.757, 9492.146, 157, 3.724, 20043.675, 147, 5.953, 3894.182, 143, 3.999, 1990.745, 132, 0.415, 5614.729, 130, 5.142, 6677.702, 127, 0.690, 3723.509, 125, 1.032, 3341.593, 124, 6.231, 5628.956, 122, 4.223, 7079.374, 118, 6.253, 2274.117, 113, 1.024, 12303.068, 112, 1.318, 3496.033, 104, 1.233, 426.598, 103, 0.901, 4535.059, 98, 3.45, 382.90, 92, 1.82, 6681.24, 92, 6.07, 6681.21, 92, 3.90, 3553.91, 90, 2.58, 2388.89, 88, 2.20, 1221.85, 86, 1.16, 2787.04, 79, 5.74, 2288.34, 78, 4.15, 6041.33, 77, 1.01, 8432.76, 73, 4.27, 2803.81, 72, 3.70, 2818.04, 71, 3.51, 8031.09, 68, 4.05, 10025.36, 68, 0.24, 11773.38, 67, 4.26, 242.73, 65, 0.04, 2957.72, 65, 2.12, 8429.24, 65, 2.76, 3339.63, 63, 1.90, 5621.84, 63, 1.60, 3347.73, 60, 2.96, 6489.78, 57, 3.14, 213.30, 55, 4.91, 7632.94, 55, 4.61, 3583.34, 53, 3.78, 5092.15, 52, 2.67, 7477.52, 51, 3.98, 7.11, 47, 0.91, 5099.27, 46, 1.82, 2810.92, 40, 4.14, 9623.69, 40, 4.91, 2942.46, 39, 0.54, 5884.93, 39, 3.08, 3.52, 39, 0.67, 3127.31, 38, 0.03, 7234.79, 37, 0.09, 6525.80, 36, 5.77, 4933.21, 32, 4.55, 2487.42, 31, 1.00, 2118.76, 30, 2.59, 2906.90, 30, 4.15, 6681.16, 30, 3.74, 6681.29, 30, 0.83, 5085.04, 29, 4.66, 7210.92, 28, 1.01, 7064.12, 28, 0.05, 639.90, 28, 3.98, 6467.93, 28, 5.17, 5828.03, 27, 0.69, 2699.73, 26, 5.34, 10973.56, 26, 5.01, 10018.31, 26, 1.09, 4929.69, 26, 5.09, 12832.76, 25, 1.53, 6836.65, 24, 3.94, 11371.70, 22, 0.19, 9595.24, 21, 5.69, 3191.05, 21, 1.30, 7740.61, 21, 3.54, 1066.50, 21, 6.24, 6674.11, 20, 6.16, 1744.43, 20, 0.46, 10575.41, 19, 5.02, 3475.68, 19, 1.37, 15643.68, 18, 4.06, 23384.29, 18, 6.16, 8425.65, 18, 5.68, 3319.84, 18, 2.31, 3355.86, 18, 5.87, 3320.26, 17, 4.58, 10419.99, 17, 2.22, 2921.13, 17, 1.93, 3767.21, 16, 4.34, 5331.36, 16, 5.93, 8439.88, 15, 1.54, 3361.39, 15, 0.35, 8969.57, 14, 2.15, 10021.85, 14, 0.12, 10021.82, 14, 0.56, 15113.99, 14, 1.39, 6682.21, 14, 4.65, 4562.46, 14, 1.50, 3325.36, 14, 0.15, 1758.65, 13, 1.25, 7875.67, 13, 1.87, 692.16, 13, 1.45, 6254.63, 13, 5.79, 14584.30, 13, 1.35, 10404.73, 12, 6.03, 3264.35, 12, 1.88, 10177.26, 12, 0.85, 3120.20, 12, 4.30, 6894.52, 12, 0.90, 13916.02, 12, 4.18, 3360.97, 12, 3.00, 6247.51, 11, 0.15, 3134.43, 11, 2.84, 640.88, 11, 2.58, 6261.74, 11, 0.49, 11243.69, 11, 0.25, 3337.02, 11, 0.13, 522.58, 11, 0.68, 3344.20, 10, 4.06, 6158.65, 10, 5.70, 536.80, 10, 5.77, 14314.17, 10, 1.28, 4569.57, 10, 2.92, 5729.51, + /*R2*/ 442422, 0.479306, 3340.612427, 81380, 0.86998, 6681.22485, 12749, 1.22594, 10021.83728, 1874, 1.5730, 13362.4497, 524, 3.142, 0.000, 407, 1.971, 3344.136, 266, 1.917, 16703.062, 178, 4.435, 2281.230, 117, 4.525, 3185.192, 102, 5.391, 1059.382, 100, 0.419, 796.298, 92, 4.54, 2146.17, 78, 5.93, 1748.02, 73, 3.14, 2544.31, 72, 2.29, 6684.75, 68, 5.27, 155.42, 67, 5.30, 1194.45, 65, 2.31, 3738.76, 58, 1.05, 1349.87, 54, 1.00, 3149.16, 47, 0.77, 3097.88, 46, 0.81, 4136.91, 44, 2.46, 951.72, 43, 3.90, 1592.60, 39, 3.86, 553.57, 37, 2.26, 20043.67, 36, 1.32, 3333.50, 35, 1.85, 398.15, 34, 3.82, 1751.54, 32, 2.12, 5614.73, 31, 4.55, 5628.96, 30, 2.86, 6151.53, 29, 1.19, 529.69, 29, 1.20, 3894.18, 28, 2.49, 1990.75, 27, 2.92, 3496.03, 27, 6.07, 4292.33, 24, 4.68, 4690.48, 24, 5.94, 2787.04, 23, 2.56, 191.45, 22, 1.85, 3337.09, 22, 5.37, 8962.46, 22, 1.07, 2388.89, 21, 2.75, 242.73, 20, 3.82, 2914.01, 20, 5.76, 3341.59, 20, 5.76, 4399.99, 20, 4.17, 3340.60, 20, 6.21, 3340.63, 20, 3.11, 3583.34, 18, 5.69, 1589.07, 18, 3.32, 5088.63, 16, 5.68, 4535.06, 15, 4.96, 382.90, 15, 2.23, 3723.51, 14, 2.70, 7079.37, 14, 5.19, 2700.72, 13, 4.88, 6525.80, 13, 4.82, 2957.72, 12, 2.62, 10025.36, 12, 0.93, 2810.92, 12, 3.27, 9492.15, 10, 6.27, 3347.73, 10, 3.40, 5621.84, 10, 2.11, 3870.30, 9, 1.40, 6489.78, 9, 5.81, 12303.07, 9, 2.20, 2699.73, 9, 5.96, 426.60, 8, 2.26, 6283.08, 8, 2.24, 3553.91, 8, 1.17, 7477.52, 8, 2.01, 5092.15, 8, 0.23, 3532.06, 8, 2.06, 5486.78, 7, 4.26, 4933.21, 7, 0.30, 6681.24, 7, 4.55, 6681.21, 7, 2.34, 7.11, 7, 3.99, 6677.70, 7, 0.16, 7632.94, 6, 2.25, 3340.55, 6, 1.84, 3340.68, 6, 1.55, 7234.79, 6, 3.30, 1221.85, 6, 5.06, 8031.09, 5, 4.26, 3339.63, 5, 2.60, 23384.29, 5, 3.08, 6836.65, 4, 1.34, 640.88, 4, 4.96, 8969.57, 4, 2.85, 5331.36, 4, 6.27, 2487.42, 4, 6.10, 7740.61, + /*R3*/ 11131, 5.14987, 3340.61243, 4244, 5.6134, 6681.2249, 1000, 5.9973, 10021.8373, 196, 0.076, 13362.450, 47, 3.14, 0.00, 35, 0.43, 16703.06, 29, 0.45, 3344.14, 24, 3.02, 3185.19, 7, 0.81, 6684.75, 6, 0.78, 20043.67, 5, 3.87, 1059.38, 5, 1.61, 3583.34, 5, 4.52, 3496.03, 4, 5.72, 3149.16, 4, 4.42, 2787.04, 4, 5.56, 4136.91, 3, 3.38, 6525.80, 3, 0.76, 3738.76, 2, 2.14, 3097.88, 2, 5.83, 2388.89, 2, 0.57, 155.42, 2, 4.20, 3341.59, 2, 0.97, 1990.75, 2, 2.35, 1592.60, 2, 4.15, 4535.06, 2, 3.76, 1194.45, 2, 1.14, 10025.36, 2, 5.13, 796.30, + /*R4*/ 196, 3.582, 3340.612, 163, 4.051, 6681.225, 58, 4.46, 10021.84, 15, 4.84, 13362.45, 4, 1.51, 3185.19, 3, 5.21, 16703.06, 2, 5.16, 3344.14, 1, 0.00, 0.00, 1, 2.19, 3496.03, 1, 0.10, 3583.34, 1, 5.55, 20043.67, 1, 1.87, 6525.80, + /*R5*/ 5, 2.48, 6681.22, 3, 2.92, 10021.84, 1, 1.77, 3340.61, 1, 3.31, 13362.45 }; + +//Djup精度:J2000+-4千年 黄经0.5角秒 黄纬0.5角秒 距离3AU/10^6 +static constexpr long double XL0_4[] = { +100000000,//A的倍率 +20, 503, 863, 1256, 1451, 1529, 1550, 1676, 1802, 1910, 1964, 1988, 1991, 2513, 2945, 3482, 3761, 3896, 3923,//位置索引表 +/*L0*/ 59954691, 0.00000000, 0.00000000, 9695899, 5.0619179, 529.6909651, 573610, 1.444062, 7.113547, 306389, 5.417347, 1059.381930, 97178, 4.14265, 632.78374, 72903, 3.64043, 522.57742, 64264, 3.41145, 103.09277, 39806, 2.29377, 419.48464, 38858, 1.27232, 316.39187, 27965, 1.78455, 536.80451, 13590, 5.77481, 1589.07290, 8769, 3.6300, 949.1756, 8246, 3.5823, 206.1855, 7368, 5.0810, 735.8765, 6263, 0.0250, 213.2991, 6114, 4.5132, 1162.4747, 5305, 4.1863, 1052.2684, 5305, 1.3067, 14.2271, 4905, 1.3208, 110.2063, 4647, 4.6996, 3.9322, 3045, 4.3168, 426.5982, 2610, 1.5667, 846.0828, 2028, 1.0638, 3.1814, 1921, 0.9717, 639.8973, 1765, 2.1415, 1066.4955, 1723, 3.8804, 1265.5675, 1633, 3.5820, 515.4639, 1432, 4.2968, 625.6702, 973, 4.098, 95.979, 884, 2.437, 412.371, 733, 6.085, 838.969, 731, 3.806, 1581.959, 709, 1.293, 742.990, 692, 6.134, 2118.764, 614, 4.109, 1478.867, 582, 4.540, 309.278, 495, 3.756, 323.505, 441, 2.958, 454.909, 417, 1.036, 2.448, 390, 4.897, 1692.166, 376, 4.703, 1368.660, 341, 5.715, 533.623, 330, 4.740, 0.048, 262, 1.877, 0.963, 261, 0.820, 380.128, 257, 3.724, 199.072, 244, 5.220, 728.763, 235, 1.227, 909.819, 220, 1.651, 543.918, 207, 1.855, 525.759, 202, 1.807, 1375.774, 197, 5.293, 1155.361, 175, 3.730, 942.062, 175, 3.226, 1898.351, 175, 5.910, 956.289, 158, 4.365, 1795.258, 151, 3.906, 74.782, 149, 4.377, 1685.052, 141, 3.136, 491.558, 138, 1.318, 1169.588, 131, 4.169, 1045.155, 117, 2.500, 1596.186, 117, 3.389, 0.521, 106, 4.554, 526.510, 100, 1.421, 532.872, 96, 1.18, 117.32, 92, 0.86, 1272.68, 88, 1.22, 453.42, 77, 4.43, 39.36, 72, 4.24, 2111.65, 70, 5.14, 835.04, 69, 2.35, 2.92, 67, 2.99, 2214.74, 66, 5.34, 1471.75, 63, 4.98, 0.75, 62, 0.51, 220.41, 60, 4.13, 4.19, 59, 4.11, 2001.44, 58, 5.87, 5753.38, 56, 1.15, 21.34, 54, 1.57, 983.12, 53, 0.91, 10.29, 52, 4.10, 1258.45, 47, 3.55, 5.42, 47, 4.79, 305.35, 46, 4.67, 5.63, 46, 5.11, 4.67, 43, 0.15, 528.21, 42, 4.68, 302.16, 40, 4.69, 0.16, 39, 4.25, 853.20, 39, 1.72, 11.05, 39, 6.08, 518.65, 38, 2.44, 433.71, 38, 0.21, 2648.45, 38, 6.19, 831.86, 36, 2.45, 430.53, 36, 4.61, 2008.56, 34, 1.01, 9683.59, 33, 5.29, 88.87, 32, 5.14, 1788.14, 31, 0.42, 1.48, 30, 3.67, 508.35, 30, 5.34, 2221.86, 28, 1.85, 0.21, 27, 2.81, 18.16, 27, 1.78, 532.14, 26, 2.74, 2531.13, 26, 3.86, 2317.84, 25, 2.63, 114.14, 24, 3.82, 1574.85, 24, 2.53, 494.27, 23, 3.24, 984.60, 23, 3.85, 2428.04, 22, 6.02, 1063.31, 21, 1.29, 35.42, 21, 4.03, 355.75, 20, 1.02, 628.85, 20, 5.60, 527.24, 19, 0.52, 14.98, 19, 4.86, 1361.55, 18, 4.30, 6.15, 17, 1.59, 1439.51, 16, 2.77, 760.26, 16, 5.27, 142.45, 16, 1.89, 529.64, 16, 5.09, 529.74, 16, 4.12, 636.72, 15, 6.08, 149.56, 15, 2.82, 621.74, 15, 4.86, 2104.54, 15, 0.88, 99.16, 15, 6.26, 569.05, 14, 2.41, 530.65, 14, 2.72, 0.26, 14, 3.56, 217.23, 13, 2.19, 1055.45, 13, 2.72, 1364.73, 13, 4.76, 528.73, 13, 1.39, 7.07, 12, 2.61, 405.26, 12, 4.30, 604.47, 12, 0.25, 1485.98, 12, 3.60, 2634.23, 12, 4.60, 7.16, 12, 2.35, 643.83, 11, 2.01, 1073.61, 11, 2.48, 423.42, 11, 4.05, 519.40, 11, 5.04, 458.84, 11, 5.09, 2324.95, 11, 2.51, 2847.53, 11, 2.08, 92.05, 11, 3.12, 1.27, 10, 3.63, 2744.43, 10, 2.09, 511.53, 10, 1.31, 1905.46, 10, 3.66, 107.02, 10, 4.06, 38.13, 10, 1.70, 1699.28, 10, 1.22, 32.24, +/*L1*/ 52993480757, 0.00000000000, 0.00000000000, 489741, 4.220667, 529.690965, 228919, 6.026475, 7.113547, 27655, 4.57266, 1059.38193, 20721, 5.45939, 522.57742, 12106, 0.16986, 536.80451, 6068, 4.4242, 103.0928, 5434, 3.9848, 419.4846, 4238, 5.8901, 14.2271, 2212, 5.2677, 206.1855, 1746, 4.9267, 1589.0729, 1296, 5.5513, 3.1814, 1173, 5.8565, 1052.2684, 1163, 0.5145, 3.9322, 1099, 5.3070, 515.4639, 1007, 0.4648, 735.8765, 1004, 3.1504, 426.5982, 848, 5.758, 110.206, 827, 4.803, 213.299, 816, 0.586, 1066.495, 725, 5.518, 639.897, 568, 5.989, 625.670, 474, 4.132, 412.371, 413, 5.737, 95.979, 345, 4.242, 632.784, 336, 3.732, 1162.475, 234, 4.035, 949.176, 234, 6.243, 309.278, 199, 1.505, 838.969, 195, 2.219, 323.505, 187, 6.086, 742.990, 184, 6.280, 543.918, 171, 5.417, 199.072, 131, 0.626, 728.763, 115, 0.680, 846.083, 115, 5.286, 2118.764, 108, 4.493, 956.289, 80, 5.82, 1045.15, 72, 5.34, 942.06, 70, 5.97, 532.87, 67, 5.73, 21.34, 66, 0.13, 526.51, 65, 6.09, 1581.96, 59, 0.59, 1155.36, 58, 0.99, 1596.19, 57, 5.97, 1169.59, 57, 1.41, 533.62, 55, 5.43, 10.29, 52, 5.73, 117.32, 52, 0.23, 1368.66, 50, 6.08, 525.76, 47, 3.63, 1478.87, 47, 0.51, 1265.57, 40, 4.16, 1692.17, 34, 0.10, 302.16, 33, 5.04, 220.41, 32, 5.37, 508.35, 29, 5.42, 1272.68, 29, 3.36, 4.67, 29, 0.76, 88.87, 25, 1.61, 831.86, 22, 6.15, 1685.05, 21, 5.86, 1258.45, 20, 2.17, 316.39, 18, 0.83, 433.71, 18, 5.96, 5.42, 18, 0.50, 1375.77, 17, 0.71, 1471.75, 17, 2.76, 853.20, 14, 0.91, 18.16, 14, 0.63, 2.92, 12, 1.76, 380.13, 12, 4.30, 405.26, 11, 5.57, 1574.85, 10, 0.31, 1361.55, 10, 0.39, 1073.61, 10, 5.90, 519.40, 9, 3.22, 1795.26, 9, 0.54, 1788.14, 8, 5.88, 2001.44, 8, 5.10, 1485.98, 8, 5.65, 2648.45, 7, 6.19, 11.05, 7, 2.41, 4.19, 6, 1.36, 1148.25, 6, 4.22, 2008.56, 6, 5.57, 191.96, 5, 4.40, 2221.86, 5, 1.46, 330.62, 5, 5.23, 628.85, 5, 2.93, 518.65, 5, 0.17, 629.60, 5, 0.79, 721.65, 5, 6.25, 1677.94, 5, 4.95, 635.97, 5, 2.07, 453.42, 4, 0.09, 1062.56, 4, 4.36, 423.42, 4, 0.15, 1699.28, 4, 4.14, 511.53, 4, 0.24, 2104.54, 4, 1.44, 2125.88, 4, 0.50, 1056.20, 4, 6.19, 636.72, 4, 2.55, 74.78, 4, 2.93, 32.24, 4, 5.67, 2317.84, 4, 0.25, 1055.45, 3, 5.89, 1802.37, 3, 4.61, 416.30, 3, 5.50, 107.02, 3, 1.09, 1464.64, 3, 5.73, 99.91, 3, 3.31, 0.75, 3, 1.61, 1063.31, 3, 1.25, 540.74, 3, 3.04, 422.67, 3, 4.29, 106.27, 3, 0.35, 1898.35, 3, 3.60, 750.10, +/*L2*/ 47234, 4.32148, 7.11355, 38966, 0.00000, 0.00000, 30629, 2.93021, 529.69097, 3189, 1.0550, 522.5774, 2729, 4.8455, 536.8045, 2723, 3.4141, 1059.3819, 1721, 4.1873, 14.2271, 383, 5.768, 419.485, 378, 0.760, 515.464, 367, 6.055, 103.093, 337, 3.786, 3.181, 308, 0.694, 206.186, 218, 3.814, 1589.073, 199, 5.340, 1066.495, 197, 2.484, 3.932, 156, 1.406, 1052.268, 146, 3.814, 639.897, 142, 1.634, 426.598, 130, 5.837, 412.371, 117, 1.414, 625.670, 97, 4.03, 110.21, 91, 1.11, 95.98, 87, 2.52, 632.78, 79, 4.64, 543.92, 72, 2.22, 735.88, 58, 0.83, 199.07, 57, 3.12, 213.30, 49, 1.67, 309.28, 40, 4.02, 21.34, 40, 0.62, 323.51, 36, 2.33, 728.76, 29, 3.61, 10.29, 28, 3.24, 838.97, 26, 4.50, 742.99, 26, 2.51, 1162.47, 25, 1.22, 1045.15, 24, 3.01, 956.29, 19, 4.29, 532.87, 18, 0.81, 508.35, 17, 4.20, 2118.76, 17, 1.83, 526.51, 15, 5.81, 1596.19, 15, 0.68, 942.06, 15, 4.00, 117.32, 14, 5.95, 316.39, 14, 1.80, 302.16, 13, 2.52, 88.87, 13, 4.37, 1169.59, 11, 4.44, 525.76, 10, 1.72, 1581.96, 9, 2.18, 1155.36, 9, 3.29, 220.41, 9, 3.32, 831.86, 8, 5.76, 846.08, 8, 2.71, 533.62, 7, 2.18, 1265.57, 6, 0.50, 949.18, 5, 6.01, 405.26, 5, 3.65, 1272.68, 5, 1.41, 1258.45, 4, 3.02, 1692.17, 4, 5.48, 433.71, 4, 2.27, 1368.66, 4, 5.07, 1073.61, 4, 5.29, 18.16, 4, 1.27, 853.20, 3, 1.54, 519.40, 3, 0.99, 191.96, 3, 2.05, 1361.55, 3, 2.10, 1478.87, 3, 1.06, 1574.85, 2, 2.37, 1471.75, 2, 3.03, 1148.25, 2, 2.48, 721.65, 2, 3.71, 1485.98, 2, 6.17, 330.62, 2, 1.88, 1685.05, 1, 5.15, 1375.77, 1, 4.72, 32.24, 1, 3.19, 635.97, 1, 1.99, 629.60, 1, 4.27, 551.03, 1, 1.28, 1038.04, 1, 4.02, 539.99, 1, 4.76, 1062.56, 1, 4.63, 2648.45, 1, 2.26, 1788.14, 1, 0.03, 2125.88, 1, 1.70, 1677.94, 1, 2.18, 1795.26, 1, 2.98, 81.75, 1, 5.06, 1699.28, 1, 0.14, 416.30, 1, 1.99, 295.05, 1, 3.75, 28.45, 1, 1.91, 750.10, 1, 2.81, 1464.64, 1, 3.01, 124.43, 1, 1.18, 99.91, 1, 3.53, 227.53, 1, 1.75, 1898.35, 1, 2.07, 1056.20, 1, 2.74, 618.56, 1, 6.25, 423.42, 1, 2.00, 2111.65, 1, 1.65, 2001.44, 1, 4.92, 1055.45, 1, 2.89, 2008.56, 1, 4.32, 1802.37, 1, 1.26, 1382.89, 1, 3.03, 2221.86, 1, 2.65, 106.27, 1, 3.30, 628.85, 1, 3.44, 824.74, 1, 0.08, 963.40, 1, 3.12, 5746.27, 1, 5.47, 5760.50, 1, 1.88, 2104.54, 1, 1.20, 422.67, 1, 4.68, 611.44, 1, 1.86, 636.72, 1, 4.54, 9676.48, 1, 0.61, 9690.71, 1, 2.84, 1905.46, 1, 3.08, 380.13, 1, 0.84, 1891.24, 1, 3.96, 440.83, 1, 1.56, 1994.33, 1, 2.55, 1781.03, 1, 1.11, 107.02, 1, 4.44, 647.01, +/*L3*/ 6502, 2.5986, 7.1135, 1357, 1.3464, 529.6910, 471, 2.475, 14.227, 417, 3.245, 536.805, 353, 2.974, 522.577, 155, 2.076, 1059.382, 87, 2.51, 515.46, 44, 0.00, 0.00, 34, 3.83, 1066.50, 28, 2.45, 206.19, 24, 1.28, 412.37, 23, 2.98, 543.92, 20, 2.10, 639.90, 20, 1.40, 419.48, 19, 1.59, 103.09, 17, 2.30, 21.34, 17, 2.60, 1589.07, 16, 3.15, 625.67, 16, 3.36, 1052.27, 13, 2.76, 95.98, 13, 2.54, 199.07, 13, 6.27, 426.60, 9, 1.76, 10.29, 9, 2.27, 110.21, 7, 3.43, 309.28, 7, 4.04, 728.76, 6, 2.52, 508.35, 5, 2.91, 1045.15, 5, 5.25, 323.51, 4, 4.30, 88.87, 4, 3.52, 302.16, 4, 4.09, 735.88, 3, 1.43, 956.29, 3, 4.36, 1596.19, 3, 1.25, 213.30, 3, 5.02, 838.97, 3, 2.24, 117.32, 2, 2.90, 742.99, 2, 2.36, 942.06, 2, 2.77, 1169.59, 2, 5.01, 831.86, 2, 1.40, 405.26, 1, 1.61, 220.41, 1, 3.09, 2118.76, 1, 3.98, 1155.36, 1, 3.46, 1073.61, 1, 3.39, 532.87, 1, 2.70, 191.96, 1, 1.48, 632.78, 1, 3.30, 1258.45, 1, 1.11, 1162.47, 1, 3.66, 1581.96, 1, 3.75, 433.71, 1, 5.90, 853.20, 1, 1.96, 1272.68, 1, 2.93, 1574.85, 1, 3.53, 525.76, 1, 2.02, 526.51, 1, 4.15, 721.65, 1, 4.69, 81.75, 1, 2.28, 551.03, 1, 4.36, 1368.66, 1, 1.57, 949.18, 1, 4.96, 1148.25, 1, 4.31, 330.62, +/*L4*/ 669, 0.853, 7.114, 114, 3.142, 0.000, 100, 0.743, 14.227, 50, 1.65, 536.80, 44, 5.82, 529.69, 32, 4.86, 522.58, 15, 4.29, 515.46, 9, 0.71, 1059.38, 5, 1.30, 543.92, 4, 2.32, 1066.50, 4, 0.48, 21.34, 3, 3.00, 412.37, 2, 0.40, 639.90, 2, 4.26, 199.07, 2, 4.91, 625.67, 2, 4.26, 206.19, 1, 5.26, 1052.27, 1, 4.72, 95.98, 1, 1.29, 1589.07, 1, 4.78, 1045.15, 1, 6.06, 88.87, 1, 5.78, 728.76, 1, 4.55, 426.60, 1, 3.40, 419.48, 1, 3.55, 103.09, 1, 0.52, 110.21, +/*L5*/ 50, 5.26, 7.11, 16, 5.25, 14.23, 4, 0.01, 536.80, 2, 1.10, 522.58, 1, 3.14, 0.00, 1, 5.86, 543.92, 1, 0.87, 515.46, +/*B0*/ 2268616, 3.5585261, 529.6909651, 110090, 0.000000, 0.000000, 109972, 3.908093, 1059.381930, 8101, 3.6051, 522.5774, 6438, 0.3063, 536.8045, 6044, 4.2588, 1589.0729, 1107, 2.9853, 1162.4747, 944, 1.675, 426.598, 942, 2.936, 1052.268, 894, 1.754, 7.114, 836, 5.179, 103.093, 767, 2.155, 632.784, 684, 3.678, 213.299, 629, 0.643, 1066.495, 559, 0.014, 846.083, 532, 2.703, 110.206, 464, 1.173, 949.176, 431, 2.608, 419.485, 351, 4.611, 2118.764, 132, 4.778, 742.990, 123, 3.350, 1692.166, 116, 1.387, 323.505, 115, 5.049, 316.392, 104, 3.701, 515.464, 103, 2.319, 1478.867, 102, 3.153, 1581.959, 79, 3.98, 1265.57, 70, 2.56, 956.29, 63, 4.50, 735.88, 56, 0.38, 1375.77, 55, 0.40, 525.76, 52, 0.99, 1596.19, 50, 0.19, 543.92, 49, 3.57, 533.62, 29, 5.43, 206.19, 28, 1.54, 625.67, 24, 6.11, 1169.59, 23, 5.95, 838.97, 23, 4.06, 526.51, 23, 6.19, 532.87, 21, 2.69, 1045.15, 21, 4.96, 2648.45, +/*B1*/ 177352, 5.701665, 529.690965, 3230, 5.7794, 1059.3819, 3081, 5.4746, 522.5774, 2212, 4.7348, 536.8045, 1694, 3.1416, 0.0000, 346, 4.746, 1052.268, 234, 5.189, 1066.495, 196, 6.186, 7.114, 150, 3.927, 1589.073, 114, 3.439, 632.784, 97, 2.91, 949.18, 82, 5.08, 1162.47, 77, 2.51, 103.09, 77, 0.61, 419.48, 74, 5.50, 515.46, 61, 5.45, 213.30, 50, 3.95, 735.88, 46, 0.54, 110.21, 45, 1.90, 846.08, 37, 4.70, 543.92, 36, 6.11, 316.39, 32, 4.92, 1581.96, 25, 3.94, 2118.76, 23, 5.85, 323.51, 21, 5.63, 1596.19, 17, 5.65, 533.62, 17, 5.67, 1265.57, 17, 5.90, 526.51, 16, 4.43, 1045.15, 13, 4.30, 532.87, 12, 4.30, 525.76, 12, 1.81, 956.29, 11, 6.16, 14.23, 10, 2.03, 206.19, 9, 4.87, 1155.36, 9, 1.56, 426.60, 8, 3.93, 1478.87, 8, 4.20, 1169.59, 8, 3.85, 625.67, 8, 2.99, 942.06, 6, 3.41, 639.90, 5, 0.83, 117.32, +/*B2*/ 8094, 1.4632, 529.6910, 813, 3.142, 0.000, 742, 0.957, 522.577, 399, 2.899, 536.805, 342, 1.447, 1059.382, 74, 0.41, 1052.27, 46, 3.48, 1066.50, 30, 1.93, 1589.07, 29, 0.99, 515.46, 23, 4.27, 7.11, 14, 2.92, 543.92, 12, 5.22, 632.78, 11, 4.88, 949.18, 6, 6.21, 1045.15, 6, 0.53, 1581.96, 5, 6.03, 735.88, 5, 1.43, 526.51, 5, 0.92, 1162.47, 5, 4.02, 1596.19, 4, 4.54, 110.21, 3, 1.39, 533.62, 3, 0.42, 419.48, 3, 4.40, 14.23, 3, 2.48, 2118.76, 3, 2.40, 532.87, 3, 2.06, 316.39, 3, 3.98, 323.51, 2, 0.88, 213.30, 2, 0.37, 1155.36, 2, 4.78, 942.06, 2, 3.89, 426.60, 2, 3.90, 846.08, 2, 1.20, 103.09, 2, 5.80, 625.67, 2, 2.24, 525.76, 2, 1.42, 1265.57, +/*B3*/ 252, 3.381, 529.691, 122, 2.733, 522.577, 49, 1.04, 536.80, 11, 2.31, 1052.27, 8, 2.77, 515.46, 7, 4.25, 1059.38, 6, 1.78, 1066.50, 4, 1.13, 543.92, 3, 3.14, 0.00, 2, 2.29, 7.11, 2, 1.78, 1045.15, 1, 0.45, 632.78, 1, 0.33, 1589.07, 1, 0.31, 949.18, 1, 1.53, 735.88, 1, 2.64, 14.23, 1, 2.37, 1581.96, 1, 2.48, 1596.19, +/*B4*/ 15, 4.53, 522.58, 5, 4.47, 529.69, 4, 5.44, 536.80, 3, 0.00, 0.00, 2, 4.52, 515.46, 1, 4.20, 1052.27, 1, 5.59, 543.92, 1, 0.06, 1066.50, +/*B5*/ 1, 0.09, 522.58, +/*R0*/ 520887429, 0.000000000, 0.000000000, 25209327, 3.49108640, 529.69096509, 610600, 3.841154, 1059.381930, 282029, 2.574199, 632.783739, 187647, 2.075904, 522.577418, 86793, 0.71001, 419.48464, 72063, 0.21466, 536.80451, 65517, 5.97996, 316.39187, 30135, 2.16132, 949.17561, 29135, 1.67759, 103.09277, 23947, 0.27458, 7.11355, 23453, 3.54023, 735.87651, 22284, 4.19363, 1589.07290, 13033, 2.96043, 1162.47470, 12749, 2.71550, 1052.26838, 9703, 1.9067, 206.1855, 9161, 4.4135, 213.2991, 7895, 2.4791, 426.5982, 7058, 2.1818, 1265.5675, 6138, 6.2642, 846.0828, 5477, 5.6573, 639.8973, 4170, 2.0161, 515.4639, 4137, 2.7222, 625.6702, 3503, 0.5653, 1066.4955, 2617, 2.0099, 1581.9593, 2500, 4.5518, 838.9693, 2128, 6.1275, 742.9901, 1912, 0.8562, 412.3711, 1611, 3.0887, 1368.6603, 1479, 2.6803, 1478.8666, 1231, 1.8904, 323.5054, 1217, 1.8017, 110.2063, 1015, 1.3867, 454.9094, 999, 2.872, 309.278, 961, 4.549, 2118.764, 886, 4.148, 533.623, 821, 1.593, 1898.351, 812, 5.941, 909.819, 777, 3.677, 728.763, 727, 3.988, 1155.361, 655, 2.791, 1685.052, 654, 3.382, 1692.166, 621, 4.823, 956.289, 615, 2.276, 942.062, 562, 0.081, 543.918, 542, 0.284, 525.759, 496, 5.530, 380.128, 470, 2.819, 1795.258, 458, 0.127, 1375.774, 445, 0.146, 14.227, 436, 2.603, 95.979, 346, 1.564, 491.558, 338, 2.799, 1045.155, 319, 1.348, 2214.743, 309, 5.369, 1272.681, 303, 1.154, 5753.385, 294, 2.049, 199.072, 291, 6.031, 1169.588, 291, 3.893, 1471.753, 277, 2.522, 2001.444, 275, 2.989, 526.510, 257, 6.134, 532.872, 239, 3.574, 835.037, 215, 2.636, 2111.650, 201, 2.373, 1258.454, 197, 5.929, 453.425, 192, 0.920, 1596.186, 191, 6.283, 983.116, 177, 2.577, 9683.595, 139, 3.640, 1788.145, 129, 1.106, 2531.135, 128, 4.666, 831.856, 124, 2.262, 2317.836, 120, 2.952, 3.932, 113, 4.862, 528.206, 112, 0.856, 433.712, 106, 5.815, 220.413, 104, 2.222, 74.782, 99, 4.50, 518.65, 94, 2.73, 853.20, 86, 2.11, 1574.85, 86, 2.34, 2428.04, 82, 3.23, 1361.55, 80, 0.89, 430.53, 77, 2.10, 508.35, 70, 3.22, 305.35, 70, 3.04, 302.16, 70, 0.20, 532.14, 68, 3.36, 2104.54, 64, 1.10, 1364.73, 60, 0.96, 494.27, 58, 5.72, 628.85, 58, 3.46, 2008.56, 57, 2.00, 2634.23, 57, 3.92, 2221.86, 54, 0.87, 2847.53, 53, 1.20, 760.26, 52, 4.02, 527.24, 49, 5.60, 2810.92, 46, 2.54, 636.72, 45, 4.90, 2648.45, 45, 1.62, 984.60, 44, 4.43, 1063.31, 44, 1.25, 621.74, 43, 0.03, 1439.51, 42, 0.32, 529.64, 42, 3.52, 529.74, 40, 2.10, 2744.43, 40, 4.39, 1148.25, 40, 2.46, 355.75, 39, 4.71, 569.05, 39, 4.32, 149.56, 38, 2.93, 1677.94, 37, 5.08, 1905.46, 37, 0.84, 530.65, 34, 3.09, 2420.93, 34, 0.76, 643.83, 33, 3.19, 528.73, 32, 2.73, 604.47, 32, 6.19, 3.18, 31, 5.36, 1485.98, 29, 1.84, 1891.24, 28, 2.48, 519.40, 27, 3.92, 2324.95, 27, 1.75, 2950.62, 27, 1.04, 405.26, 26, 0.60, 1055.45, 26, 1.34, 330.62, 26, 0.52, 511.53, 26, 3.46, 458.84, 24, 0.88, 423.42, 24, 5.00, 1289.95, 23, 5.27, 672.14, 23, 0.65, 3163.92, 22, 0.43, 1073.61, 22, 5.92, 1802.37, 22, 1.42, 540.74, 21, 3.08, 629.60, 20, 2.73, 39.36, 20, 4.14, 1464.64, 19, 1.86, 3060.83, 19, 5.17, 635.97, 19, 3.66, 415.55, 19, 3.69, 88.87, 19, 1.97, 38.13, 18, 1.90, 1021.25, 18, 3.60, 746.92, 18, 2.67, 1994.33, 17, 2.82, 2737.32, 17, 1.91, 217.23, 17, 5.67, 408.44, 16, 0.18, 1699.28, 16, 3.35, 1056.20, 16, 3.82, 721.65, 15, 1.06, 114.14, 15, 1.32, 117.32, 15, 3.74, 2641.34, 15, 1.33, 490.33, 15, 4.65, 6283.08, 15, 1.67, 529.17, 15, 0.80, 5223.69, 15, 2.17, 530.21, 14, 3.54, 142.45, 13, 1.49, 3267.01, 13, 3.97, 2538.25, 13, 0.74, 908.33, 12, 0.21, 1062.56, 12, 3.67, 750.10, 12, 1.72, 911.30, 12, 2.97, 505.31, 12, 1.67, 2207.63, 12, 5.12, 685.47, 12, 5.23, 524.06, 12, 1.60, 1474.67, +/*R1*/ 1271802, 2.6493751, 529.6909651, 61662, 3.00076, 1059.38193, 53444, 3.89718, 522.57742, 41390, 0.00000, 0.00000, 31185, 4.88277, 536.80451, 11847, 2.41330, 419.48464, 9166, 4.7598, 7.1135, 3404, 3.3469, 1589.0729, 3203, 5.2108, 735.8765, 3176, 2.7930, 103.0928, 2806, 3.7422, 515.4639, 2677, 4.3305, 1052.2684, 2600, 3.6344, 206.1855, 2412, 1.4695, 426.5982, 2101, 3.9276, 639.8973, 1646, 5.3095, 1066.4955, 1641, 4.4163, 625.6702, 1050, 3.1611, 213.2991, 1025, 2.5543, 412.3711, 806, 2.678, 632.784, 741, 2.171, 1162.475, 677, 6.250, 838.969, 567, 4.577, 742.990, 485, 2.469, 949.176, 469, 4.710, 543.918, 445, 0.403, 323.505, 416, 5.368, 728.763, 402, 4.605, 309.278, 347, 4.681, 14.227, 338, 3.168, 956.289, 261, 5.343, 846.083, 247, 3.923, 942.062, 220, 4.842, 1368.660, 203, 5.600, 1155.361, 200, 4.439, 1045.155, 197, 3.706, 2118.764, 196, 3.759, 199.072, 184, 4.265, 95.979, 180, 4.402, 532.872, 170, 4.846, 526.510, 146, 6.130, 533.623, 133, 1.322, 110.206, 132, 4.512, 525.759, 124, 2.043, 1478.867, 122, 4.406, 1169.588, 115, 4.467, 1581.959, 111, 3.625, 1272.681, 100, 5.247, 1265.567, 99, 5.73, 1596.19, 92, 4.53, 1685.05, 86, 0.08, 831.86, 82, 3.81, 508.35, 81, 4.11, 1258.45, 80, 2.72, 1692.17, 78, 5.57, 1471.75, 56, 4.75, 302.16, 55, 0.35, 316.39, 52, 5.53, 433.71, 51, 4.86, 1375.77, 49, 4.01, 220.41, 44, 4.94, 1361.55, 42, 1.22, 853.20, 38, 5.33, 1788.14, 38, 4.27, 2001.44, 36, 3.85, 1574.85, 36, 1.76, 1795.26, 29, 5.17, 3.93, 27, 6.10, 1148.25, 25, 4.34, 519.40, 25, 2.73, 405.26, 23, 0.19, 380.13, 20, 4.33, 3.18, 20, 4.63, 1677.94, 20, 5.11, 1073.61, 19, 5.05, 2104.54, 18, 6.03, 330.62, 18, 3.77, 1485.98, 17, 4.02, 2317.84, 17, 5.43, 88.87, 16, 2.93, 1905.46, 15, 2.93, 2008.56, 15, 5.51, 721.65, 14, 3.63, 628.85, 14, 2.74, 2221.86, 14, 4.88, 629.60, 13, 1.39, 518.65, 13, 5.84, 1464.64, 12, 1.59, 2111.65, 12, 3.38, 635.97, 12, 4.08, 2648.45, 11, 2.58, 511.53, 11, 3.55, 1891.24, 11, 4.63, 636.72, 10, 0.50, 453.42, 10, 2.76, 423.42, 10, 4.39, 1994.33, 9, 4.33, 1802.37, 9, 4.79, 2420.93, 9, 4.81, 1062.56, 9, 1.86, 750.10, 9, 5.16, 1056.20, 9, 4.54, 21.34, 8, 3.73, 2634.23, 8, 1.29, 2428.04, 7, 3.02, 416.30, 7, 4.98, 1699.28, 7, 4.98, 1898.35, 7, 4.99, 1055.45, 7, 5.97, 540.74, 7, 2.91, 2324.95, 7, 5.55, 1781.03, 7, 4.57, 1038.04, 6, 1.39, 422.67, 6, 6.14, 2125.88, 6, 4.46, 551.03, 6, 3.87, 191.96, 6, 3.66, 621.74, 6, 2.58, 569.05, 6, 4.23, 539.99, 5, 5.63, 618.56, 5, 4.91, 835.04, 5, 0.18, 117.32, 5, 6.22, 963.40, 5, 0.07, 1063.31, 5, 1.35, 1382.89, 5, 4.56, 2737.32, 5, 4.61, 643.83, 5, 3.35, 2207.63, 5, 4.24, 227.53, 5, 4.08, 2310.72, 4, 1.48, 408.44, 4, 0.19, 824.74, 4, 4.61, 647.01, 4, 2.38, 2538.25, 4, 1.13, 415.55, 4, 4.10, 430.53, 4, 1.15, 74.78, 4, 3.43, 2950.62, 4, 1.03, 2744.43, 4, 2.19, 534.36, 4, 4.12, 440.83, 4, 4.64, 2214.74, 4, 5.29, 2097.42, 4, 1.63, 525.03, +/*R2*/ 79645, 1.35866, 529.69097, 8252, 5.7777, 522.5774, 7030, 3.2748, 536.8045, 5314, 1.8384, 1059.3819, 1861, 2.9768, 7.1135, 964, 5.480, 515.464, 836, 4.199, 419.485, 498, 3.142, 0.000, 427, 2.228, 639.897, 406, 3.783, 1066.495, 377, 2.242, 1589.073, 363, 5.368, 206.186, 342, 6.099, 1052.268, 339, 6.127, 625.670, 333, 0.003, 426.598, 280, 4.262, 412.371, 257, 0.963, 632.784, 230, 0.705, 735.877, 201, 3.069, 543.918, 200, 4.429, 103.093, 139, 2.932, 14.227, 114, 0.787, 728.763, 95, 1.70, 838.97, 86, 5.14, 323.51, 83, 0.06, 309.28, 80, 2.98, 742.99, 75, 1.60, 956.29, 70, 1.51, 213.30, 67, 5.47, 199.07, 62, 6.10, 1045.15, 56, 0.96, 1162.47, 52, 5.58, 942.06, 50, 2.72, 532.87, 45, 5.52, 508.35, 44, 0.27, 526.51, 40, 5.95, 95.98, 30, 0.94, 1155.36, 29, 1.79, 831.86, 28, 2.88, 525.76, 27, 2.65, 2118.76, 27, 2.81, 1169.59, 26, 4.27, 1596.19, 23, 0.18, 302.16, 22, 1.89, 1272.68, 21, 4.35, 316.39, 21, 0.54, 1265.57, 20, 0.04, 949.18, 20, 1.16, 533.62, 20, 0.06, 1581.96, 18, 4.15, 846.08, 17, 5.89, 1258.45, 17, 0.53, 1368.66, 13, 0.79, 110.21, 13, 3.90, 433.71, 12, 2.23, 220.41, 12, 0.41, 1361.55, 12, 4.44, 405.26, 10, 1.00, 1471.75, 10, 6.01, 853.20, 9, 1.51, 1148.25, 9, 1.60, 1692.17, 9, 6.27, 519.40, 9, 3.52, 1073.61, 8, 5.60, 1574.85, 8, 0.18, 1685.05, 8, 0.65, 1478.87, 7, 0.88, 88.87, 7, 0.89, 721.65, 7, 4.44, 330.62, 6, 2.50, 3.18, 5, 0.85, 1788.14, 5, 2.79, 21.34, 5, 2.98, 1375.77, 5, 0.05, 1677.94, 5, 0.86, 3.93, 5, 2.28, 1485.98, 4, 1.28, 1464.64, 4, 0.41, 629.60, 4, 1.61, 635.97, 4, 2.71, 551.03, 3, 2.45, 539.99, 3, 0.55, 1795.26, 3, 1.19, 1905.46, 3, 6.19, 1038.04, 3, 5.55, 191.96, 3, 6.23, 2001.44, 3, 4.82, 416.30, 3, 0.55, 2104.54, 3, 3.24, 1062.56, 3, 0.03, 1898.35, 3, 1.24, 2221.86, 3, 2.40, 227.53, 2, 0.07, 750.10, 2, 4.28, 963.40, 2, 1.95, 824.74, 2, 6.19, 1994.33, 2, 1.72, 628.85, 2, 5.33, 1891.24, 2, 1.05, 1781.03, 2, 3.33, 1699.28, 2, 4.62, 423.42, 2, 0.29, 636.72, 2, 0.29, 2111.65, 2, 0.32, 295.05, 2, 3.44, 647.01, 2, 2.79, 1802.37, 2, 3.14, 611.44, 2, 1.12, 618.56, 2, 4.72, 2125.88, 2, 1.60, 2008.56, 2, 3.01, 2648.45, 2, 2.32, 440.83, 2, 5.89, 2317.84, 2, 2.42, 10.29, 2, 0.37, 1056.20, 2, 3.52, 1055.45, 2, 5.83, 422.67, 2, 5.76, 117.32, 1, 0.08, 1382.89, 1, 0.18, 2420.93, 1, 1.20, 1063.31, 1, 0.76, 2097.42, 1, 5.99, 2310.72, 1, 1.59, 380.13, 1, 4.20, 547.85, 1, 4.23, 934.95, 1, 3.86, 1603.30, 1, 1.35, 732.70, 1, 1.55, 2324.95, 1, 5.60, 99.91, 1, 6.18, 945.99, 1, 1.03, 81.75, 1, 0.09, 2737.32, 1, 2.54, 6283.08, 1, 1.15, 952.36, 1, 5.22, 2207.63, 1, 6.01, 511.53, 1, 3.03, 3046.60, 1, 2.71, 3370.10, 1, 6.01, 2214.74, 1, 5.00, 319.57, 1, 3.91, 10213.29, 1, 2.52, 3679.38, 1, 4.69, 5746.27, 1, 2.39, 3267.01, 1, 0.77, 5760.50, 1, 6.12, 9676.48, 1, 3.99, 337.73, 1, 2.19, 9690.71, 1, 1.12, 739.81, 1, 5.93, 2634.23, 1, 1.15, 2641.34, 1, 0.73, 1354.43, 1, 0.65, 2538.25, 1, 4.84, 860.31, 1, 4.23, 9683.59, 1, 1.20, 124.43, 1, 5.44, 107.02, 1, 0.90, 106.27, 1, 2.22, 2015.67, 1, 6.00, 501.24, 1, 5.12, 3156.81, 1, 1.24, 3803.82, 1, 2.43, 739.06, 1, 2.98, 1262.39, 1, 6.00, 1049.09, 1, 1.85, 453.42, 1, 6.19, 1987.22, 1, 5.33, 2751.55, 1, 4.92, 447.80, 1, 1.00, 462.02, 1, 4.77, 3473.20, 1, 5.61, 2524.02, 1, 5.82, 2627.11, 1, 2.43, 3686.50, 1, 3.89, 2516.91, 1, 3.55, 3178.15, 1, 3.29, 4.67, 1, 5.36, 9.56, +/*R3*/ 3519, 6.0580, 529.6910, 1073, 1.6732, 536.8045, 916, 1.413, 522.577, 342, 0.523, 1059.382, 255, 1.196, 7.114, 222, 0.952, 515.464, 90, 3.14, 0.00, 69, 2.27, 1066.50, 58, 1.41, 543.92, 58, 0.53, 639.90, 51, 5.98, 412.37, 47, 1.58, 625.67, 43, 6.12, 419.48, 37, 1.18, 14.23, 34, 1.67, 1052.27, 34, 0.85, 206.19, 31, 1.04, 1589.07, 30, 4.63, 426.60, 21, 2.50, 728.76, 15, 0.89, 199.07, 14, 0.96, 508.35, 13, 1.50, 1045.15, 12, 2.61, 735.88, 12, 3.56, 323.51, 11, 1.79, 309.28, 11, 6.28, 956.29, 10, 6.26, 103.09, 9, 3.45, 838.97, 7, 1.28, 742.99, 7, 0.92, 942.06, 7, 3.45, 831.86, 7, 1.87, 302.16, 6, 1.38, 95.98, 5, 2.83, 1596.19, 4, 1.21, 1169.59, 4, 5.99, 213.30, 4, 6.11, 405.26, 3, 2.33, 1155.36, 2, 0.35, 1272.68, 2, 1.87, 532.87, 2, 0.43, 220.41, 2, 5.97, 1162.47, 2, 1.95, 1073.61, 2, 0.09, 632.78, 2, 1.59, 2118.76, 2, 1.51, 1258.45, 2, 1.07, 21.34, 2, 2.16, 433.71, 2, 5.94, 110.21, 2, 3.17, 1148.25, 2, 2.55, 88.87, 2, 2.70, 721.65, 2, 2.26, 1361.55, 2, 1.98, 525.76, 2, 2.71, 330.62, 2, 0.44, 533.62, 2, 4.46, 853.20, 2, 0.47, 526.51, 2, 0.12, 949.18, 1, 0.67, 551.03, 1, 1.17, 1038.04, 1, 3.02, 963.40, 1, 1.16, 1574.85, 1, 2.55, 846.08, 1, 1.79, 1581.96, 1, 1.07, 227.53, 1, 2.70, 519.40, 1, 4.17, 2627.11, 1, 3.69, 824.74, 1, 4.91, 1670.83, 1, 2.93, 1368.66, 1, 0.60, 539.99, 1, 4.52, 750.10, 1, 0.94, 191.96, 1, 4.87, 611.44, 1, 0.21, 1141.13, 1, 3.23, 2125.88, 1, 2.39, 2317.84, 1, 2.25, 2538.25, 1, 5.80, 1485.98, 1, 2.27, 1699.28, 1, 0.67, 440.83, 1, 2.48, 1265.57, 1, 5.51, 2413.82, 1, 4.41, 1382.89, 1, 6.14, 1279.79, 1, 1.93, 2634.23, 1, 2.18, 1062.56, 1, 1.96, 1677.94, 1, 2.32, 1471.75, 1, 2.05, 295.05, 1, 2.50, 2207.63, 1, 0.19, 10.29, +/*R4*/ 129, 0.084, 536.805, 113, 4.249, 529.691, 83, 3.30, 522.58, 38, 2.73, 515.46, 27, 5.69, 7.11, 18, 5.40, 1059.38, 13, 6.02, 543.92, 9, 0.77, 1066.50, 8, 5.68, 14.23, 7, 1.43, 412.37, 6, 5.12, 639.90, 5, 3.34, 625.67, 3, 3.40, 1052.27, 3, 4.16, 728.76, 3, 2.90, 426.60, 2, 6.22, 1589.07, 2, 3.12, 1045.15, 2, 1.89, 419.48, 2, 2.60, 199.07, 2, 0.00, 0.00, 2, 2.81, 206.19, 2, 1.33, 1596.19, 1, 5.16, 831.86, 1, 4.42, 956.29, 1, 5.47, 220.41, 1, 0.67, 1361.55, 1, 1.87, 1148.25, 1, 3.17, 508.35, 1, 5.79, 1169.59, 1, 1.48, 1272.68, 1, 2.42, 117.32, 1, 2.20, 942.06, 1, 5.31, 551.03, 1, 0.50, 1073.61, 1, 2.85, 191.96, 1, 3.72, 88.87, 1, 3.53, 302.16, 1, 1.84, 10.29, 1, 1.59, 3.18, 1, 3.82, 618.56, 1, 0.86, 330.62, 1, 5.26, 21.34, 1, 1.83, 647.01, 1, 0.24, 433.71, 1, 4.44, 110.21, +/*R5*/ 11, 4.75, 536.80, 4, 5.92, 522.58, 2, 5.57, 515.46, 2, 4.30, 543.92, 2, 3.69, 7.11, 2, 4.13, 1059.38, 2, 5.49, 1066.50, 1, 3.78, 14.23, 1, 4.51, 529.69 }; + +//Dsat精度:J2000+-4千年 黄经0.5角秒 黄纬0.5角秒 距离5AU/10^6 +static constexpr long double XL0_5[] = { +100000000,//A的倍率 +20, 806, 1406, 1946, 2177, 2282, 2333, 2537, 2726, 2867, 2963, 3008, 3026, 4091, 5063, 5789, 6260, 6452, 6536,//位置索引表 +/*L0*/ 87401354, 0.00000000, 0.00000000, 11107660, 3.96205090, 213.29909544, 1414151, 4.5858152, 7.1135470, 398379, 0.521120, 206.185548, 350769, 3.303299, 426.598191, 206816, 0.246584, 103.092774, 79271, 3.84007, 220.41264, 23990, 4.66977, 110.20632, 16574, 0.43719, 419.48464, 15820, 0.93809, 632.78374, 15054, 2.71670, 639.89729, 14907, 5.76903, 316.39187, 14610, 1.56519, 3.93215, 13160, 4.44891, 14.22709, 13005, 5.98119, 11.04570, 10725, 3.12940, 202.25340, 6126, 1.7633, 277.0350, 5863, 0.2366, 529.6910, 5228, 4.2078, 3.1814, 5020, 3.1779, 433.7117, 4593, 0.6198, 199.0720, 4006, 2.2448, 63.7359, 3874, 3.2228, 138.5175, 3269, 0.7749, 949.1756, 2954, 0.9828, 95.9792, 2461, 2.0316, 735.8765, 1758, 3.2658, 522.5774, 1640, 5.5050, 846.0828, 1581, 4.3727, 309.2783, 1391, 4.0233, 323.5054, 1124, 2.8373, 415.5525, 1087, 4.1834, 2.4477, 1017, 3.7170, 227.5262, 957, 0.507, 1265.567, 853, 3.421, 175.166, 849, 3.191, 209.367, 789, 5.007, 0.963, 749, 2.144, 853.196, 744, 5.253, 224.345, 687, 1.747, 1052.268, 654, 1.599, 0.048, 634, 2.299, 412.371, 625, 0.970, 210.118, 580, 3.093, 74.782, 546, 2.127, 350.332, 543, 1.518, 9.561, 530, 4.449, 117.320, 478, 2.965, 137.033, 474, 5.475, 742.990, 452, 1.044, 490.334, 449, 1.290, 127.472, 372, 2.278, 217.231, 355, 3.013, 838.969, 347, 1.539, 340.771, 343, 0.246, 0.521, 330, 0.247, 1581.959, 322, 0.961, 203.738, 322, 2.572, 647.011, 309, 3.495, 216.480, 287, 2.370, 351.817, 278, 0.400, 211.815, 249, 1.470, 1368.660, 227, 4.910, 12.530, 220, 4.204, 200.769, 209, 1.345, 625.670, 208, 0.483, 1162.475, 208, 1.283, 39.357, 205, 6.011, 265.989, 185, 3.503, 149.563, 184, 0.973, 4.193, 182, 5.491, 2.921, 174, 1.863, 0.751, 165, 0.440, 5.417, 149, 5.736, 52.690, 148, 1.535, 5.629, 146, 6.231, 195.140, 140, 4.295, 21.341, 131, 4.068, 10.295, 125, 6.277, 1898.351, 122, 1.976, 4.666, 118, 5.341, 554.070, 117, 2.679, 1155.361, 114, 5.594, 1059.382, 112, 1.105, 191.208, 110, 0.166, 1.484, 109, 3.438, 536.805, 107, 4.012, 956.289, 104, 2.192, 88.866, 103, 1.197, 1685.052, 101, 4.965, 269.921, 97, 4.54, 302.16, 96, 2.83, 275.55, 91, 1.88, 38.13, 90, 5.80, 114.14, 89, 3.86, 278.52, 84, 5.49, 0.11, 83, 2.29, 628.85, 82, 3.05, 440.83, 79, 4.45, 35.42, 76, 1.61, 284.15, 75, 2.18, 728.76, 74, 5.09, 1375.77, 72, 5.11, 65.22, 70, 4.87, 0.21, 70, 3.71, 14.98, 69, 3.44, 515.46, 68, 0.73, 1478.87, 67, 0.03, 70.85, 66, 2.02, 142.45, 64, 3.32, 62.25, 63, 3.49, 479.29, 63, 2.59, 422.67, 61, 1.50, 210.85, 61, 2.69, 388.47, 55, 0.97, 942.06, 54, 2.46, 22.09, 54, 0.78, 191.96, 53, 3.18, 8.08, 53, 5.51, 0.26, 51, 4.27, 99.16, 50, 6.03, 2214.74, 49, 2.39, 1471.75, 47, 2.03, 312.20, 47, 4.60, 437.64, 46, 0.54, 212.34, 45, 0.93, 2001.44, 45, 1.12, 6.15, 44, 3.93, 525.50, 43, 2.53, 288.08, 43, 1.37, 563.63, 43, 3.82, 330.62, 42, 1.90, 430.53, 40, 5.71, 408.44, 40, 1.63, 1066.50, 38, 0.31, 423.42, 38, 1.20, 2.71, 38, 3.70, 1272.68, 38, 4.52, 24.38, 36, 6.01, 18.16, 36, 0.85, 213.35, 36, 3.93, 213.25, 35, 4.19, 215.75, 35, 4.46, 214.26, 35, 1.02, 203.00, 33, 0.54, 107.02, 33, 0.66, 692.59, 33, 0.81, 1795.26, 32, 5.22, 92.05, 32, 5.59, 6069.78, 32, 1.69, 0.16, 32, 5.50, 56.62, 31, 0.37, 703.63, 31, 6.14, 417.04, 30, 0.72, 222.86, 30, 5.30, 33.94, 29, 0.15, 131.40, 29, 1.20, 404.51, 28, 5.64, 128.96, 28, 1.46, 7.16, 27, 6.23, 1.27, 27, 1.90, 1045.15, 27, 0.07, 205.22, 27, 4.57, 7.07, 26, 5.41, 140.00, 26, 4.36, 32.24, 24, 3.09, 145.63, 24, 3.94, 414.07, 24, 2.54, 76.27, 23, 3.97, 483.22, 23, 2.10, 1788.14, 23, 3.20, 208.63, 23, 3.66, 207.67, 23, 6.10, 177.87, 23, 5.24, 212.78, 22, 5.92, 173.94, 21, 0.72, 1258.45, 21, 5.79, 2531.13, 21, 2.02, 860.31, 21, 0.67, 2317.84, 21, 5.22, 6.59, 20, 2.82, 429.78, 20, 5.07, 617.81, 19, 1.64, 565.12, 19, 5.94, 425.11, 19, 5.78, 213.82, 18, 0.73, 9999.99, 18, 5.23, 73.30, 18, 6.11, 210.38, 18, 3.14, 831.86, 17, 0.24, 134.59, 17, 0.72, 2111.65, 17, 3.28, 98.90, 16, 3.97, 355.75, 16, 3.10, 106.27, 15, 3.29, 1589.07, 15, 3.25, 78.71, 15, 5.19, 305.35, 15, 2.75, 1.22, 14, 3.88, 54.17, 14, 4.52, 59.80, 14, 1.72, 69.15, 14, 6.18, 245.54, 14, 2.37, 125.99, 14, 2.55, 405.26, 14, 2.54, 1.70, 14, 3.59, 234.64, 13, 0.83, 99.91, 13, 4.17, 225.83, 13, 6.01, 214.78, 13, 4.69, 767.37, 13, 5.31, 344.70, 12, 2.12, 28.31, 12, 3.60, 124.43, 12, 1.62, 1361.55, 12, 4.07, 280.97, 12, 4.00, 267.47, 12, 0.12, 7.63, 12, 2.79, 362.86, 11, 5.51, 192.69, 11, 1.82, 2104.54, 11, 2.62, 7.86, 11, 2.61, 339.29, 11, 5.51, 199.28, 11, 3.58, 1.44, 11, 0.19, 217.49, 11, 2.37, 831.10, 10, 2.84, 85.83, 10, 1.69, 31.02, 10, 4.72, 216.22, 10, 0.22, 198.32, 10, 0.22, 144.15, 10, 3.61, 14.01, 10, 3.94, 207.88, 10, 4.02, 207.15, 10, 0.42, 2634.23, 10, 1.61, 0.89, 10, 3.67, 212.55, 10, 3.34, 223.59, 10, 0.64, 218.93, 9, 0.72, 347.88, 9, 4.26, 20.61, 9, 5.40, 342.26, 9, 4.28, 312.46, 9, 5.08, 241.61, 9, 4.25, 46.47, 9, 1.65, 210.33, 9, 0.91, 497.45, 9, 5.81, 329.73, 9, 4.23, 6.36, 9, 0.57, 2428.04, 9, 5.36, 343.22, 9, 5.55, 2847.53, 9, 4.48, 1692.17, 9, 0.49, 1574.85, 8, 4.06, 237.68, 8, 0.81, 264.50, 8, 4.71, 333.66, 8, 2.73, 4.14, 8, 3.82, 380.13, 8, 5.54, 116.43, 8, 5.63, 518.65, 8, 5.44, 621.74, +/*L1*/ 21354295596, 0.00000000000, 0.00000000000, 1296855, 1.8282054, 213.2990954, 564348, 2.885001, 7.113547, 107679, 2.277699, 206.185548, 98323, 1.08070, 426.59819, 40255, 2.04128, 220.41264, 19942, 1.27955, 103.09277, 10512, 2.74880, 14.22709, 6939, 0.4049, 639.8973, 4803, 2.4419, 419.4846, 4056, 2.9217, 110.2063, 3769, 3.6497, 3.9322, 3385, 2.4169, 3.1814, 3302, 1.2626, 433.7117, 3071, 2.3274, 199.0720, 1953, 3.5639, 11.0457, 1249, 2.6280, 95.9792, 922, 1.961, 227.526, 706, 4.417, 529.691, 650, 6.174, 202.253, 628, 6.111, 309.278, 487, 6.040, 853.196, 479, 4.988, 522.577, 468, 4.617, 63.736, 417, 2.117, 323.505, 408, 1.299, 209.367, 352, 2.317, 632.784, 344, 3.959, 412.371, 340, 3.634, 316.392, 336, 3.772, 735.877, 332, 2.861, 210.118, 289, 2.733, 117.320, 281, 5.744, 2.448, 266, 0.543, 647.011, 230, 1.644, 216.480, 192, 2.965, 224.345, 173, 4.077, 846.083, 167, 2.597, 21.341, 136, 2.286, 10.295, 131, 3.441, 742.990, 128, 4.095, 217.231, 109, 6.161, 415.552, 98, 4.73, 838.97, 94, 3.48, 1052.27, 92, 3.95, 88.87, 87, 1.22, 440.83, 83, 3.11, 625.67, 78, 6.24, 302.16, 67, 0.29, 4.67, 66, 5.65, 9.56, 62, 4.29, 127.47, 62, 1.83, 195.14, 58, 2.48, 191.96, 57, 5.02, 137.03, 55, 0.28, 74.78, 54, 5.13, 490.33, 51, 1.46, 536.80, 47, 1.18, 149.56, 47, 5.15, 515.46, 46, 2.23, 956.29, 44, 2.71, 5.42, 40, 0.41, 269.92, 40, 3.89, 728.76, 38, 0.65, 422.67, 38, 2.53, 12.53, 37, 3.78, 2.92, 35, 6.08, 5.63, 34, 3.21, 1368.66, 33, 4.64, 277.03, 33, 5.43, 1066.50, 33, 0.30, 351.82, 32, 4.39, 1155.36, 31, 2.43, 52.69, 30, 2.84, 203.00, 30, 6.19, 284.15, 30, 3.39, 1059.38, 29, 2.03, 330.62, 28, 2.74, 265.99, 26, 4.51, 340.77, 23, 4.14, 191.21, 23, 5.89, 210.85, 22, 1.96, 203.74, 22, 5.14, 4.19, 22, 2.68, 942.06, 21, 6.16, 860.31, 20, 2.31, 437.64, 19, 4.77, 70.85, 19, 4.10, 18.16, 18, 0.90, 429.78, 18, 1.85, 234.64, 18, 2.45, 423.42, 17, 5.97, 628.85, 16, 4.06, 949.18, 16, 1.94, 1272.68, 16, 1.06, 56.62, 16, 5.59, 6.15, 15, 4.24, 1162.47, 15, 0.74, 200.77, 15, 5.77, 22.09, 15, 3.60, 1045.15, 14, 2.94, 1685.05, 14, 1.44, 408.44, 14, 4.10, 1471.75, 13, 6.25, 38.13, 13, 5.76, 138.52, 13, 4.25, 405.26, 12, 4.85, 831.86, 12, 1.86, 131.40, 12, 1.81, 124.43, 11, 1.55, 223.59, 11, 5.37, 215.75, 10, 3.47, 1375.77, 10, 6.08, 32.24, 10, 2.38, 107.02, 10, 3.95, 430.53, 10, 2.55, 99.91, 10, 1.39, 145.63, 9, 5.81, 7.16, 9, 3.65, 142.45, 9, 4.95, 208.63, 9, 1.24, 106.27, 9, 0.08, 288.08, 8, 4.42, 703.63, 8, 5.64, 62.25, 8, 2.42, 1258.45, 8, 6.22, 14.98, 8, 0.53, 654.12, 8, 3.75, 312.20, 7, 4.85, 222.86, 7, 0.28, 0.75, 7, 0.53, 388.47, 7, 2.05, 99.16, 7, 0.24, 8.08, 7, 5.83, 483.22, 7, 3.49, 35.42, 6, 2.89, 114.14, 6, 3.33, 1361.55, 6, 3.81, 1788.14, 6, 0.55, 65.22, 6, 1.63, 1589.07, 6, 2.68, 2001.44, 6, 0.89, 92.05, 6, 4.39, 81.75, 5, 5.48, 563.63, 5, 4.58, 134.59, 5, 2.12, 214.26, 5, 4.68, 212.34, 5, 3.34, 1.48, 5, 5.77, 565.12, 5, 2.20, 207.88, 5, 4.20, 404.51, 5, 0.42, 76.27, 5, 3.78, 1265.57, 5, 0.46, 362.86, 5, 4.53, 1148.25, 5, 4.59, 554.07, 5, 5.80, 217.96, 5, 3.25, 231.46, 5, 5.38, 497.45, 4, 0.11, 295.05, 4, 1.80, 213.25, 4, 5.00, 213.35, 4, 4.88, 98.90, 4, 0.59, 750.10, 4, 0.99, 24.38, 4, 0.82, 344.70, 4, 0.81, 343.22, 4, 5.13, 218.93, 4, 1.61, 245.54, 4, 0.35, 333.66, 3, 5.30, 350.33, 3, 1.85, 225.83, 3, 2.20, 1574.85, 3, 5.31, 347.88, 3, 0.21, 635.97, 3, 2.88, 216.22, 3, 1.72, 1169.59, 3, 1.92, 17.41, 3, 3.04, 1677.94, 3, 4.31, 6062.66, 3, 1.34, 543.92, 3, 0.25, 120.36, 3, 3.36, 7.86, 3, 2.53, 1692.17, 3, 2.49, 46.47, 3, 3.53, 2104.54, 3, 4.87, 144.15, 3, 5.73, 9992.87, 3, 3.73, 6076.89, 3, 0.24, 357.45, 3, 2.43, 2317.84, 3, 5.76, 618.56, 3, 5.15, 10007.10, 3, 0.72, 85.83, 3, 3.43, 31.02, 3, 3.80, 17.27, 3, 1.63, 182.28, 3, 0.92, 479.29, 3, 4.52, 198.32, 3, 2.11, 168.05, +/*L2*/ 116441, 1.179879, 7.113547, 91921, 0.07425, 213.29910, 90592, 0.00000, 0.00000, 15277, 4.06492, 206.18555, 10631, 0.25778, 220.41264, 10605, 5.40964, 426.59819, 4265, 1.0460, 14.2271, 1216, 2.9186, 103.0928, 1165, 4.6094, 639.8973, 1082, 5.6913, 433.7117, 1045, 4.0421, 199.0720, 1020, 0.6337, 3.1814, 634, 4.388, 419.485, 549, 5.573, 3.932, 457, 1.268, 110.206, 425, 0.209, 227.526, 274, 4.288, 95.979, 162, 1.381, 11.046, 129, 1.566, 309.278, 117, 3.881, 853.196, 105, 4.900, 647.011, 101, 0.893, 21.341, 96, 2.91, 316.39, 95, 5.63, 412.37, 85, 5.73, 209.37, 83, 6.05, 216.48, 82, 1.02, 117.32, 75, 4.76, 210.12, 67, 0.46, 522.58, 66, 0.48, 10.29, 64, 0.35, 323.51, 61, 4.88, 632.78, 53, 2.75, 529.69, 46, 5.69, 440.83, 45, 1.67, 202.25, 42, 5.71, 88.87, 32, 0.07, 63.74, 32, 1.67, 302.16, 31, 4.16, 191.96, 27, 0.83, 224.34, 25, 5.66, 735.88, 20, 5.94, 217.23, 18, 4.90, 625.67, 17, 1.63, 742.99, 16, 0.58, 515.46, 14, 0.21, 838.97, 14, 3.76, 195.14, 12, 4.72, 203.00, 12, 0.13, 234.64, 12, 3.12, 846.08, 11, 5.92, 536.80, 11, 5.60, 728.76, 11, 3.20, 1066.50, 10, 4.99, 422.67, 10, 0.26, 330.62, 10, 4.15, 860.31, 9, 0.46, 956.29, 8, 2.14, 269.92, 8, 5.25, 429.78, 8, 4.03, 9.56, 7, 5.40, 1052.27, 6, 4.46, 284.15, 6, 5.93, 405.26, 6, 5.41, 149.56, 6, 4.29, 415.55, 6, 0.02, 124.43, 6, 6.02, 223.59, 6, 0.30, 127.47, 5, 5.54, 949.18, 5, 3.20, 277.03, 5, 4.93, 654.12, 5, 2.27, 18.16, 5, 6.14, 1155.36, 5, 4.41, 942.06, 4, 2.89, 56.62, 4, 4.69, 74.78, 4, 5.31, 1045.15, 4, 0.29, 831.86, 4, 0.37, 12.53, 4, 6.10, 81.75, 4, 3.30, 490.33, 4, 4.93, 52.69, 4, 0.41, 137.03, 4, 0.15, 437.64, 4, 0.20, 1272.68, 3, 4.77, 423.42, 3, 4.29, 99.91, 3, 1.57, 1059.38, 3, 3.13, 70.85, 3, 0.33, 191.21, 3, 3.38, 408.44, 3, 1.88, 295.05, 3, 5.15, 1368.66, 3, 3.59, 131.40, 3, 5.12, 265.99, 2, 1.59, 32.24, 2, 3.90, 210.85, 2, 5.83, 106.27, 2, 4.77, 351.82, 2, 3.14, 22.09, 2, 5.98, 6062.66, 2, 2.06, 6076.89, 2, 5.95, 145.63, 2, 5.23, 1265.57, 2, 1.12, 9992.87, 2, 3.48, 10007.10, 2, 5.87, 1471.75, 2, 4.52, 138.52, 2, 4.15, 1258.45, 2, 5.05, 1361.55, 2, 4.14, 107.02, 2, 1.36, 231.46, 2, 6.24, 1148.25, 2, 3.75, 628.85, 2, 5.62, 447.94, 2, 5.97, 430.53, 1, 0.48, 340.77, 1, 0.85, 6069.78, 1, 2.91, 215.75, 1, 0.71, 28.45, 1, 2.28, 9999.99, 1, 5.84, 543.92, 1, 6.24, 1589.07, 1, 2.83, 200.77, 1, 3.52, 497.45, 1, 0.72, 508.35, 1, 2.61, 1279.79, 1, 4.96, 1685.05, 1, 1.20, 618.56, 1, 4.53, 635.97, 1, 1.09, 184.84, 1, 2.41, 703.63, 1, 3.40, 1073.61, 1, 4.91, 750.10, 1, 1.39, 483.22, 1, 1.59, 1375.77, 1, 2.66, 134.59, 1, 4.21, 288.08, 1, 4.68, 362.86, 1, 2.43, 222.86, 1, 4.52, 38.13, 1, 5.01, 1581.96, 1, 5.59, 1788.14, 1, 0.77, 113.39, 1, 4.80, 1677.94, 1, 2.22, 333.66, 1, 5.95, 1464.64, 1, 4.49, 643.08, 1, 5.82, 416.30, 1, 2.51, 343.22, 1, 3.97, 1574.85, 1, 4.84, 76.27, 1, 6.00, 337.73, 1, 2.28, 1162.47, 1, 2.35, 120.36, 1, 3.67, 347.88, 1, 0.01, 1169.59, 1, 0.21, 99.16, 1, 2.89, 92.05, 1, 5.63, 17.27, 1, 3.76, 203.74, 1, 5.75, 721.65, 1, 3.78, 217.96, 1, 0.68, 46.47, 1, 4.86, 357.45, 1, 5.27, 436.89, 1, 3.27, 208.63, 1, 3.88, 565.12, 1, 5.99, 1905.46, 1, 3.69, 350.33, 1, 4.96, 358.93, 1, 0.31, 98.90, 1, 1.22, 62.25, 1, 0.87, 1692.17, 1, 6.17, 182.28, 1, 2.59, 313.21, 1, 1.54, 195.89, 1, 5.42, 312.20, 1, 4.71, 2001.44, 1, 3.81, 168.05, +/*L3*/ 16039, 5.73945, 7.11355, 4250, 4.5854, 213.2991, 1907, 4.7608, 220.4126, 1466, 5.9133, 206.1855, 1162, 5.6197, 14.2271, 1067, 3.6082, 426.5982, 239, 3.861, 433.712, 237, 5.768, 199.072, 166, 5.116, 3.181, 151, 2.736, 639.897, 131, 4.743, 227.526, 63, 0.23, 419.48, 62, 4.74, 103.09, 40, 5.47, 21.34, 40, 5.96, 95.98, 39, 5.83, 110.21, 28, 3.01, 647.01, 25, 0.99, 3.93, 19, 1.92, 853.20, 18, 4.97, 10.29, 18, 1.03, 412.37, 18, 4.20, 216.48, 18, 3.32, 309.28, 16, 3.90, 440.83, 16, 5.62, 117.32, 13, 1.18, 88.87, 11, 5.58, 11.05, 11, 5.93, 191.96, 10, 3.95, 209.37, 9, 3.39, 302.16, 8, 4.88, 323.51, 7, 0.38, 632.78, 6, 2.25, 522.58, 6, 1.06, 210.12, 5, 4.64, 234.64, 4, 3.14, 0.00, 4, 2.31, 515.46, 3, 2.20, 860.31, 3, 0.59, 529.69, 3, 4.93, 224.34, 3, 0.42, 625.67, 2, 4.77, 330.62, 2, 3.35, 429.78, 2, 3.20, 202.25, 2, 1.19, 1066.50, 2, 1.35, 405.26, 2, 4.16, 223.59, 2, 3.07, 654.12, 2, 1.03, 728.76, 2, 4.40, 124.43, 2, 3.09, 422.67, 2, 4.15, 536.80, 2, 5.83, 195.14, 2, 6.04, 742.99, 1, 0.38, 316.39, 1, 1.58, 81.75, 1, 2.11, 838.97, 1, 1.38, 735.88, 1, 2.33, 217.23, 1, 5.02, 956.29, 1, 1.66, 63.74, 1, 3.88, 269.92, 1, 3.73, 295.05, 1, 2.76, 284.15, 1, 3.31, 18.16, 1, 2.02, 831.86, 1, 0.71, 846.08, 1, 3.84, 447.94, 1, 4.71, 56.62, 1, 0.80, 1045.15, 1, 2.41, 203.00, 1, 4.27, 437.64, 1, 1.65, 423.42, 1, 6.18, 942.06, 1, 2.86, 184.84, 1, 6.26, 1059.38, 1, 3.43, 149.56, +/*L4*/ 1662, 3.9983, 7.1135, 257, 2.984, 220.413, 236, 3.902, 14.227, 149, 2.741, 213.299, 114, 3.142, 0.000, 110, 1.515, 206.186, 68, 1.72, 426.60, 40, 2.05, 433.71, 38, 1.24, 199.07, 31, 3.01, 227.53, 15, 0.83, 639.90, 9, 3.71, 21.34, 6, 2.42, 419.48, 6, 1.16, 647.01, 4, 1.45, 95.98, 4, 2.12, 440.83, 3, 4.09, 110.21, 3, 2.77, 412.37, 3, 3.01, 88.87, 3, 0.00, 853.20, 3, 0.39, 103.09, 2, 3.78, 117.32, 2, 2.83, 234.64, 2, 5.08, 309.28, 2, 2.24, 216.48, 2, 5.19, 302.16, 1, 1.55, 191.96, 1, 3.45, 323.51, 1, 4.83, 210.12, 1, 2.29, 209.37, 1, 0.30, 860.31, 1, 2.38, 632.78, 1, 4.03, 522.58, 1, 4.19, 515.46, 1, 2.17, 124.43, +/*L5*/ 124, 2.259, 7.114, 34, 2.16, 14.23, 28, 1.20, 220.41, 6, 1.22, 227.53, 5, 0.24, 433.71, 4, 6.23, 426.60, 3, 2.97, 199.07, 3, 4.29, 206.19, 2, 6.25, 213.30, 1, 5.28, 639.90, 1, 0.24, 440.83, 1, 3.14, 0.00, 1, 5.57, 647.01, 1, 0.69, 302.16, 1, 6.18, 191.96, 1, 4.88, 88.87, 1, 4.78, 419.48, +/*B0*/ 4330678, 3.6028443, 213.2990954, 240348, 2.852385, 426.598191, 84746, 0.00000, 0.00000, 34116, 0.57297, 206.18555, 30863, 3.48442, 220.41264, 14734, 2.11847, 639.89729, 9917, 5.7900, 419.4846, 6994, 4.7360, 7.1135, 4808, 5.4331, 316.3919, 4788, 4.9651, 110.2063, 3432, 2.7326, 433.7117, 1506, 6.0130, 103.0928, 1060, 5.6310, 529.6910, 969, 5.204, 632.784, 942, 1.396, 853.196, 708, 3.803, 323.505, 552, 5.131, 202.253, 400, 3.359, 227.526, 319, 3.626, 209.367, 316, 1.997, 647.011, 314, 0.465, 217.231, 284, 4.886, 224.345, 236, 2.139, 11.046, 215, 5.950, 846.083, 209, 2.120, 415.552, 207, 0.730, 199.072, 179, 2.954, 63.736, 141, 0.644, 490.334, 139, 4.595, 14.227, 139, 1.998, 735.877, 135, 5.245, 742.990, 122, 3.115, 522.577, 116, 3.109, 216.480, 114, 0.963, 210.118, 96, 4.48, 117.32, 81, 1.32, 277.03, 74, 2.89, 149.56, 73, 3.06, 536.80, 69, 4.92, 309.28, 68, 2.18, 351.82, 62, 0.68, 1066.50, 57, 2.61, 440.83, 49, 5.79, 95.98, 48, 2.18, 74.78, 38, 5.29, 1059.38, 37, 6.28, 1162.47, 36, 1.63, 628.85, 35, 1.71, 1052.27, 34, 5.98, 412.37, 34, 2.46, 422.67, 34, 1.14, 949.18, 32, 4.15, 437.64, 27, 1.27, 860.31, 24, 3.07, 215.75, 24, 4.11, 3.93, 24, 2.75, 838.97, 23, 0.99, 210.85, 21, 0.14, 430.53, 21, 3.51, 330.62, 20, 2.82, 127.47, 19, 2.98, 137.03, 19, 6.27, 423.42, 18, 2.29, 388.47, 18, 6.20, 703.63, 17, 3.90, 214.26, 17, 0.17, 212.34, 17, 1.67, 38.13, 16, 4.55, 956.29, +/*B1*/ 397555, 5.332900, 213.299095, 49479, 3.14159, 0.00000, 18572, 6.09919, 426.59819, 14801, 2.30586, 206.18555, 9644, 1.6967, 220.4126, 3757, 1.2543, 419.4846, 2717, 5.9117, 639.8973, 1455, 0.8516, 433.7117, 1291, 2.9177, 7.1135, 853, 0.436, 316.392, 298, 0.919, 632.784, 292, 5.316, 853.196, 284, 1.619, 227.526, 275, 3.889, 103.093, 172, 0.052, 647.011, 166, 2.444, 199.072, 158, 5.209, 110.206, 128, 1.207, 529.691, 110, 2.457, 217.231, 82, 2.76, 210.12, 81, 2.86, 14.23, 69, 1.66, 202.25, 65, 1.26, 216.48, 61, 1.25, 209.37, 59, 1.82, 323.51, 46, 0.82, 440.83, 36, 1.82, 224.34, 34, 2.84, 117.32, 33, 1.31, 412.37, 32, 1.19, 846.08, 27, 4.65, 1066.50, 27, 4.44, 11.05, 23, 4.13, 415.55, 21, 1.41, 309.28, 18, 5.56, 860.31, 15, 1.22, 63.74, 15, 1.34, 95.98, 15, 1.01, 536.80, 13, 2.46, 490.33, 13, 3.22, 277.03, 13, 2.27, 742.99, 13, 4.89, 522.58, 13, 0.30, 422.67, 12, 1.87, 423.42, 10, 3.12, 625.67, 10, 1.75, 330.62, 9, 0.46, 429.78, 8, 4.68, 215.75, 8, 2.42, 430.53, 7, 5.97, 149.56, 7, 1.52, 437.64, 7, 3.91, 351.82, 7, 3.01, 949.18, 6, 1.49, 234.64, 6, 0.02, 654.12, 6, 5.37, 735.88, 5, 3.81, 74.78, 5, 4.34, 628.85, 4, 5.64, 210.85, 4, 2.64, 3.18, 4, 1.73, 1059.38, 4, 4.99, 3.93, 4, 1.16, 223.59, +/*B2*/ 20630, 0.50482, 213.29910, 3720, 3.9983, 206.1855, 1627, 6.1819, 220.4126, 1346, 0.0000, 0.0000, 706, 3.039, 419.485, 365, 5.099, 426.598, 330, 5.279, 433.712, 219, 3.828, 639.897, 139, 1.043, 7.114, 104, 6.157, 227.526, 93, 1.98, 316.39, 71, 4.15, 199.07, 52, 2.88, 632.78, 49, 4.43, 647.01, 41, 3.16, 853.20, 29, 4.53, 210.12, 24, 1.12, 14.23, 21, 4.35, 217.23, 20, 5.31, 440.83, 18, 0.85, 110.21, 17, 5.68, 216.48, 16, 4.26, 103.09, 14, 3.00, 412.37, 12, 2.53, 529.69, 8, 3.32, 202.25, 7, 5.56, 209.37, 7, 0.29, 323.51, 6, 1.16, 117.32, 6, 3.61, 860.31, 6, 3.58, 309.28, 6, 2.48, 1066.50, 4, 3.02, 846.08, 4, 4.80, 625.67, 3, 3.77, 423.42, 3, 6.04, 234.64, 3, 4.82, 429.78, 3, 4.48, 654.12, 3, 3.29, 95.98, 3, 5.64, 735.88, 3, 0.22, 522.58, 2, 0.03, 415.55, 2, 6.25, 330.62, 2, 4.56, 422.67, 2, 5.06, 277.03, 2, 5.53, 536.80, 2, 5.54, 224.34, 2, 5.60, 223.59, +/*B3*/ 666, 1.990, 213.299, 632, 5.698, 206.186, 398, 0.000, 0.000, 188, 4.338, 220.413, 92, 4.84, 419.48, 52, 3.42, 433.71, 42, 2.38, 426.60, 26, 4.40, 227.53, 21, 5.85, 199.07, 18, 1.99, 639.90, 11, 5.37, 7.11, 10, 2.55, 647.01, 7, 3.46, 316.39, 6, 4.80, 632.78, 6, 0.02, 210.12, 6, 3.52, 440.83, 5, 5.64, 14.23, 5, 1.22, 853.20, 4, 4.71, 412.37, 3, 0.63, 103.09, 2, 3.72, 216.48, 2, 6.11, 217.23, 1, 1.69, 860.31, 1, 4.31, 234.64, 1, 5.75, 309.28, 1, 2.66, 654.12, 1, 5.69, 117.32, 1, 5.48, 202.25, 1, 0.60, 1066.50, 1, 0.22, 625.67, 1, 2.86, 429.78, 1, 4.52, 323.51, +/*B4*/ 80, 1.12, 206.19, 32, 3.12, 213.30, 17, 2.48, 220.41, 12, 3.14, 0.00, 9, 0.38, 419.48, 6, 1.56, 433.71, 5, 2.63, 227.53, 5, 1.28, 199.07, 1, 1.43, 426.60, 1, 0.67, 647.01, 1, 1.72, 440.83, 1, 6.18, 639.90, 1, 3.85, 14.23, 1, 3.49, 7.11, 1, 0.31, 412.37, +/*B5*/ 8, 2.82, 206.19, 1, 0.51, 220.41, 1, 3.14, 0.00, 1, 2.99, 199.07, 1, 0.78, 227.53, 1, 5.96, 433.71, +/*R0*/ 955758136, 0.000000000, 0.000000000, 52921382, 2.39226220, 213.29909544, 1873680, 5.2354961, 206.1855484, 1464664, 1.6476305, 426.5981909, 821891, 5.935200, 316.391870, 547507, 5.015326, 103.092774, 371684, 2.271148, 220.412642, 361778, 3.139043, 7.113547, 140618, 5.704067, 632.783739, 108975, 3.293136, 110.206321, 69007, 5.94100, 419.48464, 61053, 0.94038, 639.89729, 48913, 1.55733, 202.25340, 34144, 0.19519, 277.03499, 32402, 5.47085, 949.17561, 20937, 0.46349, 735.87651, 20839, 1.52103, 433.71174, 20747, 5.33256, 199.07200, 15298, 3.05944, 529.69097, 14296, 2.60434, 323.50542, 12884, 1.64892, 138.51750, 11993, 5.98051, 846.08283, 11380, 1.73106, 522.57742, 9796, 5.2048, 1265.5675, 7753, 5.8519, 95.9792, 6771, 3.0043, 14.2271, 6466, 0.1773, 1052.2684, 5850, 1.4552, 415.5525, 5307, 0.5974, 63.7359, 4696, 2.1492, 227.5262, 4044, 1.6401, 209.3669, 3688, 0.7802, 412.3711, 3461, 1.8509, 175.1661, 3420, 4.9455, 1581.9593, 3401, 0.5539, 350.3321, 3376, 3.6953, 224.3448, 2976, 5.6847, 210.1177, 2885, 1.3876, 838.9693, 2881, 0.1796, 853.1964, 2508, 3.5385, 742.9901, 2448, 6.1841, 1368.6603, 2406, 2.9656, 117.3199, 2174, 0.0151, 340.7709, 2024, 5.0541, 11.0457, 1888, 0.0297, 3.9322, 1861, 5.9336, 625.6702, 1817, 5.7771, 490.3341, 1781, 0.7631, 217.2312, 1740, 2.3466, 309.2783, 1611, 1.1730, 74.7816, 1475, 5.6767, 203.7379, 1472, 1.4006, 137.0330, 1463, 1.9259, 216.4805, 1395, 5.9367, 127.4718, 1315, 5.1120, 211.8146, 1304, 0.7724, 647.0108, 1296, 4.6918, 1898.3512, 1277, 2.9841, 1059.3819, 1207, 0.7529, 351.8166, 1150, 5.7402, 1162.4747, 1127, 4.4671, 265.9893, 1099, 1.8177, 149.5632, 1071, 1.1357, 1155.3612, 1021, 5.9123, 1685.0521, 998, 2.631, 200.769, 986, 2.260, 956.289, 932, 3.670, 554.070, 664, 0.603, 728.763, 660, 4.666, 195.140, 626, 5.942, 1478.867, 618, 5.621, 942.062, 553, 3.411, 269.921, 534, 1.264, 275.551, 517, 4.443, 2214.743, 494, 2.286, 278.519, 490, 5.806, 191.208, 488, 2.794, 3.181, 482, 1.841, 479.288, 473, 1.882, 515.464, 470, 0.838, 1471.753, 453, 3.003, 302.165, 452, 5.645, 2001.444, 427, 0.057, 284.149, 405, 1.640, 536.805, 386, 1.997, 1272.681, 343, 5.856, 1795.258, 341, 2.376, 525.498, 341, 0.891, 628.852, 340, 1.402, 440.825, 303, 0.879, 6069.777, 295, 0.671, 88.866, 294, 0.426, 312.199, 292, 6.214, 210.851, 288, 1.122, 422.666, 277, 5.319, 692.587, 276, 0.478, 38.133, 262, 0.318, 1045.155, 243, 5.372, 1258.454, 241, 1.125, 388.465, 237, 0.908, 1375.774, 234, 4.228, 114.138, 231, 5.495, 191.958, 226, 0.375, 142.450, 225, 0.548, 1788.145, 224, 2.281, 330.619, 222, 5.946, 39.357, 219, 5.256, 212.336, 214, 4.203, 2531.135, 208, 5.381, 2317.836, 206, 0.958, 288.081, 197, 3.901, 52.690, 192, 2.959, 437.644, 188, 6.079, 563.631, 187, 6.036, 404.507, 183, 5.669, 2111.650, 180, 4.410, 408.439, 178, 0.382, 430.530, 177, 2.303, 9999.986, 175, 5.714, 1066.495, 173, 1.849, 1589.073, 172, 2.365, 213.251, 172, 5.563, 213.347, 170, 2.857, 99.161, 166, 2.637, 215.747, 165, 2.891, 214.262, 163, 3.458, 617.806, 162, 5.731, 203.004, 150, 4.407, 417.037, 146, 1.566, 831.856, 145, 5.082, 423.417, 143, 0.998, 76.266, 137, 5.439, 222.860, 132, 2.859, 312.460, 129, 2.553, 414.068, 125, 4.784, 205.222, 120, 0.043, 1361.547, 113, 5.031, 703.633, 112, 0.262, 2104.537, 110, 2.437, 355.749, 109, 1.632, 208.633, 109, 2.093, 207.670, 109, 2.855, 21.341, 107, 3.671, 212.778, 104, 3.637, 65.220, 99, 5.14, 1574.85, 98, 5.12, 2634.23, 97, 4.20, 305.35, 97, 4.84, 131.40, 97, 2.56, 1692.17, 96, 5.45, 2428.04, 95, 2.52, 2.45, 94, 2.40, 483.22, 93, 0.74, 831.10, 92, 2.95, 35.42, 91, 3.97, 2847.53, 91, 4.21, 213.82, 89, 5.39, 107.02, 89, 4.06, 128.96, 88, 3.87, 140.00, 87, 1.33, 1905.46, 86, 2.30, 85.83, 86, 4.55, 210.38, 86, 0.03, 860.31, 84, 1.18, 429.78, 84, 4.61, 177.87, 83, 1.53, 145.63, 82, 1.66, 62.25, 77, 3.15, 767.37, 74, 3.57, 1.48, 74, 3.72, 92.05, 73, 4.38, 425.11, 73, 4.63, 245.54, 72, 0.01, 565.12, 71, 0.99, 405.26, 70, 4.04, 173.94, 67, 1.08, 339.29, 67, 4.75, 70.85, 66, 2.47, 280.97, 65, 2.45, 267.47, 65, 0.09, 9.56, 64, 1.29, 1148.25, 64, 4.10, 327.44, 63, 2.02, 234.64, 63, 4.40, 214.78, 61, 5.12, 756.32, 59, 4.23, 700.66, 59, 2.62, 225.83, 58, 6.06, 1677.94, 58, 5.47, 347.88, 57, 6.27, 2420.93, 56, 2.07, 124.43, 56, 4.30, 329.73, 55, 1.60, 543.02, 55, 3.86, 342.26, 54, 3.71, 344.70, 54, 1.07, 362.86, 54, 4.98, 134.59, 53, 3.79, 343.22, 50, 5.76, 320.32, 50, 3.93, 192.69, 50, 5.21, 2744.43, 50, 3.23, 333.66, 49, 4.90, 217.49, 49, 5.33, 3127.31, 48, 3.15, 216.22, 48, 2.39, 207.88, 48, 3.93, 199.28, 47, 2.45, 207.15, 47, 2.07, 2008.56, 46, 2.09, 212.55, 46, 4.86, 2950.62, 46, 2.64, 10.29, 46, 4.97, 198.32, 45, 5.36, 218.93, 45, 1.78, 223.59, 45, 5.56, 264.50, 43, 1.84, 106.27, 43, 0.40, 357.45, 42, 0.08, 210.33, 42, 0.74, 125.99, 41, 2.47, 237.68, 41, 4.92, 1891.24, 41, 4.08, 621.74, 40, 4.01, 12.53, 39, 3.46, 241.61, 39, 3.74, 3163.92, 39, 4.40, 18.16, 38, 4.44, 160.61, 38, 2.06, 247.24, 37, 4.75, 348.85, 37, 1.69, 22.09, 36, 3.83, 56.62, 35, 3.44, 273.10, 35, 5.65, 497.45, 35, 5.96, 217.96, 35, 2.25, 487.37, 35, 5.63, 99.91, 35, 1.83, 380.13, 34, 6.01, 166.83, 34, 0.73, 750.10, 34, 5.31, 206.23, 34, 1.24, 2221.86, 34, 5.80, 251.43, 33, 2.45, 969.62, 33, 4.87, 209.11, 33, 1.07, 252.66, 33, 1.93, 98.90, 33, 2.23, 319.57, 32, 3.78, 33.94, 32, 3.58, 231.46, 32, 1.00, 1464.64, 32, 2.13, 206.14, 32, 3.82, 73.30, 31, 2.05, 282.45, 31, 1.96, 244.32, 31, 4.90, 144.15, 31, 2.27, 1169.59, 30, 3.93, 206.71, 29, 5.98, 2737.32, 29, 4.84, 905.89, 29, 2.22, 14.98, 29, 6.03, 188.92, 29, 5.80, 1994.33, 29, 0.04, 5.63, 29, 0.76, 488.85, 29, 1.69, 78.71, 28, 4.73, 552.59, 28, 2.72, 32.24, 28, 0.79, 546.96, 28, 5.18, 5.42, 28, 1.45, 258.88, 28, 6.12, 214.05, 27, 2.45, 254.94, 27, 3.58, 561.18, 27, 0.25, 313.21, 27, 4.26, 179.36, 27, 5.20, 148.08, 27, 5.54, 555.55, 27, 2.86, 24.38, 26, 1.59, 491.82, 26, 0.65, 654.12, 26, 2.10, 248.72, 26, 1.62, 2324.95, 26, 3.36, 0.96, 25, 5.29, 636.72, 25, 4.97, 3060.83, 25, 5.12, 168.05, 25, 1.78, 182.28, 24, 0.01, 69.15, 24, 0.52, 894.84, 24, 3.15, 240.39, 24, 1.60, 738.80, 24, 2.55, 196.62, 23, 3.51, 458.84, 22, 3.25, 681.54, 22, 4.76, 213.19, 22, 3.17, 213.41, 22, 0.88, 635.97, 22, 4.61, 3267.01, 21, 3.86, 116.43, 21, 0.63, 189.72, 21, 1.67, 274.07, 21, 1.07, 494.27, 20, 6.05, 173.68, 20, 1.84, 533.62, 20, 2.95, 59.80, 20, 2.91, 120.36, 20, 4.94, 121.25, 20, 5.59, 4.19, 20, 0.08, 842.15, 20, 2.52, 1485.98, 20, 2.14, 54.17, 19, 0.11, 218.72, 19, 0.55, 4.67, 19, 5.38, 213.09, 19, 2.55, 213.51, 18, 3.19, 295.05, 18, 2.71, 181.81, 18, 2.26, 672.14, 17, 2.90, 477.80, 17, 0.68, 151.05, 17, 0.71, 1781.03, 17, 4.74, 2207.63, 17, 1.63, 5856.48, 17, 3.53, 3480.31, 16, 3.26, 6283.08, 16, 5.39, 424.15, 16, 3.98, 2.92, 16, 0.91, 280.00, 16, 0.63, 358.93, 16, 0.98, 2538.25, 16, 0.60, 746.92, 16, 0.83, 176.65, 16, 4.46, 643.83, 16, 5.23, 135.55, 16, 1.19, 486.40, 16, 5.70, 3053.71, 15, 1.49, 543.92, 15, 5.53, 2310.72, 15, 2.67, 46.47, 15, 1.24, 2641.34, 15, 1.77, 569.05, 15, 2.92, 167.09, 15, 2.66, 292.01, 15, 6.06, 468.24, 15, 5.26, 472.17, 14, 0.22, 235.39, 14, 0.12, 313.68, 14, 0.38, 601.76, 14, 2.63, 618.56, 14, 0.82, 221.38, 14, 3.19, 213.56, 14, 4.73, 213.04, 14, 2.51, 1802.37, 14, 2.21, 228.28, +/*R1*/ 6182981, 0.2584352, 213.2990954, 506578, 0.711147, 206.185548, 341394, 5.796358, 426.598191, 188491, 0.472157, 220.412642, 186262, 3.141593, 0.000000, 143891, 1.407449, 7.113547, 49621, 6.01744, 103.09277, 20928, 5.09246, 639.89729, 19953, 1.17560, 419.48464, 18840, 1.60820, 110.20632, 13877, 0.75886, 199.07200, 12893, 5.94330, 433.71174, 5397, 1.2885, 14.2271, 4869, 0.8679, 323.5054, 4247, 0.3930, 227.5262, 3252, 1.2585, 95.9792, 3081, 3.4366, 522.5774, 2909, 4.6068, 202.2534, 2856, 2.1673, 735.8765, 1988, 2.4505, 412.3711, 1941, 6.0239, 209.3669, 1581, 1.2919, 210.1177, 1340, 4.3080, 853.1964, 1316, 1.2530, 117.3199, 1203, 1.8665, 316.3919, 1091, 0.0753, 216.4805, 966, 0.480, 632.784, 954, 5.152, 647.011, 898, 0.983, 529.691, 882, 1.885, 1052.268, 874, 1.402, 224.345, 785, 3.064, 838.969, 740, 1.382, 625.670, 658, 4.144, 309.278, 650, 1.725, 742.990, 613, 3.033, 63.736, 599, 2.549, 217.231, 503, 2.130, 3.932, 413, 4.593, 415.552, 395, 0.533, 956.289, 363, 4.707, 302.165, 356, 2.303, 728.763, 345, 5.888, 440.825, 336, 1.616, 1368.660, 322, 0.979, 3.181, 317, 3.584, 515.464, 294, 2.816, 11.046, 291, 2.831, 1155.361, 278, 0.260, 195.140, 265, 2.427, 88.866, 265, 5.829, 149.563, 264, 1.285, 1059.382, 246, 0.907, 191.958, 245, 1.045, 942.062, 222, 5.132, 269.921, 215, 3.565, 490.334, 195, 4.567, 846.083, 183, 2.679, 127.472, 182, 4.934, 74.782, 175, 3.446, 137.033, 170, 4.635, 284.149, 166, 5.998, 536.805, 158, 2.996, 340.771, 155, 1.197, 265.989, 153, 0.270, 1272.681, 152, 5.439, 422.666, 152, 0.529, 330.619, 141, 1.271, 203.004, 141, 2.021, 1045.155, 140, 1.353, 1685.052, 136, 5.017, 351.817, 129, 1.143, 21.341, 128, 2.539, 1471.753, 127, 3.003, 277.035, 108, 4.319, 210.851, 103, 0.382, 203.738, 100, 3.614, 1066.495, 98, 2.56, 191.21, 97, 3.26, 831.86, 96, 0.79, 1258.45, 83, 0.28, 234.64, 73, 0.63, 1375.77, 72, 4.38, 860.31, 72, 5.58, 429.78, 71, 0.73, 437.64, 70, 0.88, 423.42, 69, 2.47, 949.18, 67, 5.45, 200.77, 67, 0.07, 408.44, 66, 2.68, 405.26, 66, 0.06, 1589.07, 64, 1.75, 1361.55, 62, 1.09, 2001.44, 60, 2.25, 1788.14, 55, 4.59, 628.85, 54, 0.28, 124.43, 51, 6.27, 223.59, 50, 3.80, 215.75, 49, 4.17, 138.52, 48, 0.84, 10.29, 47, 2.17, 312.20, 43, 3.38, 208.63, 43, 2.99, 1148.25, 42, 4.83, 288.08, 40, 5.18, 1478.87, 40, 0.28, 131.40, 39, 0.56, 1574.85, 37, 0.63, 52.69, 35, 4.68, 38.13, 33, 1.98, 142.45, 33, 3.28, 222.86, 33, 6.12, 145.63, 32, 5.19, 76.27, 32, 6.02, 1905.46, 31, 1.48, 1677.94, 30, 1.96, 2104.54, 29, 5.10, 654.12, 29, 4.96, 1795.26, 29, 2.75, 404.51, 28, 0.83, 1692.17, 28, 0.83, 2317.84, 28, 2.24, 430.53, 27, 5.24, 388.47, 27, 1.00, 107.02, 26, 4.28, 483.22, 26, 2.21, 1265.57, 25, 2.87, 703.63, 25, 6.24, 106.27, 25, 1.08, 99.91, 25, 0.81, 312.46, 24, 3.11, 212.34, 24, 0.55, 214.26, 24, 0.65, 207.88, 23, 5.08, 479.29, 23, 4.87, 295.05, 22, 4.23, 217.96, 22, 5.51, 343.22, 22, 3.90, 563.63, 22, 0.73, 99.16, 22, 6.07, 85.83, 22, 4.17, 2.45, 22, 3.80, 347.88, 21, 3.09, 554.07, 21, 0.39, 319.57, 21, 5.11, 333.66, 21, 2.69, 1464.64, 21, 3.29, 70.85, 21, 5.12, 362.86, 21, 1.69, 231.46, 21, 2.46, 18.16, 20, 0.23, 213.25, 20, 5.08, 750.10, 20, 3.43, 213.35, 19, 2.02, 313.21, 19, 0.05, 245.54, 18, 5.70, 56.62, 18, 3.84, 497.45, 17, 3.55, 218.93, 17, 4.72, 2111.65, 17, 1.41, 114.14, 16, 3.05, 134.59, 16, 1.71, 2420.93, 16, 4.94, 357.45, 16, 4.22, 565.12, 16, 0.27, 225.83, 16, 0.33, 1891.24, 16, 2.83, 81.75, 15, 1.21, 1994.33, 15, 1.31, 216.22, 15, 3.85, 1162.47, 15, 5.57, 344.70, 14, 0.45, 2008.56, 14, 5.71, 92.05, 14, 0.57, 2634.23, 13, 5.76, 2221.86, 13, 0.45, 1169.59, 13, 1.60, 320.32, 13, 3.74, 508.35, 13, 3.43, 258.88, 13, 1.64, 273.10, 13, 1.92, 1581.96, 13, 5.19, 635.97, 12, 1.01, 329.73, 12, 5.95, 543.92, 12, 4.45, 32.24, 12, 5.11, 4.67, 12, 4.31, 618.56, 12, 2.46, 721.65, 12, 1.76, 160.61, 12, 3.71, 350.33, 12, 2.80, 217.49, 11, 3.00, 198.32, 11, 1.89, 561.18, 11, 2.41, 1781.03, 11, 1.58, 212.78, 11, 0.77, 218.72, 11, 2.07, 213.82, 10, 2.41, 546.96, 10, 0.09, 182.28, 10, 0.49, 305.35, 10, 2.64, 416.30, 10, 4.05, 62.25, 10, 3.28, 275.55, 10, 1.61, 327.44, 10, 1.10, 113.39, 9, 5.46, 414.07, 9, 4.46, 2428.04, 9, 2.92, 1279.79, 9, 4.88, 120.36, 9, 0.54, 168.05, 9, 6.14, 621.74, 9, 1.83, 629.60, 9, 1.95, 35.42, 9, 2.18, 425.11, 8, 0.36, 617.81, 8, 3.77, 251.43, 8, 0.92, 1485.98, 8, 1.38, 1.48, 8, 5.31, 65.22, 8, 3.46, 424.15, 8, 0.35, 278.52, 8, 5.44, 254.94, 8, 0.96, 767.37, 8, 1.43, 2737.32, 8, 3.38, 144.15, 8, 0.94, 636.72, 8, 5.14, 22.09, 8, 0.94, 2310.72, 8, 5.14, 358.93, 8, 4.56, 280.97, 8, 0.10, 2324.95, 8, 5.75, 447.94, 8, 2.19, 264.50, 7, 4.52, 5.63, 7, 3.85, 214.05, 7, 3.39, 98.90, 7, 1.20, 5.42, 7, 1.65, 1898.35, 7, 1.79, 12.53, 7, 3.50, 9.56, 6, 5.31, 6076.89, 6, 0.45, 10007.10, 6, 0.33, 2950.62, 6, 2.12, 274.07, 6, 0.76, 210.38, 6, 3.21, 219.45, 6, 3.80, 339.29, 6, 4.59, 207.67, 6, 0.18, 2207.63, 6, 2.11, 2097.42, 6, 4.67, 543.02, 6, 5.13, 692.59, 6, 6.17, 650.94, 6, 5.95, 486.40, 6, 1.04, 9992.87, 6, 6.10, 209.11, 6, 5.48, 2538.25, 6, 3.01, 121.25, 6, 5.92, 6062.66, 6, 3.56, 1073.61, 6, 0.56, 116.43, 6, 4.40, 196.62, 6, 4.83, 643.08, 6, 0.95, 1802.37, 6, 0.81, 472.17, 6, 2.24, 1038.04, 6, 3.61, 125.99, 6, 3.84, 181.06, 5, 5.81, 237.68, 5, 6.19, 337.73, 5, 0.56, 192.69, 5, 3.82, 842.15, 5, 4.85, 267.47, 5, 0.50, 248.72, 5, 4.01, 205.22, 5, 3.36, 824.74, 5, 1.63, 166.83, 5, 0.85, 46.47, 5, 4.04, 487.37, 5, 0.85, 247.24, 5, 4.49, 291.26, 5, 2.67, 417.04, 5, 0.25, 129.92, 5, 4.18, 2744.43, 5, 3.74, 235.39, 5, 5.58, 342.26, 5, 1.55, 214.78, 5, 3.17, 148.08, 5, 3.67, 189.72, 4, 4.71, 151.05, 4, 3.74, 699.70, 4, 0.25, 128.96, 4, 5.69, 252.66, 4, 4.95, 184.09, 4, 5.43, 436.89, 4, 6.20, 268.44, 4, 4.19, 685.47, 4, 2.98, 380.13, 4, 5.97, 212.55, 4, 6.10, 2641.34, 4, 5.82, 491.82, 4, 4.87, 14.98, 4, 4.19, 501.38, 4, 1.15, 3053.71, 4, 3.08, 710.75, 4, 5.17, 114.40, 4, 3.46, 220.46, 4, 0.75, 2627.11, 4, 0.99, 271.41, 4, 4.78, 175.17, 4, 3.71, 204.70, 4, 1.27, 211.81, 4, 3.56, 244.32, 4, 4.53, 488.85, 4, 2.87, 411.62, 4, 2.22, 2.92, 4, 3.06, 409.92, 4, 5.54, 458.84, 4, 1.58, 643.83, 4, 4.51, 601.76, 4, 1.11, 6283.08, 4, 2.20, 135.34, 4, 3.64, 229.97, 4, 1.32, 69.15, +/*R2*/ 436902, 4.786717, 213.299095, 71923, 2.50070, 206.18555, 49767, 4.97168, 220.41264, 43221, 3.86940, 426.59819, 29646, 5.96310, 7.11355, 4721, 2.4753, 199.0720, 4142, 4.1067, 433.7117, 3789, 3.0977, 639.8973, 2964, 1.3721, 103.0928, 2556, 2.8507, 419.4846, 2327, 0.0000, 0.0000, 2208, 6.2759, 110.2063, 2188, 5.8555, 14.2271, 1957, 4.9245, 227.5262, 924, 5.464, 323.505, 706, 2.971, 95.979, 546, 4.129, 412.371, 431, 5.178, 522.577, 405, 4.173, 209.367, 391, 4.481, 216.480, 374, 5.834, 117.320, 361, 3.277, 647.011, 356, 3.192, 210.118, 326, 2.269, 853.196, 207, 4.022, 735.877, 204, 0.088, 202.253, 180, 3.597, 632.784, 178, 4.097, 440.825, 154, 3.135, 625.670, 148, 0.136, 302.165, 133, 2.594, 191.958, 132, 5.933, 309.278, 123, 4.189, 88.866, 119, 5.554, 224.345, 111, 4.779, 838.969, 109, 5.293, 515.464, 100, 5.461, 3.181, 97, 4.02, 728.76, 96, 6.26, 742.99, 94, 4.38, 217.23, 81, 5.11, 956.29, 79, 5.73, 21.34, 69, 4.05, 3.93, 65, 3.78, 1052.27, 64, 5.81, 529.69, 63, 2.18, 195.14, 57, 3.15, 203.00, 56, 4.84, 234.64, 53, 5.08, 330.62, 53, 3.93, 949.18, 51, 2.77, 942.06, 45, 0.56, 269.92, 42, 4.79, 63.74, 41, 3.73, 316.39, 41, 4.58, 1155.36, 39, 3.51, 422.67, 38, 3.74, 1045.15, 38, 4.19, 536.80, 35, 2.91, 284.15, 35, 5.94, 1059.38, 34, 3.80, 149.56, 33, 4.97, 831.86, 31, 4.84, 1272.68, 30, 2.48, 860.31, 30, 4.35, 405.26, 30, 3.66, 429.78, 30, 1.59, 1066.50, 27, 1.66, 277.03, 26, 4.45, 223.59, 26, 4.82, 124.43, 26, 3.55, 1368.66, 24, 5.31, 10.29, 22, 2.76, 415.55, 22, 1.04, 11.05, 21, 3.62, 1265.57, 20, 2.52, 1258.45, 18, 4.31, 1471.75, 17, 3.49, 1361.55, 17, 3.28, 654.12, 16, 1.73, 490.33, 15, 5.01, 127.47, 15, 3.60, 265.99, 14, 4.69, 1148.25, 14, 3.05, 423.42, 13, 1.90, 408.44, 13, 0.32, 295.05, 13, 4.89, 437.64, 13, 4.62, 1589.07, 13, 3.14, 74.78, 12, 2.33, 210.85, 11, 5.48, 1375.77, 11, 4.55, 81.75, 11, 5.05, 191.21, 11, 5.03, 137.03, 10, 3.34, 1685.05, 10, 5.20, 340.77, 10, 3.17, 351.82, 9, 3.40, 1581.96, 9, 2.81, 99.91, 8, 3.23, 1677.94, 8, 4.04, 1788.14, 8, 2.36, 1574.85, 8, 6.08, 231.46, 8, 3.68, 846.08, 8, 3.29, 750.10, 7, 2.00, 131.40, 7, 4.38, 1464.64, 7, 4.83, 319.57, 7, 4.37, 145.63, 7, 5.43, 508.35, 7, 3.78, 313.21, 6, 1.34, 215.75, 6, 4.00, 447.94, 6, 4.56, 106.27, 6, 2.85, 138.52, 6, 0.55, 18.16, 6, 4.14, 543.92, 6, 4.35, 1905.46, 6, 1.13, 56.62, 5, 4.20, 721.65, 5, 3.63, 6076.89, 5, 4.50, 416.30, 5, 2.64, 288.08, 5, 5.05, 10007.10, 5, 2.45, 628.85, 5, 3.12, 1898.35, 5, 6.18, 483.22, 5, 5.92, 618.56, 5, 3.30, 76.27, 5, 3.12, 2001.44, 5, 5.78, 184.84, 5, 0.76, 333.66, 5, 1.27, 6062.66, 5, 1.20, 200.77, 5, 2.69, 9992.87, 5, 0.95, 343.22, 4, 0.80, 222.86, 4, 1.92, 497.45, 4, 2.90, 107.02, 4, 1.98, 347.88, 4, 2.88, 38.13, 4, 2.93, 1994.33, 4, 5.18, 404.51, 4, 5.45, 1692.17, 4, 4.12, 1781.03, 4, 3.12, 635.97, 4, 0.88, 703.63, 4, 3.79, 2104.54, 4, 3.25, 362.86, 4, 0.05, 32.24, 4, 3.48, 388.47, 4, 5.55, 113.39, 4, 5.46, 6283.08, 4, 4.08, 430.53, 3, 1.82, 70.85, 3, 3.52, 629.60, 3, 0.55, 10213.29, 3, 4.21, 337.73, 3, 3.28, 357.45, 3, 1.98, 203.74, 3, 3.88, 85.83, 3, 3.92, 1038.04, 3, 2.46, 867.42, 3, 1.26, 134.59, 3, 1.61, 1073.61, 3, 4.09, 1478.87, 3, 2.18, 1891.24, 3, 2.67, 52.69, 3, 0.41, 561.18, 3, 5.60, 216.22, 3, 5.01, 312.46, 3, 2.55, 6069.78, 3, 5.46, 258.88, 3, 2.19, 217.96, 3, 3.97, 9999.99, 3, 0.89, 1279.79, 3, 4.21, 650.94, 3, 1.67, 213.35, 3, 2.38, 181.06, 3, 3.91, 312.20, 3, 4.75, 213.25, 3, 5.09, 1169.59, 3, 5.74, 160.61, 3, 2.88, 643.08, 3, 3.62, 436.89, 3, 0.01, 195.89, 3, 1.69, 208.63, 3, 2.32, 565.12, 3, 1.13, 344.70, 3, 6.13, 273.10, 3, 5.10, 824.74, 3, 5.30, 444.76, 2, 3.58, 2420.93, 2, 2.96, 2214.74, 2, 3.46, 6275.96, 2, 4.74, 218.72, 2, 0.90, 121.25, 2, 4.08, 131.55, 2, 2.60, 305.35, 2, 4.22, 2221.86, 2, 5.18, 99.16, 2, 5.43, 207.88, 2, 3.38, 22.09, 2, 3.32, 358.93, 2, 3.95, 1795.26, 2, 1.61, 218.93, 2, 3.37, 320.32, 2, 4.85, 1141.13, 2, 4.63, 188.03, 2, 2.29, 2627.11, 2, 5.67, 28.45, 2, 1.69, 350.33, 2, 4.26, 546.96, 2, 0.18, 12.53, 2, 4.61, 182.28, 2, 2.90, 2310.72, 2, 1.31, 212.34, 2, 4.13, 225.83, 2, 3.01, 2317.84, 2, 1.59, 424.15, 2, 3.58, 329.73, 2, 2.24, 168.05, 2, 2.07, 144.15, 2, 2.86, 636.72, 2, 5.35, 45.58, 2, 5.05, 214.26, 2, 2.73, 291.26, 2, 2.70, 12.74, 2, 1.32, 219.45, 2, 5.56, 92.80, 2, 1.95, 129.92, 2, 3.44, 2428.04, 2, 3.55, 1354.43, 2, 4.98, 2008.56, 2, 6.14, 554.07, 2, 3.30, 1670.83, 2, 5.73, 1485.98, 2, 1.16, 235.39, 2, 4.51, 210.38, 2, 2.16, 207.67, 2, 5.51, 204.70, 2, 4.99, 1162.47, +/*R3*/ 20315, 3.02187, 213.29910, 8924, 3.1914, 220.4126, 6909, 4.3517, 206.1855, 4087, 4.2241, 7.1135, 3879, 2.0106, 426.5982, 1071, 4.2036, 199.0720, 907, 2.283, 433.712, 606, 3.175, 227.526, 597, 4.135, 14.227, 483, 1.173, 639.897, 393, 0.000, 0.000, 229, 4.698, 419.485, 188, 4.590, 110.206, 150, 3.202, 103.093, 121, 3.768, 323.505, 102, 4.710, 95.979, 101, 5.819, 412.371, 93, 1.44, 647.01, 84, 2.63, 216.48, 73, 4.15, 117.32, 62, 2.31, 440.83, 55, 0.31, 853.20, 50, 2.39, 209.37, 45, 4.37, 191.96, 41, 0.69, 522.58, 40, 1.84, 302.16, 38, 5.94, 88.87, 32, 4.01, 21.34, 28, 5.77, 210.12, 25, 0.73, 515.46, 25, 3.06, 234.64, 21, 4.93, 625.67, 18, 1.46, 309.28, 17, 5.73, 728.76, 17, 3.53, 3.18, 13, 3.36, 330.62, 12, 5.99, 735.88, 11, 3.37, 224.34, 11, 3.42, 956.29, 11, 6.07, 405.26, 10, 0.28, 838.97, 10, 0.58, 860.31, 10, 1.59, 202.25, 9, 2.57, 223.59, 9, 2.94, 124.43, 9, 4.65, 632.78, 9, 1.76, 429.78, 8, 4.48, 742.99, 8, 4.20, 195.14, 8, 0.44, 831.86, 8, 1.46, 654.12, 7, 4.51, 942.06, 7, 5.47, 1045.15, 7, 1.52, 422.67, 7, 4.83, 316.39, 7, 3.42, 10.29, 6, 6.01, 1066.50, 6, 2.34, 269.92, 6, 0.83, 217.23, 6, 1.15, 284.15, 6, 4.18, 529.69, 6, 2.47, 536.80, 5, 2.12, 295.05, 4, 0.92, 203.00, 4, 3.23, 1272.68, 4, 0.11, 1155.36, 4, 6.01, 1052.27, 4, 0.06, 81.75, 3, 4.33, 1258.45, 3, 0.19, 1148.25, 3, 2.19, 447.94, 3, 1.89, 149.56, 3, 5.64, 3.93, 3, 5.41, 1361.55, 3, 4.97, 1677.94, 3, 0.92, 508.35, 3, 3.00, 1589.07, 3, 2.31, 543.92, 3, 3.71, 408.44, 2, 4.24, 1059.38, 2, 3.22, 319.57, 2, 5.73, 313.21, 2, 1.30, 184.84, 2, 5.88, 721.65, 2, 0.52, 416.30, 2, 6.18, 1464.64, 2, 6.23, 1471.75, 2, 2.41, 337.73, 2, 5.17, 2854.64, 2, 2.41, 131.55, 2, 5.62, 11.05, 2, 0.54, 635.97, 2, 5.59, 1038.04, 2, 1.82, 436.89, 2, 1.51, 750.10, 2, 6.12, 1073.61, 2, 4.58, 1994.33, 2, 0.03, 423.42, 2, 2.58, 2090.31, 2, 2.95, 437.64, 2, 1.75, 195.89, 2, 5.97, 1781.03, 2, 0.56, 2324.95, 2, 6.15, 490.33, 2, 0.61, 210.85, 2, 3.85, 1251.34, 1, 0.27, 497.45, 1, 0.99, 643.08, 1, 5.35, 1354.43, 1, 3.29, 1884.12, 1, 1.50, 430.53, 1, 0.85, 415.55, 1, 5.33, 2538.25, 1, 4.12, 1574.85, 1, 5.58, 1382.89, 1, 0.70, 867.42, 1, 3.79, 1567.73, 1, 2.29, 2420.93, 1, 1.41, 2634.23, 1, 0.48, 824.74, 1, 2.97, 241.75, 1, 3.11, 2200.52, 1, 5.13, 25.27, 1, 4.70, 113.39, 1, 1.80, 618.56, 1, 3.96, 1891.24, 1, 3.78, 1375.77, 1, 3.73, 131.40, 1, 4.48, 2214.74, 1, 0.79, 127.47, 1, 5.42, 1279.79, 1, 0.05, 63.74, 1, 4.80, 1987.22, 1, 5.85, 215.75, 1, 4.06, 231.46, 1, 1.09, 362.86, 1, 4.23, 1802.37, 1, 5.33, 2428.04, 1, 5.91, 265.99, 1, 0.74, 16.67, 1, 6.26, 2015.67, 1, 5.99, 2524.02, 1, 1.92, 483.22, 1, 2.66, 145.63, 1, 2.97, 934.95, 1, 6.26, 2.45, 1, 3.16, 2207.63, 1, 0.09, 628.85, 1, 1.24, 74.78, 1, 5.87, 1368.66, 1, 2.90, 2008.56, 1, 2.38, 2228.97, 1, 2.28, 1478.87, 1, 1.16, 3053.71, 1, 4.70, 1670.83, 1, 5.92, 1685.05, 1, 3.13, 56.62, +/*R4*/ 1202, 1.4150, 220.4126, 708, 1.162, 213.299, 516, 6.240, 206.186, 427, 2.469, 7.114, 268, 0.187, 426.598, 170, 5.959, 199.072, 150, 0.480, 433.712, 145, 1.442, 227.526, 121, 2.405, 14.227, 47, 5.57, 639.90, 19, 5.86, 647.01, 17, 0.53, 440.83, 16, 2.90, 110.21, 15, 0.30, 419.48, 14, 1.30, 412.37, 13, 2.09, 323.51, 11, 0.22, 95.98, 11, 2.46, 117.32, 10, 3.14, 0.00, 9, 1.56, 88.87, 9, 2.28, 21.34, 9, 0.68, 216.48, 8, 1.27, 234.64, 8, 4.49, 853.20, 8, 3.59, 302.16, 6, 5.17, 103.09, 5, 2.59, 515.46, 4, 4.97, 860.31, 4, 0.02, 191.96, 4, 5.97, 654.12, 4, 1.60, 330.62, 4, 1.60, 405.26, 4, 3.30, 210.12, 3, 2.73, 522.58, 3, 0.75, 209.37, 3, 1.32, 728.76, 2, 1.19, 124.43, 2, 0.49, 447.94, 2, 3.28, 203.00, 2, 0.73, 625.67, 2, 6.15, 429.78, 2, 0.75, 295.05, 2, 3.89, 1066.50, 2, 2.00, 831.86, 2, 0.09, 942.06, 2, 0.82, 223.59, 2, 1.40, 224.34, 2, 3.02, 184.84, 2, 5.41, 824.74, 2, 5.96, 422.67, 1, 2.12, 529.69, 1, 0.72, 536.80, 1, 1.65, 17.41, 1, 1.90, 956.29, 1, 5.97, 195.14, 1, 1.12, 838.97, 1, 0.89, 721.65, 1, 1.59, 735.88, 1, 3.06, 1574.85, 1, 1.01, 1045.15, 1, 5.36, 316.39, 1, 4.93, 56.62, 1, 2.72, 508.35, 1, 1.11, 1169.59, +/*R5*/ 129, 5.913, 220.413, 32, 0.69, 7.11, 27, 5.91, 227.53, 20, 4.95, 433.71, 20, 0.67, 14.23, 14, 2.67, 206.19, 14, 1.46, 199.07, 13, 4.59, 426.60, 7, 4.63, 213.30, 5, 3.61, 639.90, 4, 4.90, 440.83, 3, 4.07, 647.01, 3, 4.66, 191.96, 3, 0.49, 323.51, 3, 3.18, 419.48, 2, 3.70, 88.87, 2, 3.32, 95.98, 2, 0.56, 117.32, 2, 5.33, 302.16, 2, 0.00, 0.00, 2, 2.67, 853.20, 2, 0.86, 515.46, 1, 5.83, 234.64, 1, 0.16, 412.37, 1, 5.98, 3.18, 1, 5.23, 216.48, 1, 5.05, 124.43, 1, 0.37, 28.45 }; + + +//Dura精度:J2000+-4千年 黄经1角秒 黄纬1角秒 距离20AU/10^6 +static constexpr long double XL0_6[] = { +100000000,//A的倍率 +20, 539, 836, 980, 1070, 1085, 1088, 1193, 1271, 1307, 1322, 1325, 1325, 2150, 2660, 2936, 3089, 3122, 3122,//位置索引表 +/*L0*/ 548129294, 0.000000000, 0.000000000, 9260408, 0.8910642, 74.7815986, 1504248, 3.6271926, 1.4844727, 365982, 1.899622, 73.297126, 272328, 3.358237, 149.563197, 70328, 5.39254, 63.73590, 68893, 6.09292, 76.26607, 61999, 2.26952, 2.96895, 61951, 2.85099, 11.04570, 26469, 3.14152, 71.81265, 25711, 6.11380, 454.90937, 21079, 4.36059, 148.07872, 17819, 1.74437, 36.64856, 14613, 4.73732, 3.93215, 11163, 5.82682, 224.34480, 10998, 0.48865, 138.51750, 9527, 2.9552, 35.1641, 7546, 5.2363, 109.9457, 4220, 3.2333, 70.8494, 4052, 2.2775, 151.0477, 3490, 5.4831, 146.5943, 3355, 1.0655, 4.4534, 3144, 4.7520, 77.7505, 2927, 4.6290, 9.5612, 2922, 5.3524, 85.8273, 2273, 4.3660, 70.3282, 2149, 0.6075, 38.1330, 2051, 1.5177, 0.1119, 1992, 4.9244, 277.0350, 1667, 3.6274, 380.1278, 1533, 2.5859, 52.6902, 1376, 2.0428, 65.2204, 1372, 4.1964, 111.4302, 1284, 3.1135, 202.2534, 1282, 0.5427, 222.8603, 1244, 0.9161, 2.4477, 1221, 0.1990, 108.4612, 1151, 4.1790, 33.6796, 1150, 0.9334, 3.1814, 1090, 1.7750, 12.5302, 1072, 0.2356, 62.2514, 946, 1.192, 127.472, 708, 5.183, 213.299, 653, 0.966, 78.714, 628, 0.182, 984.600, 607, 5.432, 529.691, 559, 3.358, 0.521, 524, 2.013, 299.126, 483, 2.106, 0.963, 471, 1.407, 184.727, 467, 0.415, 145.110, 434, 5.521, 183.243, 405, 5.987, 8.077, 399, 0.338, 415.552, 396, 5.870, 351.817, 379, 2.350, 56.622, 310, 5.833, 145.631, 300, 5.644, 22.091, 294, 5.839, 39.618, 252, 1.637, 221.376, 249, 4.746, 225.829, 239, 2.350, 137.033, 224, 0.516, 84.343, 223, 2.843, 0.261, 220, 1.922, 67.668, 217, 6.142, 5.938, 216, 4.778, 340.771, 208, 5.580, 68.844, 202, 1.297, 0.048, 199, 0.956, 152.532, 194, 1.888, 456.394, 193, 0.916, 453.425, 187, 1.319, 0.160, 182, 3.536, 79.235, 173, 1.539, 160.609, 172, 5.680, 219.891, 170, 3.677, 5.417, 169, 5.879, 18.159, 165, 1.424, 106.977, 163, 3.050, 112.915, 158, 0.738, 54.175, 147, 1.263, 59.804, 143, 1.300, 35.425, 139, 5.386, 32.195, 139, 4.260, 909.819, 124, 1.374, 7.114, 110, 2.027, 554.070, 109, 5.706, 77.963, 104, 5.028, 0.751, 104, 1.458, 24.379, 103, 0.681, 14.978, 95, 0.91, 74.67, 94, 3.94, 74.89, 89, 0.52, 181.76, 86, 1.71, 82.86, 85, 5.89, 256.54, 85, 0.37, 186.21, 83, 2.93, 265.99, 80, 3.01, 297.64, 80, 1.01, 6.59, 77, 4.59, 6.22, 75, 4.63, 69.36, 74, 6.24, 447.80, 73, 4.28, 87.31, 73, 2.85, 462.02, 70, 1.19, 66.70, 70, 0.87, 305.35, 70, 3.76, 131.40, 69, 4.44, 39.36, 62, 0.17, 479.29, 62, 3.19, 77.23, 58, 1.59, 60.77, 58, 2.67, 381.61, 58, 3.67, 51.21, 57, 1.63, 143.63, 55, 1.50, 71.60, 54, 5.52, 128.96, 50, 1.12, 20.61, 46, 4.36, 75.74, 45, 0.48, 14.01, 42, 3.82, 81.00, 40, 4.57, 46.21, 40, 0.70, 218.41, 40, 6.06, 293.19, 39, 5.59, 99.16, 39, 3.44, 153.50, 38, 6.07, 211.81, 36, 1.67, 258.02, 35, 1.97, 835.04, 35, 3.72, 692.59, 35, 1.03, 203.74, 35, 0.39, 1.37, 34, 1.08, 191.21, 34, 2.94, 140.00, 34, 6.06, 275.55, 33, 4.22, 200.77, 32, 5.51, 72.33, 30, 1.89, 269.92, 30, 3.87, 259.51, 29, 0.17, 528.21, 28, 2.18, 125.99, 27, 2.10, 209.37, 27, 4.75, 41.10, 27, 6.28, 28.57, 27, 4.48, 373.91, 26, 4.77, 284.15, 26, 5.81, 75.30, 26, 6.20, 134.59, 26, 3.63, 490.33, 26, 0.54, 41.64, 26, 0.75, 278.52, 25, 5.43, 116.43, 25, 4.71, 378.64, 24, 3.19, 81.37, 23, 3.58, 1.60, 23, 0.93, 288.08, 23, 0.53, 1514.29, 22, 1.84, 617.81, 22, 4.59, 404.51, 22, 5.87, 45.58, 22, 0.06, 173.94, 21, 2.74, 28.31, 21, 1.98, 114.40, 21, 5.62, 55.66, 21, 2.64, 105.49, 21, 0.89, 255.06, 20, 0.10, 195.14, 20, 3.78, 135.55, 19, 1.49, 0.89, 19, 6.22, 329.84, 19, 2.84, 159.12, 19, 0.51, 67.36, 19, 2.30, 5.11, +/*L1*/ 7502543122, 0.0000000000, 0.0000000000, 154458, 5.242017, 74.781599, 24456, 1.71256, 1.48447, 9258, 0.4284, 11.0457, 8266, 1.5022, 63.7359, 7842, 1.3198, 149.5632, 3899, 0.4648, 3.9322, 2284, 4.1737, 76.2661, 1927, 0.5301, 2.9689, 1233, 1.5863, 70.8494, 791, 5.436, 3.181, 767, 1.996, 73.297, 482, 2.984, 85.827, 450, 4.138, 138.517, 446, 3.723, 224.345, 427, 4.731, 71.813, 354, 2.583, 148.079, 348, 2.454, 9.561, 317, 5.579, 52.690, 206, 2.363, 2.448, 189, 4.202, 56.622, 184, 0.284, 151.048, 180, 5.684, 12.530, 171, 3.001, 78.714, 158, 2.909, 0.963, 155, 5.591, 4.453, 154, 4.652, 35.164, 152, 2.942, 77.751, 143, 2.590, 62.251, 121, 4.148, 127.472, 116, 3.732, 65.220, 102, 4.188, 145.631, 102, 6.034, 0.112, 88, 3.99, 18.16, 88, 6.16, 202.25, 81, 2.64, 22.09, 72, 6.05, 70.33, 69, 4.05, 77.96, 59, 3.70, 67.67, 47, 3.54, 351.82, 44, 5.91, 7.11, 43, 5.72, 5.42, 39, 4.92, 222.86, 36, 5.90, 33.68, 36, 3.29, 8.08, 36, 3.33, 71.60, 35, 5.08, 38.13, 31, 5.62, 984.60, 31, 5.50, 59.80, 31, 5.46, 160.61, 30, 1.66, 447.80, 29, 1.15, 462.02, 29, 4.52, 84.34, 27, 5.54, 131.40, 27, 6.15, 299.13, 26, 4.99, 137.03, 25, 5.74, 380.13, 23, 2.25, 111.43, 22, 0.93, 213.30, 22, 2.81, 69.36, 19, 1.86, 108.46, 19, 3.56, 54.17, 16, 3.10, 14.98, 14, 1.54, 340.77, 14, 2.69, 225.83, 14, 4.38, 5.94, 13, 1.95, 87.31, 13, 5.88, 6.22, 12, 0.33, 51.21, 12, 3.60, 269.92, 12, 5.34, 152.53, 12, 0.33, 35.42, 12, 1.75, 79.24, 11, 3.38, 72.33, 11, 1.69, 45.58, 11, 5.97, 265.99, 11, 3.07, 284.15, 10, 4.17, 24.38, 10, 3.52, 529.69, 10, 4.65, 77.23, 10, 5.50, 153.50, 10, 1.01, 68.84, 10, 0.50, 209.37, 10, 5.60, 82.86, 9, 3.54, 41.64, 9, 3.93, 39.62, 9, 4.49, 20.61, 9, 1.97, 195.14, 9, 3.89, 60.77, 8, 4.41, 134.59, 8, 2.44, 146.59, 8, 5.73, 184.73, 8, 0.17, 120.36, 8, 5.36, 75.74, 8, 5.77, 73.82, 8, 4.44, 14.01, 7, 2.19, 145.11, 7, 4.12, 191.21, 7, 2.13, 116.43, +/*L2*/ 53033, 0.00000, 0.00000, 2358, 2.2601, 74.7816, 769, 4.526, 11.046, 552, 3.258, 63.736, 542, 2.276, 3.932, 529, 4.923, 1.484, 258, 3.691, 3.181, 239, 5.858, 149.563, 182, 6.218, 70.849, 54, 1.44, 76.27, 49, 6.03, 56.62, 45, 3.91, 2.45, 45, 0.81, 85.83, 38, 1.78, 52.69, 37, 4.46, 2.97, 33, 0.86, 9.56, 29, 5.10, 73.30, 24, 2.11, 18.16, 22, 5.99, 138.52, 22, 4.82, 78.71, 21, 2.40, 77.96, 21, 2.17, 224.34, 17, 2.54, 145.63, 17, 3.47, 12.53, 12, 0.02, 22.09, 11, 0.08, 127.47, 10, 5.16, 71.60, 10, 4.46, 62.25, 9, 4.26, 7.11, 8, 5.50, 67.67, 7, 1.25, 5.42, 6, 3.36, 447.80, 6, 5.45, 65.22, 6, 4.52, 151.05, 6, 5.73, 462.02, 6, 5.61, 148.08, 6, 1.83, 202.25, 5, 1.06, 131.40, 5, 3.52, 59.80, 5, 3.36, 4.45, 5, 1.20, 71.81, 4, 0.68, 77.75, 4, 1.76, 351.82, 4, 4.57, 454.91, 3, 3.84, 45.58, 3, 3.32, 160.61, 3, 6.15, 77.23, 3, 5.36, 269.92, +/*L3*/ 121, 0.024, 74.782, 68, 4.12, 3.93, 53, 2.39, 11.05, 46, 0.00, 0.00, 45, 2.04, 3.18, 44, 2.96, 1.48, 25, 4.89, 63.74, 21, 4.55, 70.85, 20, 2.31, 149.56, 9, 1.58, 56.62, 4, 0.23, 18.16, 4, 5.39, 76.27, 4, 0.95, 77.96, 3, 4.98, 85.83, 3, 4.13, 52.69, 3, 0.37, 78.71, 2, 0.86, 145.63, 2, 5.66, 9.56, 2, 2.68, 7.11, 2, 0.49, 71.60, 1, 5.20, 73.30, 1, 4.87, 224.34, 1, 1.25, 12.53, 1, 3.93, 22.09, 1, 2.19, 127.47, 1, 3.98, 462.02, 1, 5.06, 447.80, 1, 1.06, 138.52, 1, 0.35, 5.63, 1, 2.94, 131.40, +/*L4*/ 114, 3.142, 0.000, 6, 4.58, 74.78, 3, 0.35, 11.05, 1, 3.42, 56.62, 1, 4.66, 18.16, +/*L5*/ 1, 3.14, 0.00, +/*B0*/ 1346278, 2.6187781, 74.7815986, 62341, 5.08111, 149.56320, 61601, 3.14159, 0.00000, 9964, 1.6160, 76.2661, 9926, 0.5763, 73.2971, 3259, 1.2612, 224.3448, 2972, 2.2437, 1.4845, 2010, 6.0555, 148.0787, 1522, 0.2796, 63.7359, 924, 4.038, 151.048, 761, 6.140, 71.813, 522, 3.321, 138.517, 463, 0.743, 85.827, 437, 3.381, 529.691, 435, 0.341, 77.751, 431, 3.554, 213.299, 420, 5.213, 11.046, 245, 0.788, 2.969, 233, 2.257, 222.860, 216, 1.591, 38.133, 180, 3.725, 299.126, 175, 1.236, 146.594, 174, 1.937, 380.128, 160, 5.336, 111.430, 144, 5.962, 35.164, 116, 5.739, 70.849, 106, 0.941, 70.328, 102, 2.619, 78.714, 86, 0.70, 39.62, 73, 0.21, 225.83, 71, 0.83, 109.95, 58, 2.67, 108.46, 54, 3.35, 184.73, 44, 2.74, 152.53, 41, 3.22, 160.61, +/*B1*/ 206366, 4.123943, 74.781599, 8563, 0.3382, 149.5632, 1726, 2.1219, 73.2971, 1374, 0.0000, 0.0000, 1369, 3.0686, 76.2661, 451, 3.777, 1.484, 400, 2.848, 224.345, 307, 1.255, 148.079, 154, 3.786, 63.736, 112, 5.573, 151.048, 111, 5.329, 138.517, 83, 3.59, 71.81, 56, 3.40, 85.83, 54, 1.70, 77.75, 42, 1.21, 11.05, 41, 4.45, 78.71, 32, 3.77, 222.86, 30, 2.56, 2.97, 27, 5.34, 213.30, 26, 0.42, 380.13, 23, 2.49, 146.59, 20, 3.70, 70.85, 20, 5.93, 529.69, 20, 5.37, 299.13, 19, 3.83, 38.13, 19, 1.09, 111.43, +/*B2*/ 9212, 5.8004, 74.7816, 557, 0.000, 0.000, 286, 2.177, 149.563, 95, 3.84, 73.30, 45, 4.88, 76.27, 20, 5.46, 1.48, 15, 0.88, 138.52, 14, 2.85, 148.08, 14, 5.07, 63.74, 10, 5.00, 224.34, 8, 6.27, 78.71, 5, 5.16, 71.81, +/*B3*/ 268, 1.251, 74.782, 11, 3.14, 0.00, 6, 4.01, 149.56, 3, 5.78, 73.30, 2, 1.06, 63.74, +/*B4*/ 6, 2.85, 74.78, +/*R0*/ 1921264848, 0.0000000000, 0.0000000000, 88784984, 5.60377527, 74.78159857, 3440836, 0.3283610, 73.2971259, 2055653, 1.7829517, 149.5631971, 649322, 4.522473, 76.266071, 602248, 3.860038, 63.735898, 496404, 1.401399, 454.909367, 338526, 1.580027, 138.517497, 243508, 1.570866, 71.812653, 190522, 1.998094, 1.484473, 161858, 2.791379, 148.078724, 143706, 1.383686, 11.045700, 93192, 0.17437, 36.64856, 89806, 3.66105, 109.94569, 71424, 4.24509, 224.34480, 46677, 1.39977, 35.16409, 39026, 3.36235, 277.03499, 39010, 1.66971, 70.84945, 36755, 3.88649, 146.59425, 30349, 0.70100, 151.04767, 29156, 3.18056, 77.75054, 25786, 3.78538, 85.82730, 25620, 5.25656, 380.12777, 22637, 0.72519, 529.69097, 20473, 2.79640, 70.32818, 20472, 1.55589, 202.25340, 17901, 0.55455, 2.96895, 15503, 5.35405, 38.13304, 14702, 4.90434, 108.46122, 12897, 2.62154, 111.43016, 12328, 5.96039, 127.47180, 11959, 1.75044, 984.60033, 11853, 0.99343, 52.69020, 11696, 3.29826, 3.93215, 11495, 0.43774, 65.22037, 10793, 1.42105, 213.29910, 9111, 4.9964, 62.2514, 8421, 5.2535, 222.8603, 8402, 5.0388, 415.5525, 7449, 0.7949, 351.8166, 7329, 3.9728, 183.2428, 6046, 5.6796, 78.7138, 5524, 3.1150, 9.5612, 5445, 5.1058, 145.1098, 5238, 2.6296, 33.6796, 4079, 3.2206, 340.7709, 3919, 4.2502, 39.6175, 3802, 6.1099, 184.7273, 3781, 3.4584, 456.3938, 3687, 2.4872, 453.4249, 3102, 4.1403, 219.8914, 2963, 0.8298, 56.6224, 2942, 0.4239, 299.1264, 2940, 2.1464, 137.0330, 2938, 3.6766, 140.0020, 2865, 0.3100, 12.5302, 2538, 4.8546, 131.4039, 2364, 0.4425, 554.0700, 2183, 2.9404, 305.3462, 1979, 6.1284, 106.9767, 1963, 0.0411, 221.3759, 1963, 5.2434, 84.3428, 1849, 2.9111, 909.8187, 1830, 4.0111, 68.8437, 1656, 1.9643, 79.2350, 1643, 0.3556, 67.6681, 1632, 4.2306, 22.0914, 1585, 3.1627, 225.8293, 1563, 1.4792, 112.9146, 1507, 5.2419, 181.7583, 1482, 5.6620, 152.5321, 1477, 4.3221, 256.5399, 1439, 1.5305, 447.7958, 1409, 4.4192, 462.0229, 1404, 5.6356, 4.4534, 1401, 1.3908, 265.9893, 1250, 6.2448, 160.6089, 1249, 5.4403, 54.1747, 1248, 4.8898, 479.2884, 1228, 5.9770, 59.8037, 1197, 2.5219, 145.6310, 1091, 4.1539, 77.9630, 1072, 1.7429, 528.2065, 906, 5.620, 74.670, 900, 2.373, 74.893, 845, 0.129, 82.858, 759, 2.137, 692.587, 719, 4.000, 128.956, 710, 5.416, 218.407, 710, 4.220, 381.612, 710, 4.490, 293.189, 705, 0.455, 835.037, 700, 0.040, 143.625, 690, 3.081, 69.365, 652, 4.423, 18.159, 642, 2.711, 87.312, 630, 4.461, 275.551, 598, 0.358, 269.921, 594, 3.838, 32.195, 594, 4.501, 8.077, 588, 5.083, 186.212, 576, 5.896, 66.705, 575, 5.579, 2.448, 570, 1.639, 77.229, 557, 1.072, 1059.382, 549, 5.628, 3.181, 545, 5.694, 203.738, 542, 5.395, 278.519, 540, 6.208, 71.600, 516, 3.233, 284.149, 503, 5.839, 191.208, 496, 2.651, 200.769, 488, 0.064, 60.767, 477, 2.894, 39.357, 464, 2.354, 211.815, 464, 1.434, 297.642, 455, 2.593, 490.334, 455, 4.084, 99.161, 449, 0.280, 617.806, 437, 0.528, 209.367, 436, 2.082, 51.206, 436, 2.101, 1514.291, 436, 2.794, 75.745, 429, 3.080, 41.102, 420, 2.254, 81.001, 414, 0.090, 258.024, 410, 3.050, 404.507, 405, 6.123, 24.379, 387, 0.686, 230.565, 380, 0.058, 378.643, 368, 0.712, 125.987, 365, 5.595, 255.055, 359, 0.009, 35.425, 359, 0.352, 426.598, 358, 4.714, 173.942, 354, 4.657, 329.837, 326, 4.720, 134.585, 324, 4.829, 195.140, 320, 5.486, 14.978, 308, 3.924, 116.426, 306, 3.761, 344.703, 305, 2.555, 6208.294, 302, 0.132, 565.116, 296, 4.211, 1364.728, 293, 3.995, 72.334, 287, 1.850, 153.495, 262, 3.837, 831.105, 256, 1.167, 177.874, 250, 4.242, 75.303, 248, 1.063, 105.492, 245, 5.949, 20.607, 241, 1.605, 81.374, 234, 2.971, 46.210, 234, 4.481, 628.852, 225, 0.407, 114.399, 220, 0.196, 180.274, 220, 2.961, 120.358, 219, 0.248, 294.673, 217, 3.429, 241.610, 211, 4.931, 103.093, 205, 2.304, 259.509, 194, 6.117, 414.068, 192, 5.767, 291.704, 189, 2.236, 5.417, 188, 2.045, 408.439, 187, 3.035, 135.549, 182, 0.784, 417.037, 182, 0.707, 391.173, 179, 4.824, 366.486, 178, 3.980, 10138.504, 176, 1.960, 756.323, 176, 5.508, 7.114, 172, 5.217, 41.644, 171, 2.309, 98.900, 170, 4.950, 206.186, 170, 4.510, 288.081, 169, 4.043, 55.659, 168, 5.258, 518.645, 167, 4.922, 422.666, 164, 5.225, 67.359, 162, 3.273, 443.864, 162, 4.995, 73.818, 161, 3.823, 451.940, 157, 0.663, 220.413, 155, 4.320, 760.256, 154, 4.278, 45.577, 154, 4.707, 543.024, 152, 4.647, 155.783, 146, 2.657, 465.955, 143, 2.078, 457.878, 142, 1.270, 159.124, 134, 5.309, 14.015, 133, 2.889, 373.908, 129, 0.363, 96.873, 127, 0.424, 331.322, 125, 4.305, 339.286, 123, 2.383, 141.486, 117, 3.950, 74.260, 117, 1.837, 1289.947, 116, 4.435, 5.938, 116, 2.512, 296.157, 115, 6.249, 767.369, 113, 4.654, 80.198, 113, 0.831, 100.384, 113, 0.081, 558.002, 112, 1.212, 329.725, 111, 0.750, 80.719, 111, 0.387, 216.922, 108, 3.773, 142.450, 107, 2.394, 347.884, 107, 1.821, 306.831, 106, 0.816, 1087.693, 105, 5.945, 328.353, 104, 2.994, 6.220, 103, 0.698, 358.930, 101, 1.057, 92.308, 99, 4.33, 74.52, 98, 3.73, 75.04, 97, 0.69, 977.49, 96, 5.55, 969.62, 95, 0.80, 342.26, 94, 4.54, 28.57, 94, 4.99, 403.13, 91, 5.17, 144.15, 91, 0.22, 333.66, 90, 0.37, 0.96, 90, 3.80, 986.08, 89, 2.19, 74.83, 89, 5.88, 74.73, 89, 4.74, 604.47, 89, 4.44, 154.02, 87, 5.62, 300.61, 86, 2.83, 983.12, 85, 5.80, 6.59, 85, 1.26, 142.14, 84, 1.84, 227.31, 83, 1.88, 387.24, 83, 2.21, 74.94, 83, 5.86, 74.62, 80, 2.98, 526.72, 79, 5.67, 267.47, 78, 2.73, 110.21, 76, 2.78, 88.11, 76, 4.66, 101.87, 76, 5.41, 50.40, 75, 5.37, 373.01, 75, 1.35, 350.33, 74, 6.21, 312.46, 73, 0.58, 367.97, 71, 3.17, 23.58, 71, 3.65, 894.84, 71, 0.56, 92.94, 71, 4.66, 44.73, 70, 1.52, 552.59, 70, 3.74, 546.96, 70, 3.95, 187.70, 69, 2.45, 555.55, 69, 2.42, 235.39, 69, 4.77, 991.71, 67, 0.86, 522.58, 66, 5.05, 30.71, 65, 4.24, 771.30, 65, 0.69, 152.74, 65, 3.74, 536.80, 65, 5.27, 68.19, 64, 2.37, 157.64, 64, 0.10, 681.54, 63, 4.60, 67.88, 63, 2.90, 79.89, 63, 0.29, 119.51, 63, 5.36, 92.05, 63, 0.34, 561.18, 62, 2.68, 130.44, 62, 2.32, 74.03, 61, 0.58, 253.57, +/*R1*/ 1479896, 3.6720571, 74.7815986, 71212, 6.22601, 63.73590, 68627, 6.13411, 149.56320, 24060, 3.14159, 0.00000, 21468, 2.60177, 76.26607, 20857, 5.24625, 11.04570, 11405, 0.01848, 70.84945, 7497, 0.4236, 73.2971, 4244, 1.4169, 85.8273, 3927, 3.1551, 71.8127, 3578, 2.3116, 224.3448, 3506, 2.5835, 138.5175, 3229, 5.2550, 3.9322, 3060, 0.1532, 1.4845, 2564, 0.9808, 148.0787, 2429, 3.9944, 52.6902, 1645, 2.6535, 127.4718, 1584, 1.4305, 78.7138, 1508, 5.0600, 151.0477, 1490, 2.6756, 56.6224, 1413, 4.5746, 202.2534, 1403, 1.3699, 77.7505, 1228, 1.0470, 62.2514, 1033, 0.2646, 131.4039, 992, 2.172, 65.220, 862, 5.055, 351.817, 744, 3.076, 35.164, 687, 2.499, 77.963, 647, 4.473, 70.328, 624, 0.863, 9.561, 604, 0.907, 984.600, 575, 3.231, 447.796, 562, 2.718, 462.023, 530, 5.917, 213.299, 528, 5.151, 2.969, 494, 0.463, 145.631, 487, 0.706, 380.128, 460, 4.223, 12.530, 444, 2.156, 67.668, 406, 1.230, 22.091, 381, 3.851, 3.181, 373, 5.051, 529.691, 348, 1.749, 71.600, 339, 2.538, 18.159, 272, 3.384, 222.860, 269, 6.241, 340.771, 259, 3.921, 59.804, 256, 2.957, 84.343, 255, 3.504, 38.133, 238, 2.049, 269.921, 234, 0.278, 108.461, 225, 3.910, 160.609, 222, 3.647, 137.033, 212, 0.680, 111.430, 206, 1.534, 284.149, 201, 1.249, 69.365, 196, 4.772, 299.126, 189, 4.413, 265.989, 163, 4.341, 33.680, 153, 5.218, 209.367, 151, 1.990, 54.175, 137, 0.403, 195.140, 128, 2.403, 39.618, 117, 0.396, 87.312, 107, 1.230, 225.829, 106, 0.698, 2.448, 106, 0.171, 79.235, 105, 4.436, 305.346, 104, 2.922, 134.585, 104, 1.816, 72.334, 104, 2.576, 191.208, 100, 4.941, 120.358, 97, 3.81, 152.53, 95, 4.03, 82.86, 94, 5.02, 51.21, 93, 3.09, 77.23, 86, 0.53, 145.11, 85, 0.62, 116.43, 85, 5.72, 68.84, 85, 5.56, 344.70, 78, 1.64, 479.29, 77, 0.08, 45.58, 76, 4.20, 73.82, 76, 3.79, 75.74, 72, 4.31, 565.12, 72, 3.71, 408.44, 72, 3.94, 153.50, 71, 2.38, 60.77, 65, 1.56, 106.98, 64, 1.94, 41.64, 63, 4.19, 184.73, 62, 3.24, 422.67, 62, 4.39, 453.42, 62, 3.90, 4.45, 60, 0.60, 74.89, 59, 1.56, 456.39, 58, 5.33, 220.41, 57, 0.84, 146.59, 55, 1.60, 14.98, 54, 3.73, 7.11, 53, 4.45, 426.60, 53, 5.20, 358.93, 53, 3.50, 125.99, 52, 6.09, 404.51, 52, 1.76, 8.08, 51, 0.37, 206.19, 51, 0.53, 490.33, 49, 5.85, 112.91, 49, 4.26, 5.42, 49, 0.94, 99.16, 49, 3.63, 81.00, 48, 1.97, 288.08, 46, 5.35, 152.74, 44, 3.04, 20.61, 43, 1.26, 1514.29, 42, 0.05, 128.96, 42, 2.51, 24.38, 41, 2.34, 277.03, 40, 5.10, 35.42, 39, 5.49, 200.77, 39, 0.74, 347.88, 39, 4.95, 92.94, 38, 2.06, 333.66, 38, 3.62, 173.94, 36, 3.73, 96.87, 34, 3.68, 66.92, 33, 6.26, 1059.38, 33, 1.38, 74.67, 32, 4.38, 221.38, 32, 0.54, 203.74, 31, 0.80, 373.01, 31, 2.05, 230.56, 31, 2.54, 977.49, 30, 0.71, 109.95, 30, 0.19, 387.24, 29, 5.43, 58.11, 29, 3.11, 991.71, 28, 4.77, 415.55, 28, 0.37, 80.20, 27, 2.15, 140.00, 27, 2.03, 536.80, 27, 1.36, 0.96, 26, 4.53, 454.91, 26, 3.47, 144.15, 26, 5.43, 546.96, 26, 2.57, 522.58, 25, 1.80, 143.63, 25, 5.12, 81.37, 25, 0.55, 181.76, 25, 3.04, 14.01, 24, 3.30, 617.81, 24, 2.20, 628.85, 24, 5.67, 443.86, 24, 5.60, 32.20, 24, 4.95, 561.18, 24, 0.66, 46.21, 23, 3.81, 55.14, 23, 5.85, 297.64, 22, 4.82, 135.55, 22, 4.62, 391.17, 22, 4.59, 241.61, 22, 1.23, 41.10, 21, 5.27, 159.12, 21, 4.19, 329.73, 21, 0.24, 465.96, 21, 0.91, 76.48, 20, 3.16, 186.21, 20, 0.66, 66.70, 20, 1.30, 518.65, 20, 4.91, 909.82, +/*R2*/ 22440, 0.69953, 74.78160, 4727, 1.6990, 63.7359, 1682, 4.6483, 70.8494, 1650, 3.0966, 11.0457, 1434, 3.5212, 149.5632, 770, 0.000, 0.000, 500, 6.172, 76.266, 461, 0.767, 3.932, 390, 4.496, 56.622, 390, 5.527, 85.827, 292, 0.204, 52.690, 287, 3.534, 73.297, 273, 3.847, 138.517, 220, 1.964, 131.404, 216, 0.848, 77.963, 205, 3.248, 78.714, 149, 4.898, 127.472, 129, 2.081, 3.181, 117, 4.934, 447.796, 114, 4.787, 145.631, 113, 1.014, 462.023, 104, 3.586, 71.600, 99, 6.16, 224.34, 91, 0.68, 18.16, 89, 0.23, 202.25, 88, 2.93, 62.25, 71, 6.10, 454.91, 64, 3.39, 1.48, 64, 3.96, 67.67, 62, 3.30, 351.82, 59, 5.56, 9.56, 58, 4.91, 22.09, 51, 3.87, 65.22, 49, 3.75, 269.92, 44, 5.90, 71.81, 44, 1.93, 59.80, 42, 6.14, 284.15, 42, 2.62, 151.05, 42, 2.09, 12.53, 37, 5.91, 984.60, 36, 5.40, 77.75, 31, 4.59, 148.08, 31, 2.27, 195.14, 28, 4.58, 77.23, 28, 4.91, 277.03, 27, 3.53, 209.37, 26, 0.66, 120.36, 24, 5.87, 69.36, 23, 1.04, 84.34, 23, 1.71, 160.61, 21, 2.20, 45.58, 20, 2.32, 2.45, 17, 4.37, 54.17, 17, 4.78, 213.30, 17, 1.86, 340.77, 16, 0.40, 265.99, 16, 3.65, 152.74, 15, 5.44, 408.44, 14, 3.39, 358.93, 13, 1.53, 422.67, 13, 5.25, 137.03, 13, 1.26, 134.59, 13, 4.43, 87.31, 13, 3.03, 92.94, 12, 1.33, 51.21, 12, 3.24, 116.43, 12, 5.10, 191.21, 12, 4.66, 41.64, 12, 3.73, 220.41, 12, 4.17, 60.55, 11, 2.03, 7.11, 11, 1.08, 72.33, 10, 1.19, 344.70, 10, 0.33, 70.33, 10, 5.97, 35.16, 10, 3.06, 2.97, 10, 0.39, 415.55, 9, 2.44, 565.12, 9, 6.05, 146.38, 9, 5.19, 225.83, 9, 6.01, 5.42, 9, 5.82, 153.50, 9, 5.25, 347.88, 8, 3.91, 333.66, 8, 4.49, 70.12, 8, 3.72, 14.98, 8, 2.27, 299.13, 8, 2.26, 206.19, 8, 5.72, 55.14, 8, 0.90, 222.86, 7, 1.51, 991.71, 7, 1.18, 96.87, +/*R3*/ 1164, 4.7345, 74.7816, 212, 3.343, 63.736, 196, 2.980, 70.849, 105, 0.958, 11.046, 73, 1.00, 149.56, 72, 0.03, 56.62, 55, 2.59, 3.93, 36, 5.65, 77.96, 34, 3.82, 76.27, 32, 3.60, 131.40, 30, 3.44, 85.83, 28, 0.43, 3.18, 27, 2.55, 52.69, 25, 5.14, 78.71, 19, 5.13, 18.16, 18, 0.00, 0.00, 16, 5.20, 71.60, 16, 0.37, 447.80, 15, 2.97, 145.63, 15, 5.57, 462.02, 15, 3.86, 73.30, 11, 6.03, 138.52, 11, 3.58, 224.34, 8, 2.62, 22.09, 8, 0.30, 127.47, 8, 1.45, 1.48, 7, 5.44, 269.92, 7, 0.01, 151.05, 6, 4.37, 284.15, 6, 4.23, 373.01, 5, 4.16, 195.14, 5, 0.78, 62.25, 5, 1.84, 202.25, 5, 2.78, 120.36, 4, 3.96, 9.56, 4, 1.84, 72.33, 4, 1.86, 152.74, 4, 1.89, 209.37, 4, 1.05, 92.94, 4, 2.00, 65.22, 4, 1.17, 153.50, 4, 3.93, 124.29, 3, 1.54, 148.08, 3, 1.41, 351.82, 3, 2.99, 387.24, 3, 5.84, 160.61, 3, 6.04, 12.53, 3, 0.79, 572.23, 3, 5.65, 134.59, 3, 2.77, 213.30, 3, 1.99, 450.98, +/*R4*/ 53, 3.01, 74.78, 10, 1.91, 56.62, 7, 5.09, 11.05, 7, 5.43, 149.56, 4, 5.23, 131.40, 3, 1.30, 85.83, 3, 3.14, 0.00, 3, 0.44, 63.74, 2, 6.21, 358.93, 2, 0.92, 145.63, 2, 2.23, 440.68 }; + +//Dnep精度:J2000+-4千年 黄经1角秒 黄纬1角秒 距离40AU/10^6 +static constexpr long double XL0_7[] = { +100000000,//A的倍率 +20, 188, 260, 281, 293, 299, 302, 359, 404, 419, 422, 425, 425, 638, 701, 743, 746, 746, 746,//位置索引表 +/*L0*/ 531188633, 0.000000000, 0.000000000, 1798476, 2.9010127, 38.1330356, 1019728, 0.4858092, 1.4844727, 124532, 4.830081, 36.648563, 42064, 5.41055, 2.96895, 37715, 6.09222, 35.16409, 33785, 1.24489, 76.26607, 16483, 0.00008, 491.55793, 9199, 4.9375, 39.6175, 8994, 0.2746, 175.1661, 4216, 1.9871, 73.2971, 3365, 1.0359, 33.6796, 2285, 4.2061, 4.4534, 1434, 2.7834, 74.7816, 900, 2.076, 109.946, 745, 3.190, 71.813, 506, 5.748, 114.399, 400, 0.350, 1021.249, 345, 3.462, 41.102, 340, 3.304, 77.751, 323, 2.248, 32.195, 306, 0.497, 0.521, 287, 4.505, 0.048, 282, 2.246, 146.594, 267, 4.889, 0.963, 252, 5.782, 388.465, 245, 1.247, 9.561, 233, 2.505, 137.033, 227, 1.797, 453.425, 170, 3.324, 108.461, 151, 2.192, 33.940, 150, 2.997, 5.938, 148, 0.859, 111.430, 119, 3.677, 2.448, 109, 2.416, 183.243, 103, 0.041, 0.261, 103, 4.404, 70.328, 102, 5.705, 0.112, 98, 2.81, 8.08, 86, 4.23, 490.07, 82, 5.20, 493.04, 78, 4.16, 4.19, 74, 1.33, 529.69, 72, 5.30, 350.33, 64, 3.55, 168.05, 63, 0.15, 182.28, 58, 3.50, 145.11, 48, 1.11, 112.91, 48, 0.13, 484.44, 48, 2.58, 219.89, 47, 4.57, 46.21, 47, 4.50, 173.68, 47, 3.02, 498.67, 45, 5.47, 176.65, 39, 1.67, 213.30, 39, 2.39, 2.92, +/*L1*/ 3837687717, 0.0000000000, 0.0000000000, 16604, 4.86319, 1.48447, 15807, 2.27923, 38.13304, 3335, 3.6820, 76.2661, 1306, 3.6732, 2.9689, 605, 1.505, 35.164, 179, 3.453, 39.618, 107, 2.451, 4.453, 106, 2.755, 33.680, 73, 5.49, 36.65, 57, 1.86, 114.40, 57, 5.22, 0.52, 35, 4.52, 74.78, 32, 5.90, 77.75, 30, 3.67, 388.47, 29, 5.17, 9.56, 29, 5.17, 2.45, 26, 5.25, 168.05, 25, 4.73, 182.28, 20, 5.79, 1021.25, 19, 1.83, 484.44, 19, 1.32, 498.67, 15, 3.99, 32.20, 15, 4.95, 137.03, +/*L2*/ 53893, 0.00000, 0.00000, 296, 1.855, 1.484, 281, 1.191, 38.133, 270, 5.721, 76.266, 23, 1.21, 2.97, 9, 4.43, 35.16, 7, 0.54, 2.45, +/*L3*/ 31, 0.00, 0.00, 15, 1.35, 76.27, 12, 6.04, 1.48, 12, 6.11, 38.13, +/*L4*/ 114, 3.142, 0.000, 1, 3.18, 76.27, +/*L5*/ 1, 3.14, 0.00, +/*B0*/ 3088623, 1.4410437, 38.1330356, 27780, 5.91272, 76.26607, 27624, 0.00000, 0.00000, 15448, 3.50877, 39.61751, 15355, 2.52124, 36.64856, 2000, 1.5100, 74.7816, 1968, 4.3778, 1.4845, 1015, 3.2156, 35.1641, 606, 2.802, 73.297, 595, 2.129, 41.102, 589, 3.187, 2.969, 402, 4.169, 114.399, 280, 1.682, 77.751, 262, 3.767, 213.299, 254, 3.271, 453.425, 206, 4.257, 529.691, 140, 3.530, 137.033, 99, 4.17, 33.68, 68, 4.67, 71.81, +/*B1*/ 227279, 3.807931, 38.133036, 1803, 1.9758, 76.2661, 1433, 3.1416, 0.0000, 1386, 4.8256, 36.6486, 1073, 6.0805, 39.6175, 148, 3.858, 74.782, 136, 0.478, 1.484, 70, 6.19, 35.16, 52, 5.05, 73.30, 43, 0.31, 114.40, 37, 4.89, 41.10, 37, 5.76, 2.97, 26, 5.22, 213.30, 19, 0.90, 453.42, 17, 4.26, 77.75, +/*B2*/ 9691, 5.5712, 38.1330, 79, 3.63, 76.27, 72, 0.45, 36.65, 59, 3.14, 0.00, 30, 1.61, 39.62, +/*B3*/ 273, 1.017, 38.133, +/*B4*/ 6, 2.67, 38.13, +/*B5*/ +/*R0*/ 3007013206, 0.0000000000, 0.0000000000, 27062259, 1.32999459, 38.13303564, 1691764, 3.2518614, 36.6485629, 807831, 5.185928, 1.484473, 537761, 4.521139, 35.164090, 495726, 1.571057, 491.557929, 274572, 1.845523, 175.166060, 135134, 3.372206, 39.617508, 121802, 5.797544, 76.266071, 100895, 0.377027, 73.297126, 69792, 3.79617, 2.96895, 46688, 5.74938, 33.67962, 24594, 0.50802, 109.94569, 16939, 1.59422, 71.81265, 14230, 1.07786, 74.78160, 12012, 1.92062, 1021.24889, 8395, 0.6782, 146.5943, 7572, 1.0715, 388.4652, 5721, 2.5906, 4.4534, 4840, 1.9069, 41.1020, 4483, 2.9057, 529.6910, 4421, 1.7499, 108.4612, 4354, 0.6799, 32.1951, 4270, 3.4134, 453.4249, 3381, 0.8481, 183.2428, 2881, 1.9860, 137.0330, 2879, 3.6742, 350.3321, 2636, 3.0976, 213.2991, 2530, 5.7984, 490.0735, 2523, 0.4863, 493.0424, 2306, 2.8096, 70.3282, 2087, 0.6186, 33.9402, 1977, 5.1170, 168.0525, 1905, 1.7219, 182.2796, 1654, 1.9278, 145.1098, 1499, 1.0162, 219.8914, 1435, 1.7001, 484.4444, 1403, 6.0766, 173.6816, 1403, 4.5891, 498.6715, 1399, 0.7622, 176.6505, 1228, 1.5988, 77.7505, 1129, 5.9666, 9.5612, 835, 3.971, 114.399, 811, 3.003, 46.210, 732, 2.104, 181.758, 705, 1.187, 256.540, 616, 2.979, 106.977, 530, 4.241, 111.430, 502, 1.387, 5.938, 437, 2.270, 1550.940, 422, 5.532, 525.498, 421, 1.891, 30.711, 400, 1.256, 8.077, 382, 3.300, 983.116, 355, 2.278, 218.407, 345, 1.359, 293.189, 333, 5.751, 39.096, 321, 1.506, 454.909, 314, 3.959, 381.352, 309, 2.855, 72.073, 307, 0.320, 601.764, 306, 2.725, 6244.943, 294, 4.891, 528.206, 292, 4.024, 68.844, 281, 4.542, 44.725, 280, 1.541, 98.900, 268, 5.133, 112.915, 251, 3.540, 312.199, 248, 3.411, 37.612, 246, 1.015, 141.226, 240, 3.164, 143.625, +/*R1*/ 236339, 0.704980, 38.133036, 13220, 3.32015, 1.48447, 8622, 6.2163, 35.1641, 2702, 1.8814, 39.6175, 2155, 2.0943, 2.9689, 2153, 5.1687, 76.2661, 1603, 0.0000, 0.0000, 1464, 1.1842, 33.6796, 1136, 3.9189, 36.6486, 898, 5.241, 388.465, 790, 0.533, 168.053, 760, 0.021, 182.280, 607, 1.077, 1021.249, 572, 3.401, 484.444, 561, 2.887, 498.671, 490, 3.468, 137.033, 271, 3.274, 71.813, 264, 0.862, 4.453, 204, 2.418, 32.195, 155, 0.365, 41.102, 133, 3.602, 9.561, +/*R2*/ 4247, 5.8991, 38.1330, 218, 0.346, 1.484, 163, 2.239, 168.053, 156, 4.594, 182.280, 127, 2.848, 35.164, 118, 5.103, 484.444, 112, 1.190, 498.671, 99, 3.42, 175.17, 77, 0.02, 491.56, 65, 3.46, 388.47, 50, 4.07, 76.27, 39, 6.10, 1021.25, 37, 5.97, 2.97, 36, 5.17, 137.03, +/*R3*/ 166, 4.552, 38.133 }; + +static constexpr const long double* XL0[] = { + XL0_0, + XL0_1, + XL0_2, + XL0_3, + XL0_4, + XL0_5, + XL0_6, + XL0_7 +}; + + +/******************************** +月亮星历数据表 +********************************/ +//以下是月球黄经周期项及泊松项,精度0.5角秒,平均误差0.8角秒,近期精度更高一些 +/****** +1.黄经精度(角秒):0.5 +2.黄纬精度(角秒):0.5 +3.距离精度(千米):1 +4.J2000.0时间最大偏移(世纪数):30 +5.小数点增补位数:3 + +误差检测 +1.测试点数N；2 n2) N = n2; } + c = 0; + for (int j = n1; j < (int)N; j += 3) + { + c += F[j] * cos(F[j + 1] + t*F[j + 2]); + } + v += c*tn; + } + v /= F[0]; + if (xt == 0) { //地球 + long double t2 = t*t, t3 = t2*t; //千年数的各次方 + if (zn == 0) v += (-0.0728 - 2.7702*t - 1.1019*t2 - 0.0996*t3) / rad; + if (zn == 1) v += (+0.0000 + 0.0004*t + 0.0004*t2 - 0.0026*t3) / rad; + if (zn == 2) v += (-0.0020 + 0.0044*t + 0.0213*t2 - 0.0250*t3) / 1000000; + } + else { //其它行星 + long double dv = XL0_xzb[(xt - 1) * 3 + zn]; + if (zn == 0) v += -3 * t / rad; + if (zn == 2) v += dv / 1000000; + else v += dv / rad; + } + return v; +} + +//返回冥王星J2000直角坐标(未实现) +Vector3 pluto_coord(long double t) { + /*long double c0 = PI / 180 / 100000; + long double x = -1 + 2 * (t * 36525 + 1825394.5) / 2185000; + long double T = t / 100000000;*/ + Vector3 r; + + /*for (int i = 0; i < 9; i++) { + long double ob = XL0Pluto[i], N = ob.length, v = 0; + for (int j = 0; j < N; j += 3) v += ob[j] * Math.sin(ob[j + 1] * T + ob[j + 2] * c0); + if (i % 3 == 1) v *= x; + if (i % 3 == 2) v *= x*x; + r[Math.floor(i / 3)] += v / 100000000; + } + r[0] += 9.922274 + 0.154154*x; + r[1] += 10.016090 + 0.064073*x; + r[2] += -3.947474 - 0.042746*x;*/ + return r; +} + +//xt星体,T儒略世纪数,TD +Vector3 p_coord(int xt, int t, int n1, int n2, int n3) { + Vector3 z; + if (xt < 8) { + z[0] = XL0_calc(xt, 0, t, n1); + z[1] = XL0_calc(xt, 1, t, n2); + z[2] = XL0_calc(xt, 2, t, n3); + } + if (xt == 8) { //冥王星 + z = pluto_coord(t); + z = xyz2llr(z); + z = HDllr_J2D(t, z, "P03"); + } + if (xt == 9) { //太阳 + z[0] = 0, z[1] = 0, z[2] = 0; + } + return z; +} + +//返回地球坐标,t为世纪数 +Vector3 e_coord(int t, int n1, int n2, int n3) { + Vector3 re; + re[0] = XL0_calc(0, 0, t, n1); + re[1] = XL0_calc(0, 1, t, n2); + re[2] = XL0_calc(0, 2, t, n3); + return re; +} + +//=================================月亮星历--======================================= +//================================================================================== +//计算月亮 +long double XL1_calc(int zn, long double t, int n) { + const long double* const* ob = XL1[zn]; + long double F, N, v = 0, tn = 1, c = 0; + long double t2 = t*t, t3 = t2*t, t4 = t3*t, t5 = t4*t, tx = t - 10; + if (zn == 0) { + v += (3.81034409 + 8399.684730072*t - 3.319e-05*t2 + 3.11e-08*t3 - 2.033e-10*t4)*rad; //月球平黄经(弧度) + v += 5028.792262*t + 1.1124406*t2 + 0.00007699*t3 - 0.000023479*t4 - 0.0000000178*t5; //岁差(角秒) + if (tx > 0) v += -0.866 + 1.43*tx + 0.054*tx*tx; //对公元3000年至公元5000年的拟合,最大误差小于10角秒 + } + t2 /= 1e4, t3 /= 1e8, t4 /= 1e8; + n *= 6; if (n < 0) n = 3/*ob[0].length*/; + for (int i = 0; i < 3/*ob.length*/; i++, tn *= t) { + const long double* F = ob[i]; + int F_len = 0; + if (zn == 0 && i == 0) + { + F_len = sizeof(XL1_0_0) / sizeof(long double); + } + else if (zn == 0 && i == 1) + { + F_len = sizeof(XL1_0_1) / sizeof(long double); + } + else if (zn == 0 && i == 2) + { + F_len = sizeof(XL1_0_2) / sizeof(long double); + } + else if (zn == 1 && i == 0) + { + F_len = sizeof(XL1_1_0) / sizeof(long double); + } + else if (zn == 1 && i == 1) + { + F_len = sizeof(XL1_1_1) / sizeof(long double); + } + else if (zn == 1 && i == 2) + { + F_len = sizeof(XL1_1_2) / sizeof(long double); + } + else if (zn == 2 && i == 0) + { + F_len = sizeof(XL1_2_0) / sizeof(long double); + } + else if (zn == 2 && i == 1) + { + F_len = sizeof(XL1_2_1) / sizeof(long double); + } + else if (zn == 2 && i == 2) + { + F_len = sizeof(XL1_2_2) / sizeof(long double); + } + + N = int2(n*F_len / 3/*ob[0].length*/ + 0.5); if (i) N += 6; if (N >= F_len) N = F_len; + c = 0; + for (int j = 0; j < N; j += 6) c += F[j] * cos(F[j + 1] + t*F[j + 2] + t2*F[j + 3] + t3*F[j + 4] + t4*F[j + 5]); + v += c*tn; + } + if (zn != 2) v /= rad; + return v; +}; + +//返回月球坐标,n1,n2,n3为各坐标所取的项数 +Vector3 m_coord(int t, int n1, int n2, int n3) { + Vector3 re; + re[0] = XL1_calc(0, t, n1); + re[1] = XL1_calc(1, t, n2); + re[2] = XL1_calc(2, t, n3); + return re; +} + +//=============================一些天文基本问题===================================== +//================================================================================== +//返回朔日的编号,jd应在朔日附近，允许误差数天 +int suoN(int jd) +{ + return int((jd + 8) / 29.5306); +} + +long double gxc_sunLon(long double t) { //太阳光行差,t是世纪数 + long double v = -0.043126 + 628.301955*t - 0.000002732*t*t; //平近点角 + long double e = 0.016708634 - 0.000042037*t - 0.0000001267*t*t; + return (-20.49552 * (1 + e*cos(v))) / rad; //黄经光行差 +} + +long double gxc_sunLat(long double t) { return 0; } //黄纬光行差 +long double gxc_moonLon(long double t) { return -3.4E-6; } //月球经度光行差,误差0.07" +long double gxc_moonLat(long double t) { return 0.063*sin(0.057 + 8433.4662*t + 0.000064*t*t) / rad; } //月球纬度光行差,误差0.006" + +//传入T是2000年首起算的日数(UT),dt是deltatT(日),精度要求不高时dt可取值为0 //传入T是2000年首起算的日数(UT),dt是deltatT(日),精度要求不高时dt可取值为0 +long double pGST(long double T, long double dt) { + //返回格林尼治平恒星时(不含赤经章动及非多项式部分),即格林尼治子午圈的平春风点起算的赤经 + long double t = (T + dt) / 36525, t2 = t*t, t3 = t2*t, t4 = t3*t; + return pi2*(0.7790572732640 + 1.00273781191135448*T) //T是UT,下一行的t是力学时(世纪数) + + (0.014506 + 4612.15739966*t + 1.39667721*t2 - 0.00009344*t3 + 0.00001882*t4) / rad; +} + +long double pGST2(long double jd) { //传入力学时J2000起算日数，返回平恒星时 + long double dt = dt_T(jd); + return pGST(jd - dt, dt); +} + +//太阳升降计算。jd儒略日(须接近L当地平午UT)，L地理经度，fa地理纬度，sj=-1升,sj=1降 +long double sunShengJ(long double jd, long double L, long double fa, long double sj) { + jd = floor(jd + 0.5) - L / pi2; + for (int i = 0; i < 2; i++) { + long double T = jd / 36525, E = (84381.4060 - 46.836769*T) / rad; //黄赤交角 + long double t = T + (32 * (T + 1.8)*(T + 1.8) - 20) / 86400 / 36525; //儒略世纪年数,力学时 + long double J = (48950621.66 + 6283319653.318*t + 53 * t*t - 994 + + 334166 * cos(4.669257 + 628.307585*t) + + 3489 * cos(4.6261 + 1256.61517*t) + + 2060.6 * cos(2.67823 + 628.307585*t) * t) / 10000000; + long double sinJ = sin(J), cosJ = cos(J); //太阳黄经以及它的正余弦值 + long double gst = (0.7790572732640 + 1.00273781191135448*jd)*pi2 + (0.014506 + 4612.15739966*T + 1.39667721*T*T) / rad; //恒星时(子午圈位置) + long double A = atan2(sinJ*cos(E), cosJ); //太阳赤经 + long double D = asin(sin(E)*sinJ); //太阳赤纬 + long double cosH0 = (sin(-50 * 60 / rad) - sin(fa)*sin(D)) / (cos(fa)*cos(D)); + if (fabs(cosH0) >= 1) return 0; //太阳在地平线上的cos(时角)计算 + jd += rad2rrad(sj*acos(cosH0) - (gst + L - A)) / 6.28; //(升降时角-太阳时角)/太阳速度 + } + return jd; //反回格林尼治UT +} + +//时差计算(高精度),t力学时儒略世纪数 +long double pty_zty(long double t) { + long double t2 = t*t, t3 = t2*t, t4 = t3*t, t5 = t4*t; + long double L = (1753470142 + 628331965331.8*t + 5296.74*t2 + 0.432*t3 - 0.1124*t4 - 0.00009*t5) / 1000000000 + PI - 20.5 / rad; + + long double E, dE, dL, f; + Vector3 z; + dL = -17.2*sin(2.1824 - 33.75705*t) / rad; //黄经章 + dE = 9.2*cos(2.1824 - 33.75705*t) / rad; //交角章 + E = hcjj(t) + dE; //真黄赤交角 + + //地球坐标 + z[0] = XL0_calc(0, 0, t, 50) + PI + gxc_sunLon(t) + dL; + z[1] = -(2796 * cos(3.1987 + 8433.46616*t) + 1016 * cos(5.4225 + 550.75532*t) + 804 * cos(3.88 + 522.3694*t)) / 1000000000; + + z = llrConv(z, E); //z太阳地心赤道坐标 + z[0] -= dL*cos(E); + + L = rad2rrad(L - z[0]); + return L / pi2; //单位是周(天) +} + +long double pty_zty2(long double t) { //时差计算(低精度),误差约在1秒以内,t力学时儒略世纪数 + long double L = (1753470142 + 628331965331.8*t + 5296.74*t*t) / 1000000000 + PI; + Vector3 z; + long double E = (84381.4088 - 46.836051*t) / rad; + z[0] = XL0_calc(0, 0, t, 5) + PI, z[1] = 0; //地球坐标 + z = llrConv(z, E); //z太阳地心赤道坐标 + L = rad2rrad(L - z[0]); + return L / pi2; //单位是周(天) +} + +//物件XL : 日月黄道平分点坐标、视坐标、速度、已知经度反求时间等方面的计算 +namespace XL +{ + //===================== + //星历函数(日月球面坐标计算) + + long double E_Lon(long double t, int n) { return XL0_calc(0, 0, t, n); } //地球经度计算,返回Date分点黄经,传入世纪数、取项数 + long double M_Lon(long double t, int n) { return XL1_calc(0, t, n); } //月球经度计算,返回Date分点黄经,传入世纪数,n是项数比例 + //========================= + long double E_v(long double t) + { //地球速度,t是世纪数,误差小于万分3 + long double f = 628.307585*t; + return 628.332 + 21 * sin(1.527 + f) + 0.44 *sin(1.48 + f * 2) + + 0.129*sin(5.82 + f)*t + 0.00055*sin(4.21 + f)*t*t; + } + + //月球速度计算,传入世经数 + long double M_v(long double t) { + long double v = 8399.71 - 914 * sin(0.7848 + 8328.691425*t + 0.0001523*t*t); //误差小于5% + v -= 179 * sin(2.543 + 15542.7543*t) //误差小于0.3% + + 160 * sin(0.1874 + 7214.0629*t) + + 62 * sin(3.14 + 16657.3828*t) + + 34 * sin(4.827 + 16866.9323*t) + + 22 * sin(4.9 + 23871.4457*t) + + 12 * sin(2.59 + 14914.4523*t) + + 7 * sin(0.23 + 6585.7609*t) + + 5 * sin(0.9 + 25195.624 *t) + + 5 * sin(2.32 - 7700.3895*t) + + 5 * sin(3.88 + 8956.9934*t) + + 5 * sin(0.49 + 7771.3771*t); + return v; + } + + //========================= + //月日视黄经的差值 + long double MS_aLon(long double t, long double Mn, long double Sn) { + return M_Lon(t, Mn) + gxc_moonLon(t) - (E_Lon(t, Sn) + gxc_sunLon(t) + PI); + } + + //太阳视黄经 + long double S_aLon(long double t, long double n) { + return E_Lon(t, n) + nutationLon2(t) + gxc_sunLon(t) + PI; //注意，这里的章动计算很耗时 + } + + //========================= + //已知地球真黄经求时间 + long double E_Lon_t(long double W) { + long double t, v = 628.3319653318; + t = (W - 1.75347) / v; v = E_v(t); //v的精度0.03%，详见原文 + t += (W - E_Lon(t, 10)) / v; v = E_v(t); //再算一次v有助于提高精度,不算也可以 + t += (W - E_Lon(t, -1)) / v; + return t; + } + + //已知真月球黄经求时间 + long double M_Lon_t(long double W) { + long double t, v = 8399.70911033384; + t = (W - 3.81034) / v; + t += (W - M_Lon(t, 3)) / v; v = M_v(t); //v的精度0.5%，详见原文 + t += (W - M_Lon(t, 20)) / v; + t += (W - M_Lon(t, -1)) / v; + return t; + }; + + //已知月日视黄经差求时间 + long double MS_aLon_t(long double W) { + long double t, v = 7771.37714500204; + t = (W + 1.08472) / v; + t += (W - MS_aLon(t, 3, 3)) / v; v = M_v(t) - E_v(t); //v的精度0.5%，详见原文 + t += (W - MS_aLon(t, 20, 10)) / v; + t += (W - MS_aLon(t, -1, 60)) / v; + return t; + } + + //已知太阳视黄经反求时间 + long double S_aLon_t(long double W) { + long double t, v = 628.3319653318; + t = (W - 1.75347 - PI) / v; v = E_v(t); //v的精度0.03%，详见原文 + t += (W - S_aLon(t, 10)) / v; v = E_v(t); //再算一次v有助于提高精度,不算也可以 + t += (W - S_aLon(t, -1)) / v; + return t; + }; + /**** + MS_aLon_t1:function(W){ //已知月日视黄经差求时间,高速低精度,误差不超过40秒 + var t,v = 7771.37714500204; + t = ( W + 1.08472 )/v; + t += ( W - this.MS_aLon(t, 3, 3) )/v; v=this.M_v(t)-this.E_v(t); //v的精度0.5%，详见原文 + t += ( W - this.MS_aLon(t,50,20) )/v; + return t; + }, + S_aLon_t1:function(W){ //已知太阳视黄经反求时间,高速低精度,最大误差不超过50秒,平均误差15秒 + var t,v= 628.3319653318; + t = ( W - 1.75347-Math.PI )/v; v = 628.332 + 21*Math.sin( 1.527+628.307585*t ); + t += ( W - this.S_aLon(t,3) )/v; + t += ( W - this.S_aLon(t,40))/v; + return t; + }, + ****/ + //已知月日视黄经差求时间,高速低精度,误差不超过600秒(只验算了几千年) + long double MS_aLon_t2(long double W) { + long double t, v = 7771.37714500204; + t = (W + 1.08472) / v; + long double L, t2 = t*t; + t -= (-0.00003309*t2 + 0.10976*cos(0.784758 + 8328.6914246*t + 0.000152292*t2) + 0.02224 *cos(0.18740 + 7214.0628654*t - 0.00021848 *t2) - 0.03342 *cos(4.669257 + 628.307585*t)) / v; + L = M_Lon(t, 20) - (4.8950632 + 628.3319653318*t + 0.000005297*t*t + 0.0334166*cos(4.669257 + 628.307585*t) + 0.0002061*cos(2.67823 + 628.307585*t)*t + 0.000349*cos(4.6261 + 1256.61517*t) - 20.5 / rad); + v = 7771.38 - 914 * sin(0.7848 + 8328.691425*t + 0.0001523*t*t) - 179 * sin(2.543 + 15542.7543*t) - 160 * sin(0.1874 + 7214.0629*t); + t += (W - L) / v; + return t; + } + + long double S_aLon_t2(long double W) { //已知太阳视黄经反求时间,高速低精度,最大误差不超过600秒 + long double t, L, v = 628.3319653318; + t = (W - 1.75347 - PI) / v; + t -= (0.000005297*t*t + 0.0334166 * cos(4.669257 + 628.307585*t) + 0.0002061 * cos(2.67823 + 628.307585*t)*t) / v; + t += (W - E_Lon(t, 8) - PI + (20.5 + 17.2*sin(2.1824 - 33.75705*t)) / rad) / v; + return t; + } + + long double moonIll(long double t) { //月亮被照亮部分的比例 + long double t2 = t*t, t3 = t2*t, t4 = t3*t; + long double D, M, m, a, dm = PI / 180; + D = (297.8502042 + 445267.1115168*t - 0.0016300*t2 + t3 / 545868 - t4 / 113065000)*dm; //日月平距角 + M = (357.5291092 + 35999.0502909*t - 0.0001536*t2 + t3 / 24490000)*dm; //太阳平近点 + m = (134.9634114 + 477198.8676313*t + 0.0089970*t2 + t3 / 69699 - t4 / 14712000)*dm; //月亮平近点 + a = PI - D + (-6.289*sin(m) + 2.100*sin(M) - 1.274*sin(D * 2 - m) - 0.658*sin(D * 2) - 0.214*sin(m * 2) - 0.110*sin(D))*dm; + return (1 + cos(a)) / 2; + } + + //转入地平纬度及地月质心距离,返回站心视半径(角秒) + long double moonRad(long double r, long double h) { + return cs_sMoon / r*(1 + sin(h)*cs_rEar / r); + } + + //求月亮近点时间和距离,t为儒略世纪数力学时 + Vector2 moonMinR(long double t, long double min) { + long double a = 27.55454988 / 36525, b; + if (min) b = -10.3302 / 36525; else b = 3.4471 / 36525; + t = b + a * int2((t - b) / a + 0.5); //平近(远)点时间 + long double r1, r2, r3, dt; + //初算二次 + dt = 1 / 36525; + r1 = XL1_calc(2, t - dt, 10); + r2 = XL1_calc(2, t, 10); + r3 = XL1_calc(2, t + dt, 10); + t += (r1 - r3) / (r1 + r3 - 2 * r2)*dt / 2; + dt = 0.5 / 36525; + r1 = XL1_calc(2, t - dt, 20); + r2 = XL1_calc(2, t, 20); + r3 = XL1_calc(2, t + dt, 20); + t += (r1 - r3) / (r1 + r3 - 2 * r2)*dt / 2; + //精算 + dt = 1200 / 86400 / 36525; + r1 = XL1_calc(2, t - dt, -1); + r2 = XL1_calc(2, t, -1); + r3 = XL1_calc(2, t + dt, -1); + t += (r1 - r3) / (r1 + r3 - 2 * r2)*dt / 2; + r2 += (r1 - r3) / (r1 + r3 - 2 * r2)*(r3 - r1) / 8; + Vector2 re(t, r2); + return re; + } + + Vector3 moonNode(long double t, long double asc) {//月亮升交点 + long double a = 27.21222082 / 36525, b; + if (asc) b = 21 / 36525; else b = 35 / 36525; + t = b + a * int2((t - b) / a + 0.5); //平升(降)交点时间 + long double w, v, w2, dt; + dt = 0.5 / 36525; w = XL1_calc(1, t, 10); w2 = XL1_calc(1, t + dt, 10); v = (w2 - w) / dt; t -= w / v; + dt = 0.05 / 36525; w = XL1_calc(1, t, 40); w2 = XL1_calc(1, t + dt, 40); v = (w2 - w) / dt; t -= w / v; + w = XL1_calc(1, t, -1); t -= w / v; + Vector3 re;// (t, XL1_calc(0, t, -1)); + return re; + } + + //地球近远点 + Vector2 earthMinR(long double t, long double min) { + long double a = 365.25963586 / 36525, b; + if (min) b = 1.7 / 36525; else b = 184.5 / 36525; + t = b + a * int2((t - b) / a + 0.5); //平近(远)点时间 + long double r1, r2, r3, dt; + //初算二次 + dt = 3 / 36525; + r1 = XL0_calc(0, 2, t - dt, 10); + r2 = XL0_calc(0, 2, t, 10); + r3 = XL0_calc(0, 2, t + dt, 10); + t += (r1 - r3) / (r1 + r3 - 2 * r2)*dt / 2; //误差几个小时 + dt = 0.2 / 36525; + r1 = XL0_calc(0, 2, t - dt, 80); + r2 = XL0_calc(0, 2, t, 80); + r3 = XL0_calc(0, 2, t + dt, 80); + t += (r1 - r3) / (r1 + r3 - 2 * r2)*dt / 2; //误差几分钟 + //精算 + dt = 0.01 / 36525; + r1 = XL0_calc(0, 2, t - dt, -1); + r2 = XL0_calc(0, 2, t, -1); + r3 = XL0_calc(0, 2, t + dt, -1); + t += (r1 - r3) / (r1 + r3 - 2 * r2)*dt / 2; //误差小于秒 + r2 += (r1 - r3) / (r1 + r3 - 2 * r2)*(r3 - r1) / 8; + Vector2 re(t, r2); + return re; + } +}; + diff --git a/src/eph.h b/src/eph.h new file mode 100644 index 0000000..392827a --- /dev/null +++ b/src/eph.h @@ -0,0 +1,172 @@ +#pragma once +#include +#include + +struct Vector3 +{ + Vector3(long double x, long double y, long double z) : + x(x), y(y), z(z) + { + + }; + + Vector3(const Vector3& v) : + x(v.x), y(v.y), z(v.z) + { + + }; + + + + Vector3() {}; + long double x, y, z; + + long double& operator [](const uint64_t index)////重载[]操作符，作为左值 + { + switch (index) + { + case 0: return x; + case 1: return y; + case 2: return z; + default: return x; + } + + }; + const long double& operator [](const uint64_t index) const////重载[]操作符，作为右值 + { + switch (index) + { + case 0: return x; + case 1: return y; + case 2: return z; + default: return x; + } + }; +}; + +struct Vector2 +{ + Vector2(long double x, long double y) : + x(x), y(y) + { + + }; + Vector2() {}; + long double x, y; + + long double& operator [](const uint64_t index)////重载[]操作符，作为左值 + { + switch (index) + { + case 0: return x; + case 1: return y; + default: return x; + } + + }; + const long double& operator [](const uint64_t index) const////重载[]操作符，作为右值 + { + switch (index) + { + case 0: return x; + case 1: return y; + default: return x; + } + }; +}; + +//=================================数学工具========================================= + +//对超过0-2PI的角度转为0-2PI; +long double rad2mrad(long double v); +//对超过-PI到PI的角度转为-PI到PI; +long double rad2rrad(long double v); +//临界余数(a与最近的整倍数b相差的距离); +long double mod2(long double a, long double b); +//球面转直角坐标; +Vector3 llr2xyz(Vector3 JW); +//直角坐标转球; +Vector3 xyz2llr(Vector3 xyz); +//球面坐标旋转; +Vector3 llrConv(Vector3 JW, long double E); +//赤道坐标转为地平坐标; +Vector3 CD2DP(Vector3 z, long double L, long double fa, long double gst); +//求角度差; +long double j1_j2(long double J1, long double W1, long double J2, long double W2); +//日心球面转地心球面,Z星体球面坐标,A地球球面坐标; +//本含数是通用的球面坐标中心平移函数,行星计算中将反复使用; +Vector3 h2g(Vector3 z, Vector3 a); +//视差角(不是视差); +long double shiChaJ(long double gst, long double L, long double fa, long double J, long double W); + +//物件XL : 日月黄道平分点坐标、视坐标、速度、已知经度反求时间等方面的计算 +namespace XL +{ + //===================== + //星历函数(日月球面坐标计算) + + long double E_Lon(long double t, int n); //地球经度计算,返回Date分点黄经,传入世纪数、取项数 + long double M_Lon(long double t, int n); //月球经度计算,返回Date分点黄经,传入世纪数,n是项数比例 + //地球速度,t是世纪数,误差小于万分3 //========================= + long double E_v(long double t); + + + //月球速度计算,传入世经数 + long double M_v(long double t); + + //========================= + //月日视黄经的差值 + long double MS_aLon(long double t, long double Mn, long double Sn); + + //太阳视黄经 + long double S_aLon(long double t, long double n); + + //========================= + //已知地球真黄经求时间 + long double E_Lon_t(long double W); + + //已知真月球黄经求时间 + long double M_Lon_t(long double W); + + //已知月日视黄经差求时间 + long double MS_aLon_t(long double W); + + //已知太阳视黄经反求时间 + long double S_aLon_t(long double W); + + //已知月日视黄经差求时间,高速低精度,误差不超过600秒(只验算了几千年) + long double MS_aLon_t2(long double W); + //已知太阳视黄经反求时间,高速低精度,最大误差不超过600秒 + long double S_aLon_t2(long double W); + + long double moonIll(long double t); + + //转入地平纬度及地月质心距离,返回站心视半径(角秒) + long double moonRad(long double r, long double h); + + //求月亮近点时间和距离,t为儒略世纪数力学时 + Vector2 moonMinR(long double t, long double min); + + Vector3 moonNode(long double t, long double asc); + + //地球近远点 + Vector2 earthMinR(long double t, long double min); +}; + + +//=================================deltat T计算===================================== +long double dt_T(long double t); + + +//精气 +inline long double qi_accurate(long double W) +{ + long double t = XL::S_aLon_t(W) * 36525; + return t - dt_T(t) + (long double)8.0 / (long double)24.0; +} + +inline long double so_accurate(long double W) +{ + long double t = XL::MS_aLon_t(W) * 36525; + return t - dt_T(t) + (long double)8.0 / (long double)24.0; +} //精朔 diff --git a/src/sxtwl.cpp b/src/sxtwl.cpp new file mode 100644 index 0000000..3c8ed39 --- /dev/null +++ b/src/sxtwl.cpp @@ -0,0 +1,746 @@ +#include "sxtwl.h" +#include "const.h" +#include "JD.h" +#include "eph.h" +#include "SSQ.h" +#include + +//获取干支索引 +short getGanZhiIndex(GZ value) +{ + short index = 0; + for (int i = 0; i < 6; ++i) + { + if ((value.tg + i * 10) % 12 == value.dz) + { + index = value.tg + i * 10; + break; + } + } + return index; +} + +namespace sxtwl +{ + + Day* fromSolar(int year, uint8_t month, int day) + { + return Day::fromSolar(year, month, day); + } + + Day* fromLunar(int year, uint8_t month, int day, bool isRun) + { + return Day::fromLunar(year, month, day, isRun); + } + + //通过四柱获取年月日 + std::vector siZhu2Year(GZ yearGz, GZ yueGz, GZ riGz, GZ shiGz, int fromYear, int toYear) + { + auto fromDiff = fromYear - 1984; + + ///月 + /* + 甲己之年丙作首，乙庚之岁戊为头。 + 丙辛岁首寻庚起，丁壬壬位顺行流。 + 若言戊癸何方求，甲寅之上好追求*/ + + int startYueTg = 0, startYueDz = 0; + if (yearGz.tg == 0 || yearGz.tg == 5) + { + startYueTg = 2; + startYueDz = 2; + } + + if (yearGz.tg == 1 || yearGz.tg == 6) + { + startYueTg = 4; + startYueDz = 2; + } + + if (yearGz.tg == 2 || yearGz.tg == 7) + { + startYueTg = 6; + startYueDz = 2; + } + + if (yearGz.tg == 3 || yearGz.tg == 8) + { + startYueTg = 8; + startYueDz = 2; + } + + if (yearGz.tg == 4 || yearGz.tg == 9) + { + startYueTg = 0; + startYueDz = 2; + } + + auto mayBeDzMoth = yueGz.dz - startYueDz; + if (mayBeDzMoth < 0) + { + mayBeDzMoth = mayBeDzMoth + 12; + } + + auto mayBeTGMoth = yueGz.tg - startYueTg; + if (mayBeTGMoth < 0) + { + mayBeTGMoth = mayBeTGMoth + 10; + } + + std::vector ret; + //说明没有合适的 + if (!(mayBeTGMoth == mayBeDzMoth || mayBeTGMoth + 10 == mayBeDzMoth)) + { + return ret; + } + + ///时 + // 甲己日起甲子时 + // 乙庚日起丙子时 + // 丙辛日起戊子时 + // 丁壬日起庚子时 + // 戊葵日起壬子时 + + uint8_t startHourtg = 0; + if (riGz.tg == 0 || riGz.tg == 5) + { + startHourtg = 0; + } + if (riGz.tg == 1 || riGz.tg == 6) + { + startHourtg = 2; + } + if (riGz.tg == 2 || riGz.tg == 7) + { + startHourtg = 4; + } + + if (riGz.tg == 3 || riGz.tg == 8) + { + startHourtg = 6; + } + + if (riGz.tg == 4 || riGz.tg == 9) + { + startHourtg = 8; + } + + auto mayBeTGHour = shiGz.tg - startHourtg; + if (mayBeTGHour < 0) + { + mayBeTGHour = mayBeTGHour + 10; + } + + //说明没有合适的 + if (!(mayBeTGHour == shiGz.dz || mayBeTGHour + 10 == shiGz.dz || (shiGz.dz == 12 && mayBeTGHour + 10 == 12))) //晚子时 + { + return ret; + } + + ///年 + GZ fromYearGz; + if (fromDiff < 0) + { + fromYearGz.tg = fromDiff * -1 % 10; + if (fromYearGz.tg > 0) + { + fromYearGz.tg = 10 - fromYearGz.tg; + } + fromYearGz.dz = fromDiff * -1 % 12; + + if (fromYearGz.dz > 0) + { + fromYearGz.dz = 12 - fromYearGz.dz; + } + } + else + { + fromYearGz.tg = fromDiff % 10; + fromYearGz.dz = fromDiff % 12; + } + + //获取起始年天干支所在的位置 + auto fromGzPos = getGanZhiIndex(fromYearGz); + //所查询的年需要的天干地支位置 + auto needGzPos = getGanZhiIndex(yearGz); + + int startMatchBeYear = 60; + if (needGzPos >= fromGzPos) + { + startMatchBeYear = needGzPos - fromGzPos + fromYear; + } + else + { + startMatchBeYear = needGzPos + (60 - fromGzPos) + fromYear; + } + + std::vector matchYears; + + int loop = 0; + while (startMatchBeYear + loop * 60 <= toYear) + { + matchYears.push_back(startMatchBeYear + loop * 60); + loop += 1; + } + + //理论是是第几个小时 (晚子时算成13) + int hour = (shiGz.dz % 13) * 2 - 1; + if (hour < 0) + hour = 0; + + //获取这个月应当需要落下的节气 + int jiqiIndex = 3 + (mayBeDzMoth * 2); + bool needAddOne = false; //需要算到下一年 + if (jiqiIndex > 24) + { + jiqiIndex = jiqiIndex - 24; + needAddOne = true; + } + + //遍历符条件的年 + for (auto it = matchYears.begin(); it != matchYears.end(); ++it) + { + int year = *it; + if (needAddOne) + { + year = year + 1; + } + + //计算1月1号的信息 + Time t; + t.h = 12, t.m = 0, t.s = 0.1; + t.Y = year; + t.M = 9; + t.D = 1; + + //公历月首的儒略日,中午; + int Bd0 = int2(JD::toJD(t)) - J2000; + + GZ startGz; + GZ endGz; + long double startJD = 0; + long double endJD = 0; + Time startT; + Time endT; + + //纪月处理,1998年12月7(大雪)开始连续进行节气计数,0为甲子 + for (int i = 1; i >= 0; --i) + { + int index = jiqiIndex + 2 * i; + //定节气范围 + if (i == 1 && jiqiIndex == 23) + { + if (!SSQPtr->ZQ.size() || Bd0 + 360 < SSQPtr->ZQ[0] || Bd0 + 360 >= SSQPtr->ZQ[24]) + { + SSQPtr->calcY(Bd0 + 360); + } + index = 1; + } + else + { + if (!SSQPtr->ZQ.size() || Bd0 < SSQPtr->ZQ[0] || Bd0 >= SSQPtr->ZQ[24]) + { + SSQPtr->calcY(Bd0); + } + } + + int mk = int2((SSQPtr->ZQ[index] - SSQPtr->ZQ[0]) / 30.43685); + //相对大雪的月数计算,mk的取值范围0-12 + if (mk < 12 && SSQPtr->ZQ[index] >= SSQPtr->ZQ[2 * mk + 1]) + { + mk++; + } + + int D = mk + int2((SSQPtr->ZQ[12] + 390) / 365.2422) * 12 + 900000; //相对于1998年12月7(大雪)的月数,900000为正数基数 + + ////纪日,2000年1月7日起算 + D = SSQPtr->ZQ[index] - 6 + 9000000; + + if (i == 0) + { + startJD = SSQPtr->ZQ[index]; + startT = JD::JD2DD(startJD + J2000); + startGz.tg = D % 10; + startGz.dz = D % 12; + + //获取准确节气的时间 + auto jd2 = SSQPtr->ZQ[0] + dt_T(SSQPtr->ZQ[0]) - (8.0 / 24.0); + auto w = XL::S_aLon(jd2 / 36525, 3); + w = int2((w - 0.13) / pi2 * 24) * pi2 / 24; + + for (int i = 0; i <= index; ++i) + { + long double d = 0; + while (true) + { + d = qi_accurate(w); + D = int2(d + 0.5); + auto xn = int2(w / pi2 * 24 + 24000006.01) % 24; + w += pi2 / 24; + if (D < SSQPtr->ZQ[i]) + continue; + break; + } + + if (index != i) + continue; + Time t1 = JD::JD2DD(d); + startT.h = t1.h; + startT.m = t1.m; + startT.s = t1.s; + break; + } + } + else + { + endJD = SSQPtr->ZQ[index]; + endT = JD::JD2DD(endJD + J2000); + endGz.tg = D % 10; + endGz.dz = D % 12; + + //获取准确节气的时间 + auto jd2 = SSQPtr->ZQ[0] + dt_T(SSQPtr->ZQ[0]) - (8.0 / 24.0); + auto w = XL::S_aLon(jd2 / 36525, 3); + w = int2((w - 0.13) / pi2 * 24) * pi2 / 24; + + for (int i = 0; i <= index; ++i) + { + long double d = 0; + while (true) + { + d = qi_accurate(w); + D = int2(d + 0.5); + auto xn = int2(w / pi2 * 24 + 24000006.01) % 24; + w += pi2 / 24; + if (D < SSQPtr->ZQ[i]) + continue; + break; + } + + if (index != i) + continue; + Time t1 = JD::JD2DD(d); + endT.h = t1.h; + endT.m = t1.m; + endT.s = t1.s; + break; + } + } + } + + int diff = getGanZhiIndex(riGz) - getGanZhiIndex(startGz); + long double startDay = 0; + if (diff < 0) + { + + diff = 60 + diff; + } + + startDay = startJD + diff; + + /*Time st = JD::JD2DD(startJD + J2000); + Time et = JD::JD2DD(endJD + J2000);*/ + + do + { + + Time mayBet = JD::JD2DD(startDay + J2000); + mayBet.h = hour; + mayBet.m = 0; + mayBet.s = 0; + + if (diff == 0) + { + bool isMatch = false; + + //此时算上一个月的 + if (hour > t.h) + { + isMatch = true; + } + else + { + if (hour != 0 || hour != 23) + { + mayBet.h = hour; + mayBet.m = 59; + mayBet.s = 0; + } + else + { + mayBet.h = hour; + mayBet.m = 59; + mayBet.s = 0; + } + + if (mayBet.h >= t.h && t.m < 59) + { + isMatch = true; + } + } + + if (!isMatch) + { + break; + } + } + + else if (diff == int2(endJD - startJD)) + { + bool isMatch = false; + + //此时算上一个月的 + if (hour < endT.h) + { + isMatch = true; + } + else + { + if (mayBet.h == endT.h && endT.m > 0) + { + isMatch = true; + } + } + + if (!isMatch) + { + break; + } + } + + if (diff > int2(endJD - startJD)) + { + break; + } + + ret.push_back(JD::toJD(mayBet)); + } while (false); + } + return ret; + } + + GZ getShiGz(uint8_t dayTg, uint8_t hour, bool isZaoWanZiShi) + { + GZ ret; + // 甲己日起甲子时 + // 乙庚日起丙子时 + // 丙辛日起戊子时 + // 丁壬日起庚子时 + // 戊葵日起壬子时 + + uint8_t step = (hour + 1) / 2; + if (step >= 12) + { + ret.dz = 0; + } + + // 如果非早晚子时，以及时间为23点，则算第二日的起始子时 + if (!isZaoWanZiShi && hour == 23) + { + step = 0; + } + + switch (dayTg) + { + case 0: //甲 + case 5: //己 + ret.tg = 0 + step; + break; + case 1: //乙 + case 6: //庚 + ret.tg = 2 + step; + break; + + case 2: //丙 + case 7: //辛 + ret.tg = 4 + step; + break; + case 3: //丁 + case 8: //壬 + ret.tg = 6 + step; + break; + case 4: //戊 + case 9: //葵 + ret.tg = 8 + step; + break; + default: + break; + } + ret.tg = ret.tg % 10; + ret.dz = step % 12; + return ret; + } + + uint8_t getRunMonth(int By) + { + //计算1月1号的信息 + Time t; + t.h = 12, t.m = 0, t.s = 0.1; + t.Y = By; + t.M = 1; + t.D = 1; + + //公历月首的儒略日,中午; + int Bd0 = int2(JD::toJD(t)) - J2000; + + if (!SSQPtr->ZQ.size() || Bd0 < SSQPtr->ZQ[0] || Bd0 >= SSQPtr->ZQ[24]) + { + SSQPtr->calcY(Bd0); + } + + //{ "十一", "十二", "正", "二", "三", "四", "五", "六", "七", "八", "九", "十" } + // static int mkIndex[] = { 11, 12, 1,2,3,4,5,6,7, 8,9,10 }; + static int yueIndex[] = { 11, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + + //需要排除11月和12月的，这个可能属于上一个月的信息 + int leap = SSQPtr->leap - 1; + if (leap > 1) + { + return yueIndex[leap]; + } + + //看看11月和12月是否有闰 + t.Y = By + 1; + Bd0 = int2(JD::toJD(t)) - J2000; + if (!SSQPtr->ZQ.size() || Bd0 < SSQPtr->ZQ[0] || Bd0 >= SSQPtr->ZQ[24]) + { + SSQPtr->calcY(Bd0); + } + leap = SSQPtr->leap - 1; + if (leap > 1 || leap < 0) + { + return 0; + } + return yueIndex[leap]; + } + + uint8_t getLunarMonthNum(int year, uint8_t month, bool isRun) + { + if (month > 10) + { + year = year + 1; + } + + //计算1月1号的信息 + Time t; + t.h = 12, t.m = 0, t.s = 0.1; + t.Y = year; + t.M = 1; + t.D = 1; + + //公历月首的儒略日,中午; + int Bd0 = int2(JD::toJD(t)) - J2000; + + if (!SSQPtr->ZQ.size() || Bd0 < SSQPtr->ZQ[0] || Bd0 >= SSQPtr->ZQ[24]) + { + SSQPtr->calcY(Bd0); + } + + //{ "十一", "十二", "正", "二", "三", "四", "五", "六", "七", "八", "九", "十" } + // static int mkIndex[] = { 11, 12, 1,2,3,4,5,6,7, 8,9,10 }; + static int yueIndex[] = { 11, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + + int yue = 0; + + for (int i = 0; i < sizeof(yueIndex); ++i) + { + if (*(yueIndex + i) == month) + { + yue = i; + break; + } + } + + int mk = 0; + int leap = SSQPtr->leap - 1; + + if (isRun && ((leap < 0) || (leap >= 0 && month != yueIndex[leap]))) + { + //throw CalendarException(ErrorCode_NotRun); + } + + for (auto it = SSQPtr->ym.begin(); it != SSQPtr->ym.end(); ++it) + { + + if (leap < 0) + { + if (*it == yue) + { + break; + } + } + else + { + if (yue < leap && *it == yue) + { + break; + } + + if (yue == leap && *it == yue && isRun) + { + ++mk; + break; + } + + if (yue == leap && *it == yue && !isRun) + { + break; + } + + if (yue > leap && *it == yue) + { + break; + } + } + ++mk; + } + + //阴历首月的儒略日 + int bdi = SSQPtr->HS[mk]; + + return SSQPtr->HS[mk + 1] - SSQPtr->HS[mk]; + } + + //儒略日数转公历 + Time JD2DD(double jd) + { + return JD::JD2DD(jd); + } + + //公历转儒略日 + double toJD(Time& time) + { + return JD::toJD(time); + } + + std::vector getJieQiByYear(int year) + { + std::vector ret; + + Time t(year, 1, 1, 12, 0, 0); + auto jd = sxtwl::toJD(t) - J2000; + /*Day* day = Day::fromSolar(year, 1, 1); + + auto jd = day->getJD(); + delete day;*/ + + + if (!SSQPtr->ZQ.size() || jd < SSQPtr->ZQ[0] || jd >= SSQPtr->ZQ[24]) + { + SSQPtr->calcY(jd); + } + + long double d, xn, jd2 = jd + dt_T(jd) - (long double)8 / (long double)24; + long double w = XL::S_aLon(jd2 / 36525, 3); + w = int2((w - 0.13) / pi2 * 24) * pi2 / 24; + int D = 0; + + bool startLiChun = false; + for (auto it = SSQPtr->ZQ.begin(); it != SSQPtr->ZQ.end(); ++it) + { + while (true) + { + d = qi_accurate(w); + D = int2(d + 0.5); + xn = int2(w / pi2 * 24 + 24000006.01) % 24; + w += pi2 / 24; + // 这里可能会有误差，实际的不等相等 + if ( abs(int2(*it) - D) <= 5 ) + { + break; + } + if (D < *it) continue; + break; + + } + + if (xn == 3 && !startLiChun) + { + startLiChun = true; + } + + if (!startLiChun) + { + continue; + } + + Time t1 = JD::JD2DD(d); + Time t2 = JD::JD2DD(D + J2000); + + t2.h = t1.h; + t2.m = t1.m; + t2.s = t1.s; + + + auto jd = JD::toJD(t2); + + + JieQiInfo tmp; + tmp.jd = jd; + tmp.jqIndex = xn; + + ret.push_back(tmp); + + } + + t = Time(year + 1, 1, 1, 12, 0, 0); + jd = sxtwl::toJD(t) - J2000; + /*jd = SSQPtr->ZQ[24] + 1;*/ + + SSQPtr->calcY(jd); + + jd2 = jd + dt_T(jd) - (long double)8 / (long double)24;; + w = XL::S_aLon(jd2 / 36525, 3); + w = int2((w - 0.13) / pi2 * 24) * pi2 / 24; + + + for (auto it = SSQPtr->ZQ.begin(); it != SSQPtr->ZQ.end(); ++it) + { + while (true) + { + d = qi_accurate(w); + D = int2(d + 0.5); + xn = int2(w / pi2 * 24 + 24000006.01) % 24; + w += pi2 / 24; + // 这里可能会有误差，实际的不等相等 + if (abs(int2(*it) - D) <= 5) + { + break; + } + if (D < *it) continue; + break; + + } + + + if (xn == ret[ret.size() - 1].jqIndex) + { + continue; + } + + + Time t1 = JD::JD2DD(d); + Time t2 = JD::JD2DD(*it + J2000); + + t2.h = t1.h; + t2.m = t1.m; + t2.s = t1.s; + + + auto jd = JD::toJD(t2); + + JieQiInfo tmp; + tmp.jd = jd; + tmp.jqIndex = xn; + + ret.push_back(tmp); + + + if (ret.size() >= 25) { + break; + } + } + return ret; + } +} + diff --git a/src/sxtwl.h b/src/sxtwl.h new file mode 100644 index 0000000..d5a192c --- /dev/null +++ b/src/sxtwl.h @@ -0,0 +1,33 @@ +#pragma once +#include + +#include "SSQ.h" +#include +#include "day.h" + +namespace sxtwl +{ + struct JieQiInfo + { + double jd; //节气的儒略日 + uint8_t jqIndex; //节气索引 + }; + + + Day *fromSolar(int year, uint8_t month, int day); + Day *fromLunar(int year, uint8_t month, int day, bool isRun = false); + //通过四柱获取年月日, 返回的是儒略日列表 + std::vector siZhu2Year(GZ year, GZ yue, GZ ri, GZ shi, int fromYear, int toYear); + //获取时辰上的那个天干 + GZ getShiGz(uint8_t dayTg, uint8_t hour, bool isZaoWanZiShi = true); + //获取一年中的润月(不存，则返回0) + uint8_t getRunMonth(int By); + //获取一月中的阴日数量 + uint8_t getLunarMonthNum(int By, uint8_t month, bool isRun = false); + //儒略日数转公历 + Time JD2DD(double jd); + //公历转儒略日 + double toJD(Time& time); + //获取某年的节气（立春到立春） + std::vector getJieQiByYear(int year); +}; diff --git a/swig/sxtwl.i b/swig/sxtwl.i new file mode 100644 index 0000000..120d61f --- /dev/null +++ b/swig/sxtwl.i @@ -0,0 +1,121 @@ +%module sxtwl + +%{ +#include "const.h" +#include "sxtwl.h" +%} + +%include "stdint.i" +%include "std_vector.i" +%include "std_string.i" + +namespace std{ + %template(JDList) vector; + %template(JQList) vector; +} + +%constant int J2000=2451545; + +// %catches(LunarException) Lunar::getLunarMonthNum(int By, uint8_t month, bool isRun = false); +// %catches(LunarException) Lunar::getDayBySolar(int year, uint8_t month, uint8_t day); +// %catches(LunarException) Lunar::getDayByLunar(int year, uint8_t month, uint8_t day, bool isRun = false); + + +struct Time +{ + Time(); + Time(int year, int month, int day, double hour, double min, double sec); + int Y, M, D; + double h, m, s; + +//========================================================= +//time的操作方法 + int getYear(); + void setYear(int year); + void setMonth(int month) ; + int getMonth() ; + int getDay() ; + void setDay(int day); + double getHour(); + void setHour(double hour); + double getMin() ; + void setMour(double min); + double getSec(); + void setSec(double sec); +//========================================================= +}; + + +struct GZ +{ + GZ(){}; + GZ(uint8_t tg, uint8_t dz) : tg(tg), dz(dz) + { + } + uint8_t tg; + uint8_t dz; +}; + +class Day +{ +public: + static Day *fromSolar(int _year, uint8_t _month, int _day); + static Day *fromLunar(int year, uint8_t month, int day, bool isRun = false); +private: + Day(int d0); +public: + Day *after(int day); + Day *before(int day); + // 获取阴历日期 + int getLunarDay(); + //获取阴历月 + uint8_t getLunarMonth(); + //获取阴历年 chineseNewYearBoundary是否以春节为界 + int getLunarYear(bool chineseNewYearBoundary = true); + //获取阴历年干支 chineseNewYearBoundary是否以春节为界 + GZ getYearGZ(bool chineseNewYearBoundary = false); + GZ getMonthGZ(); + GZ getDayGZ(); + GZ getHourGZ(uint8_t hour, bool isZaoWanZiShi = true); + bool isLunarLeap(); + + int getSolarYear(); + uint8_t getSolarMonth(); + int getSolarDay() ; + uint8_t getWeek(); + // 处于该月的第几周 + uint8_t getWeekIndex(); + //是否有节气 + bool hasJieQi(); + // 获取节气 + uint8_t getJieQi() ; + double getJieQiJD(); + // 获取星座 + uint8_t getConstellation(); +}; + +namespace sxtwl +{ + struct JieQiInfo + { + double jd; //节气的儒略日 + uint8_t jqIndex; //节气索引 + }; + + Day *fromSolar(int year, uint8_t month, int day); + Day *fromLunar(int year, uint8_t month, int day, bool isRun = false); + //通过四柱获取年月日 + std::vector siZhu2Year(GZ year, GZ yue, GZ ri, GZ shi, int fromYear, int toYear); + //获取时辰上的那个天干 + GZ getShiGz(uint8_t dayTg, uint8_t hour, bool isZaoWanZiShi = true); + //获取一年中的润月(不存，则返回0) + uint8_t getRunMonth(int By); + //获取一月中的阴日数量 + uint8_t getLunarMonthNum(int By, uint8_t month, bool isRun = false); + //儒略日数转公历 + Time JD2DD(double jd); + //公历转儒略日 + double toJD(Time& time); + + std::vector getJieQiByYear(int year); +}; \ No newline at end of file