senset/vnpy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[Mod] updated oes binding

Browse Source
This commit is contained in:
nanoric 2019-03-19 05:24:31 -04:00
parent 8e5ea24a36
commit 1b2a567e1e
17 changed files with 1630 additions and 698 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
vnpy/api/oes/include/autocxxpy/autocxxpy.hpp
View File

@ -1,6 +1,7 @@
#pragma once
#include "brigand.hpp"
#include "dispatcher.hpp"
#include "property_helper.hpp"
#include "calling_wrapper.hpp"

12
vnpy/api/oes/include/autocxxpy/base/type.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
namespace autocxxpy
{
template <class element, size_t size>
using literal_array = element[size];
// specialization for char[]
template <size_t size>
using string_literal = literal_array<char, size>;
}

6
vnpy/api/oes/include/autocxxpy/brigand.hpp Normal file
View File

@ -0,0 +1,6 @@
#pragma once
#ifndef BRIGAND_NO_BOOST_SUPPORT
#define BRIGAND_NO_BOOST_SUPPORT
#endif
#include <brigand/brigand.hpp>

52
vnpy/api/oes/include/autocxxpy/callback_wrapper.hpp
View File

@ -3,7 +3,7 @@
#include <tuple>
#include <type_traits>
#include <brigand/brigand.hpp>
#include "brigand.hpp"
#include "utils/functional.hpp"
#include "dispatcher.hpp"
@ -71,30 +71,46 @@ namespace autocxxpy
struct pybind11_static_caster {
static pybind11::detail::overload_caster_t<ret_type> caster;
};
template <class ret_type>
AUTOCXXPY_SELECT_ANY pybind11::detail::overload_caster_t<ret_type> pybind11_static_caster<ret_type>::caster;
#endif
namespace arg_helper
{
// # todo: char8, char16, char32, wchar_t, etc...
// # todo: shall i copy only const type, treating non-const type as output pointer?
inline std::string save(const char *val)
{ // match const char *
return val;
}
inline std::string save(char *val)
{ // match char *
return val;
}
template <class T>
inline T &deref(T *val)
inline T &save(T *val)
{ // match pointer
return *val;
}
template <class T>
inline T &deref(const T *val)
inline T &save(const T *val)
{ // match const pointer
return const_cast<T&>(*val);
}
template <class T>
inline T &deref(const T &val)
inline T &save(const T &val)
{ // match everything else : just use original type
return const_cast<T&>(val);
}
template <class to_type>
struct resolver
struct loader
{ // match default(everyting besides pointer)
template <class src_type>
inline to_type operator ()(src_type &val)
@ -103,8 +119,18 @@ namespace autocxxpy
}
};
template <>
struct loader<char *>
{ // match char *
using to_type = char *;
inline to_type operator ()(const std::string &val)
{
return const_cast<char *>(val.data());
}
};
template <class to_type>
struct resolver<to_type *>
struct loader<to_type *>
{ // match pointer
template <class src_type>
inline to_type *operator ()(src_type &val)
@ -112,11 +138,11 @@ namespace autocxxpy
return const_cast<to_type *>(&val);
}
template <class src_type>
inline to_type *operator ()(src_type *val)
{ // pointer to pointer
return val;
}
//template <class src_type>
//inline to_type *operator ()(src_type *val)
//{ // pointer to pointer
// return val;
//}
};
};
@ -175,7 +201,7 @@ namespace autocxxpy
{
// wrap for ctp like function calls:
// all the pointer might be unavailable after this call, so copy its value into a tuple
auto arg_tuple = std::make_tuple(arg_helper::deref(args) ...);
auto arg_tuple = std::make_tuple(arg_helper::save(args) ...);
auto task = [instance, py_func_name, arg_tuple = std::move(arg_tuple)]()
{
// resolve all value:
@ -183,7 +209,7 @@ namespace autocxxpy
// if it was originally a value, just keep a reference to that value.
sync<arg_types ...>(
instance, py_func_name,
arg_helper::resolver<brigand::at<brigand::list<arg_types ...>, brigand::integral_constant<int, idx> > >{}
arg_helper::loader<brigand::at<brigand::list<arg_types ...>, brigand::integral_constant<int, idx> > >{}
(std::get<idx>(arg_tuple)) ...
);
};

6
vnpy/api/oes/include/autocxxpy/calling_wrapper.hpp
View File

@ -2,10 +2,11 @@
#include "utils/functional.hpp"
#include "dispatcher.hpp"
#include <brigand/brigand.hpp>
#include "brigand.hpp"
#include "wrappers/cfunction.h"
#include "wrappers/no_gil.hpp"
#include "wrappers/string_array.h"
namespace autocxxpy
{
@ -39,7 +40,8 @@ namespace autocxxpy
};
using trans_list = brigand::list <
transform_holder<c_function_pointer_to_std_function_transform>
transform_holder<c_function_pointer_to_std_function_transform>,
transform_holder<string_array_transform>
//, transform_holder<no_gil_transform> // no gil transform should be the last one
>;

7
vnpy/api/oes/include/autocxxpy/config/config.hpp
View File

@ -10,3 +10,10 @@
#ifndef AUTOCXXPY_UNUSED
#define AUTOCXXPY_UNUSED(x) (void)(x)
#endif
#ifdef _MSC_VER
#define AUTOCXXPY_SELECT_ANY __declspec(selectany)
#else
#define AUTOCXXPY_SELECT_ANY __attribute__ ((selectany))
#endif

77
vnpy/api/oes/include/autocxxpy/property_helper.hpp
View File

@ -1,15 +1,41 @@
#pragma once
#include <vector>
#include <string>
#include <string_view>
#include <functional>
#include <mutex>
#include <condition_variable>
#include "config/config.hpp"
#include "base/type.h"
namespace autocxxpy
{
template <class class_type, class value_type>
template <class tag, size_t size>
struct get_string
{
auto &operator()(string_literal<size> &val)
{
return val;
}
};
template <class tag, size_t size>
struct set_string
{
void operator()(string_literal<size> &val, const char *str)
{
#ifdef _MSC_VER
strcpy_s(val, str);
#else
strcpy(val, str);
#endif
}
};
template <class tag, class class_type, class value_type>
inline constexpr auto default_getter_wrap(value_type class_type::*member)
{ // match normal case
return [member](const class_type &instance)->const value_type & {
@ -17,7 +43,7 @@ namespace autocxxpy
};
}
template <class class_type, class value_type>
template <class tag, class class_type, class value_type>
inline constexpr auto default_setter_wrap(value_type class_type::*member)
{ // match normal case
return [member](class_type &instance, const value_type &value) {
@ -26,26 +52,28 @@ namespace autocxxpy
}
// specialization for const setter
template <class class_type, class value_type>
template <class tag, class class_type, class value_type>
inline constexpr auto default_setter_wrap(const value_type class_type::*member)
{ // match const
return nullptr;
}
// specialization for any []
template <class element_t, size_t size>
using array_literal = element_t[size];
template <class class_type, class element_t, size_t size>
inline constexpr auto default_getter_wrap(array_literal<element_t, size> class_type::*member)
template <class tag, class class_type, class element_t, size_t size>
inline constexpr auto default_getter_wrap(literal_array<element_t, size> class_type::*member)
{ // match get any []
return [member](const class_type &instance) {
return std::vector<element_t>(instance.*member, instance.*member + size);
auto es = std::vector<element_t *>(size);
for (size_t i = 0; i < size ; i++)
{
es[i] = instance.*member + i;
}
return std::move(es);
};
}
template <class class_type, class element_t, size_t size>
inline constexpr auto default_setter_wrap(array_literal<element_t, size> class_type::*member)
template <class tag, class class_type, class element_t, size_t size>
inline constexpr auto default_setter_wrap(literal_array<element_t, size> class_type::*member)
{ // match set any []
return [member](class_type &instance, const std::vector<element_t> &value) {
if (value.size() >= size)
@ -61,8 +89,8 @@ namespace autocxxpy
}
// specialization for any *[]
template <class class_type, class element_t, size_t size>
inline constexpr auto default_getter_wrap(array_literal<element_t *, size> class_type::*member)
template <class tag, class class_type, class element_t, size_t size>
inline constexpr auto default_getter_wrap(literal_array<element_t *, size> class_type::*member)
{ // match get (any *)[]
return [member](const class_type &instance) {
std::vector<element_t *> arr;
@ -75,42 +103,35 @@ namespace autocxxpy
}
// specialization for char[]
template <size_t size>
using string_literal = array_literal<char, size>;
template <class class_type, size_t size>
template <class tag, class class_type, size_t size>
inline constexpr auto default_getter_wrap(string_literal<size> class_type::*member)
{ // match get char []
return [member](const class_type &instance) {
return instance.*member;
return get_string<tag, size>{}(instance.*member);
};
}
template <class class_type, size_t size>
template <class tag, class class_type, size_t size>
inline constexpr auto default_setter_wrap(string_literal<size> class_type::*member)
{ // match set char []
return [member](class_type &instance, const std::string_view &value) {
#ifdef _MSC_VER
strcpy_s(instance.*member, value.data());
#else
strcpy(instance.*member, value.data());
#endif
return set_string<tag, size>{}(instance.*member, value.data());
};
}
template <class tag, class MemberConstant>
struct getter_wrap
{
using value_type = decltype(default_getter_wrap(MemberConstant::value));
static constexpr value_type value = default_getter_wrap(MemberConstant::value);
using value_type = decltype(default_getter_wrap<tag>(MemberConstant::value));
static constexpr value_type value = default_getter_wrap<tag>(MemberConstant::value);
};
template <class tag, class MemberConstant>
struct setter_wrap
{
using value_type = decltype(default_setter_wrap(MemberConstant::value));
static constexpr value_type value = default_setter_wrap(MemberConstant::value);
using value_type = decltype(default_setter_wrap<tag>(MemberConstant::value));
static constexpr value_type value = default_setter_wrap<tag>(MemberConstant::value);
};
}
#define AUTOCXXPY_DEF_PROPERTY(cls, name, member) \

3
vnpy/api/oes/include/autocxxpy/wrappers/cfunction.h
View File

@ -1,7 +1,8 @@
#pragma once
#include <boost/callable_traits.hpp>
#include <brigand/brigand.hpp>
#include "../brigand.hpp"
namespace autocxxpy
{

2
vnpy/api/oes/include/autocxxpy/wrappers/no_gil.hpp
View File

@ -1,7 +1,7 @@
#pragma once
#include <boost/callable_traits.hpp>
#include <brigand/brigand.hpp>
#include "../brigand.hpp"
namespace autocxxpy
{

123
vnpy/api/oes/include/autocxxpy/wrappers/string_array.h Normal file
View File

@ -0,0 +1,123 @@
#pragma once
#include "../base/type.h"
#include <boost/callable_traits.hpp>
#include "../brigand.hpp"
#ifdef AUTOCXXPY_INCLUDED_PYBIND11
#include <pybind11/stl.h>
#endif
#include <functional>
#include <iostream>
namespace autocxxpy
{
template <size_t size>
using string_array = literal_array<char *, size>;
template <size_t size>
using const_string_array = literal_array<const char *, size>;
template <class T>
struct is_string_array : std::false_type {};
template <>
struct is_string_array<char **> :std::true_type {};
template <>
struct is_string_array<const char **> :std::true_type {};
template <size_t size>
struct is_string_array<string_array<size>> :std::true_type {};
template <size_t size>
struct is_string_array<const_string_array<size>> :std::true_type {};
template <class MethodConstant, class size_type, class ... Ls, class ... Rs>
inline constexpr auto _wrap_string_array_impl(brigand::list<Ls...>, brigand::list<Rs...>)
{
return [](Ls ...ls, std::vector<std::string> &vals, Rs ... rs)
{
constexpr auto method = MethodConstant::value;
namespace ct = boost::callable_traits;
using func_t = typename ct::function_type_t<decltype(method)>;
std::vector<char *> arr;
arr.reserve(vals.size());
for (auto &s : vals)
{
arr.push_back(const_cast<char *>(s.data()));
}
return std::function<func_t>(method)(
ls...,
&arr[0],
(size_type)vals.size(),
rs...
);
};
}
template <class MethodConstant, class args_t, class args_from_cfp>
inline constexpr auto _wrap_string_array_nocheck()
{
using namespace brigand;
namespace ct = boost::callable_traits;
using target_t = front<args_from_cfp>;
using size_type = front<pop_front<args_from_cfp>>;
if constexpr (std::is_integral_v<size_type>)
{
constexpr int target_idx = index_of<args_t, target_t>::value;
using ls = front<split_at<args_t, integral_constant<int, target_idx>>>;
using rs = pop_front<args_from_cfp, integral_constant<int, 2>>;
return _wrap_string_array_impl <MethodConstant, size_type>(ls{}, rs{});
}
else
{
constexpr auto method = MethodConstant::value;
return method;
}
}
template <class MethodConstant>
inline constexpr auto wrap_string_array()
{
using namespace brigand;
namespace ct = boost::callable_traits;
constexpr auto method = MethodConstant::value;
using func_t = ct::function_type_t<decltype(method)>;
using args_t = wrap<ct::args_t<func_t>, list>;
constexpr bool has_string_array_pointer = found<args_t, is_string_array<_1>>::value;
if constexpr (has_string_array_pointer)
{
using args_from_cfp = find<args_t, is_string_array<_1>>;
constexpr int nargs_left = size<args_from_cfp>::value;
if constexpr (nargs_left >= 2)
{
return _wrap_string_array_nocheck<MethodConstant, args_t, args_from_cfp>();
}
else
{
return method;
}
}
else
{
return method;
}
}
template <class T>
struct string_array_transform
{
using type = string_array_transform;
using value_type = decltype(wrap_string_array<T>());
static constexpr value_type value = wrap_string_array<T>();
};
}

BIN
vnpy/api/oes/vnoes.pyd
View File

Binary file not shown.

672
vnpy/api/oes/vnoes.pyi
View File

File diff suppressed because it is too large Load Diff

118
vnpy/api/oes/vnoes/custom/wrapper.hpp
View File

@ -12,86 +12,14 @@
namespace autocxxpy
{
//template <>
//struct calling_wrapper<&::OesApi_WaitReportMsg>
//{
// static constexpr auto value = [](
// OesApiSessionInfoT *pRptChannel,
// int32 timeoutMs,
// F_OESAPI_ON_RPT_MSG_T pRptMsgCallback,
// void *pCallbackParams
// )
// {
// return ::OesApi_WaitReportMsg(pRptChannel, timeoutMs, pRptMsgCallback, pCallbackParams);
// };
//};
template <>
struct calling_wrapper<&::OesApi_WaitOnChannelGroup>
{
static constexpr auto value = [](
OesApiChannelGroupT *pChannelGroup,
int32 timeoutMs,
F_OESAPI_ON_RPT_MSG_T pOnMsgCallback,
void *pCallbackParams
)
{
return ::OesApi_WaitOnChannelGroup(pChannelGroup, timeoutMs, pOnMsgCallback, pCallbackParams, nullptr);
};
};
template <>
struct calling_wrapper<&::MdsApi_WaitOnTcpChannelGroup>
{
static constexpr auto value = [](
MdsApiChannelGroupT *pChannelGroup,
int32 timeoutMs,
F_MDSAPI_ONMSG_T pOnMsgCallback,
void *pCallbackParams
)
{
return ::MdsApi_WaitOnTcpChannelGroup(pChannelGroup, timeoutMs, pOnMsgCallback, pCallbackParams, nullptr);
};
};
template <>
struct calling_wrapper<&::MdsApi_WaitOnTcpChannelGroupCompressible>
{
static constexpr auto value = [](
MdsApiChannelGroupT *pChannelGroup,
int32 timeoutMs,
F_MDSAPI_ONMSG_T pOnMsgCallback,
void *pCallbackParams
)
{
return ::MdsApi_WaitOnTcpChannelGroupCompressible(pChannelGroup, timeoutMs, pOnMsgCallback, pCallbackParams, nullptr);
};
};
template <>
struct calling_wrapper<&::MdsApi_WaitOnUdpChannelGroup>
{
static constexpr auto value = [](
MdsApiChannelGroupT *pChannelGroup,
int32 timeoutMs,
F_MDSAPI_ONMSG_T pOnMsgCallback,
void *pCallbackParams
)
{
return ::MdsApi_WaitOnUdpChannelGroup(pChannelGroup, timeoutMs, pOnMsgCallback, pCallbackParams, nullptr);
};
};
template <class T>
struct ssss
{
using type = int;
};
//////////////////////////////////////////////////////////////////////////
// special output variable
//////////////////////////////////////////////////////////////////////////
// set/get of userInfo.u64
CREATE_MEMBER_DETECTOR(u64);
template <class MemberConstant>
template <class tag, class MemberConstant>
struct my_getter_helper
{
static constexpr auto get()
@ -110,7 +38,7 @@ namespace autocxxpy
}
else
{
return default_getter_wrap(member);
return default_getter_wrap<tag>(member);
}
}
};
@ -118,12 +46,12 @@ namespace autocxxpy
template <class MemberConstant>
struct getter_wrap<module_tag, MemberConstant>
{
using value_type = decltype(my_getter_helper<MemberConstant>::get());
static constexpr value_type value = my_getter_helper< MemberConstant>::get();
using value_type = decltype(my_getter_helper<module_tag, MemberConstant>::get());
static constexpr value_type value = my_getter_helper<module_tag, MemberConstant>::get();
};
template <class MemberConstant>
template <class tag, class MemberConstant>
struct my_setter_helper
{
static constexpr auto set()
@ -142,7 +70,7 @@ namespace autocxxpy
}
else
{
return default_setter_wrap(member);
return default_setter_wrap<tag>(member);
}
}
};
@ -150,28 +78,8 @@ namespace autocxxpy
template <class MemberConstant>
struct setter_wrap<module_tag, MemberConstant>
{
using value_type = decltype(my_setter_helper<MemberConstant>::set());
static constexpr value_type value = my_setter_helper< MemberConstant>::set();
using value_type = decltype(my_setter_helper<module_tag, MemberConstant>::set());
static constexpr value_type value = my_setter_helper<module_tag, MemberConstant>::set();
};
//template <>
//struct post_register_class<tag_vnoes, MdsMktDataSnapshotT>
//{
// template <class T>
// static constexpr void post_register(T &c)
// {
// c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "l2Stock", l2Stock);
// c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "l2StockIncremental", l2StockIncremental);
// c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "l2BestOrders", l2BestOrders);
// c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "l2BestOrdersIncremental", l2BestOrdersIncremental);
// c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "stock", stock);
// c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "option", option);
// c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "index", index);
// c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "l2VirtualAuctionPrice", l2VirtualAuctionPrice);
// c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "l2MarketOverview", l2MarketOverview);
// }
//};
//////////////////////////////////////////////////////////////////////////
}

331
vnpy/api/oes/vnoes/generated_files/classes_1.cpp
View File

File diff suppressed because it is too large Load Diff

305
vnpy/api/oes/vnoes/generated_files/classes_2.cpp
View File

@ -16,7 +16,8 @@
void generate_class_OesEtfComponentItemT(pybind11::module &m)
{
pybind11::class_<OesEtfComponentItemT> c(m, "OesEtfComponentItemT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesEtfComponentItemT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesEtfComponentItemT, "securityId", securityId);
c.AUTOCXXPY_DEF_PROPERTY(OesEtfComponentItemT, "mktId", mktId);
c.AUTOCXXPY_DEF_PROPERTY(OesEtfComponentItemT, "subFlag", subFlag);
@ -29,87 +30,107 @@ void generate_class_OesEtfComponentItemT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(OesEtfComponentItemT, "redemptionCashSub", redemptionCashSub);
c.AUTOCXXPY_DEF_PROPERTY(OesEtfComponentItemT, "fundId", fundId);
AUTOCXXPY_POST_REGISTER_CLASS(OesEtfComponentItemT, c);
m.attr("_OesEtfComponentItem") = c;
}
void generate_class_OesQryEtfComponentReqT(pybind11::module &m)
{
pybind11::class_<OesQryEtfComponentReqT> c(m, "OesQryEtfComponentReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesQryEtfComponentReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesQryEtfComponentReqT, "reqHead", reqHead);
c.AUTOCXXPY_DEF_PROPERTY(OesQryEtfComponentReqT, "qryFilter", qryFilter);
AUTOCXXPY_POST_REGISTER_CLASS(OesQryEtfComponentReqT, c);
m.attr("_OesQryEtfComponentReq") = c;
}
void generate_class_OesQryEtfComponentRspT(pybind11::module &m)
{
pybind11::class_<OesQryEtfComponentRspT> c(m, "OesQryEtfComponentRspT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesQryEtfComponentRspT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesQryEtfComponentRspT, "rspHead", rspHead);
c.AUTOCXXPY_DEF_PROPERTY(OesQryEtfComponentRspT, "qryItems", qryItems);
AUTOCXXPY_POST_REGISTER_CLASS(OesQryEtfComponentRspT, c);
m.attr("_OesQryEtfComponentRsp") = c;
}
void generate_class_OesQryOptionFilterT(pybind11::module &m)
{
pybind11::class_<OesQryOptionFilterT> c(m, "OesQryOptionFilterT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesQryOptionFilterT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesQryOptionFilterT, "securityId", securityId);
c.AUTOCXXPY_DEF_PROPERTY(OesQryOptionFilterT, "mktId", mktId);
c.AUTOCXXPY_DEF_PROPERTY(OesQryOptionFilterT, "__filler", __filler);
c.AUTOCXXPY_DEF_PROPERTY(OesQryOptionFilterT, "userInfo", userInfo);
AUTOCXXPY_POST_REGISTER_CLASS(OesQryOptionFilterT, c);
m.attr("_OesQryOptionFilter") = c;
}
void generate_class_OesQryOptionReqT(pybind11::module &m)
{
pybind11::class_<OesQryOptionReqT> c(m, "OesQryOptionReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesQryOptionReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesQryOptionReqT, "reqHead", reqHead);
c.AUTOCXXPY_DEF_PROPERTY(OesQryOptionReqT, "qryFilter", qryFilter);
AUTOCXXPY_POST_REGISTER_CLASS(OesQryOptionReqT, c);
m.attr("_OesQryOptionReq") = c;
}
void generate_class_OesQryOptionRspT(pybind11::module &m)
{
pybind11::class_<OesQryOptionRspT> c(m, "OesQryOptionRspT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesQryOptionRspT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesQryOptionRspT, "rspHead", rspHead);
c.AUTOCXXPY_DEF_PROPERTY(OesQryOptionRspT, "qryItems", qryItems);
AUTOCXXPY_POST_REGISTER_CLASS(OesQryOptionRspT, c);
m.attr("_OesQryOptionRsp") = c;
}
void generate_class_OesQryTradingDayRspT(pybind11::module &m)
{
pybind11::class_<OesQryTradingDayRspT> c(m, "OesQryTradingDayRspT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesQryTradingDayRspT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesQryTradingDayRspT, "tradingDay", tradingDay);
c.AUTOCXXPY_DEF_PROPERTY(OesQryTradingDayRspT, "__filler", __filler);
AUTOCXXPY_POST_REGISTER_CLASS(OesQryTradingDayRspT, c);
m.attr("_OesQryTradingDayRsp") = c;
}
void generate_class_OesQryMarketStateFilterT(pybind11::module &m)
{
pybind11::class_<OesQryMarketStateFilterT> c(m, "OesQryMarketStateFilterT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesQryMarketStateFilterT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesQryMarketStateFilterT, "exchId", exchId);
c.AUTOCXXPY_DEF_PROPERTY(OesQryMarketStateFilterT, "platformId", platformId);
c.AUTOCXXPY_DEF_PROPERTY(OesQryMarketStateFilterT, "__filler", __filler);
c.AUTOCXXPY_DEF_PROPERTY(OesQryMarketStateFilterT, "userInfo", userInfo);
AUTOCXXPY_POST_REGISTER_CLASS(OesQryMarketStateFilterT, c);
m.attr("_OesQryMarketStateFilter") = c;
}
void generate_class_OesQryMarketStateReqT(pybind11::module &m)
{
pybind11::class_<OesQryMarketStateReqT> c(m, "OesQryMarketStateReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesQryMarketStateReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesQryMarketStateReqT, "reqHead", reqHead);
c.AUTOCXXPY_DEF_PROPERTY(OesQryMarketStateReqT, "qryFilter", qryFilter);
AUTOCXXPY_POST_REGISTER_CLASS(OesQryMarketStateReqT, c);
m.attr("_OesQryMarketStateReq") = c;
}
void generate_class_OesQryMarketStateRspT(pybind11::module &m)
{
pybind11::class_<OesQryMarketStateRspT> c(m, "OesQryMarketStateRspT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesQryMarketStateRspT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesQryMarketStateRspT, "rspHead", rspHead);
c.AUTOCXXPY_DEF_PROPERTY(OesQryMarketStateRspT, "qryItems", qryItems);
AUTOCXXPY_POST_REGISTER_CLASS(OesQryMarketStateRspT, c);
m.attr("_OesQryMarketStateRsp") = c;
}
void generate_class_OesQryReqMsgT(pybind11::module &m)
{
pybind11::class_<OesQryReqMsgT> c(m, "OesQryReqMsgT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesQryReqMsgT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesQryReqMsgT, "qryOrd", qryOrd);
c.AUTOCXXPY_DEF_PROPERTY(OesQryReqMsgT, "qryTrd", qryTrd);
c.AUTOCXXPY_DEF_PROPERTY(OesQryReqMsgT, "qryCashAsset", qryCashAsset);
@ -128,11 +149,13 @@ void generate_class_OesQryReqMsgT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(OesQryReqMsgT, "qryMktState", qryMktState);
c.AUTOCXXPY_DEF_PROPERTY(OesQryReqMsgT, "qryCounterCash", qryCounterCash);
AUTOCXXPY_POST_REGISTER_CLASS(OesQryReqMsgT, c);
m.attr("_OesQryReqMsg") = c;
}
void generate_class_OesQryRspMsgT(pybind11::module &m)
{
pybind11::class_<OesQryRspMsgT> c(m, "OesQryRspMsgT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesQryRspMsgT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesQryRspMsgT, "ordRsp", ordRsp);
c.AUTOCXXPY_DEF_PROPERTY(OesQryRspMsgT, "trdRsp", trdRsp);
c.AUTOCXXPY_DEF_PROPERTY(OesQryRspMsgT, "cashAssetRsp", cashAssetRsp);
@ -153,11 +176,13 @@ void generate_class_OesQryRspMsgT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(OesQryRspMsgT, "clientOverview", clientOverview);
c.AUTOCXXPY_DEF_PROPERTY(OesQryRspMsgT, "counterCashRsp", counterCashRsp);
AUTOCXXPY_POST_REGISTER_CLASS(OesQryRspMsgT, c);
m.attr("_OesQryRspMsg") = c;
}
void generate_class_OesLogonReqT(pybind11::module &m)
{
pybind11::class_<OesLogonReqT> c(m, "OesLogonReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesLogonReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesLogonReqT, "encryptMethod", encryptMethod);
c.AUTOCXXPY_DEF_PROPERTY(OesLogonReqT, "heartBtInt", heartBtInt);
c.AUTOCXXPY_DEF_PROPERTY(OesLogonReqT, "username", username);
@ -173,11 +198,13 @@ void generate_class_OesLogonReqT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(OesLogonReqT, "lastOutMsgSeq", lastOutMsgSeq);
c.AUTOCXXPY_DEF_PROPERTY(OesLogonReqT, "clientDriverId", clientDriverId);
AUTOCXXPY_POST_REGISTER_CLASS(OesLogonReqT, c);
m.attr("_OesLogonReq") = c;
}
void generate_class_OesLogonRspT(pybind11::module &m)
{
pybind11::class_<OesLogonRspT> c(m, "OesLogonRspT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesLogonRspT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesLogonRspT, "encryptMethod", encryptMethod);
c.AUTOCXXPY_DEF_PROPERTY(OesLogonRspT, "heartBtInt", heartBtInt);
c.AUTOCXXPY_DEF_PROPERTY(OesLogonRspT, "username", username);
@ -194,40 +221,48 @@ void generate_class_OesLogonRspT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(OesLogonRspT, "lastInMsgSeq", lastInMsgSeq);
c.AUTOCXXPY_DEF_PROPERTY(OesLogonRspT, "lastOutMsgSeq", lastOutMsgSeq);
AUTOCXXPY_POST_REGISTER_CLASS(OesLogonRspT, c);
m.attr("_OesLogonRsp") = c;
}
void generate_class_OesReportSynchronizationReqT(pybind11::module &m)
{
pybind11::class_<OesReportSynchronizationReqT> c(m, "OesReportSynchronizationReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesReportSynchronizationReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesReportSynchronizationReqT, "lastRptSeqNum", lastRptSeqNum);
c.AUTOCXXPY_DEF_PROPERTY(OesReportSynchronizationReqT, "subscribeEnvId", subscribeEnvId);
c.AUTOCXXPY_DEF_PROPERTY(OesReportSynchronizationReqT, "__filler", __filler);
c.AUTOCXXPY_DEF_PROPERTY(OesReportSynchronizationReqT, "subscribeRptTypes", subscribeRptTypes);
AUTOCXXPY_POST_REGISTER_CLASS(OesReportSynchronizationReqT, c);
m.attr("_OesReportSynchronizationReq") = c;
}
void generate_class_OesReportSynchronizationRspT(pybind11::module &m)
{
pybind11::class_<OesReportSynchronizationRspT> c(m, "OesReportSynchronizationRspT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesReportSynchronizationRspT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesReportSynchronizationRspT, "lastRptSeqNum", lastRptSeqNum);
c.AUTOCXXPY_DEF_PROPERTY(OesReportSynchronizationRspT, "subscribeEnvId", subscribeEnvId);
c.AUTOCXXPY_DEF_PROPERTY(OesReportSynchronizationRspT, "__filler", __filler);
c.AUTOCXXPY_DEF_PROPERTY(OesReportSynchronizationRspT, "subscribeRptTypes", subscribeRptTypes);
AUTOCXXPY_POST_REGISTER_CLASS(OesReportSynchronizationRspT, c);
m.attr("_OesReportSynchronizationRsp") = c;
}
void generate_class_OesTestRequestReqT(pybind11::module &m)
{
pybind11::class_<OesTestRequestReqT> c(m, "OesTestRequestReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesTestRequestReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesTestRequestReqT, "testReqId", testReqId);
c.AUTOCXXPY_DEF_PROPERTY(OesTestRequestReqT, "sendTime", sendTime);
c.AUTOCXXPY_DEF_PROPERTY(OesTestRequestReqT, "__filler", __filler);
AUTOCXXPY_POST_REGISTER_CLASS(OesTestRequestReqT, c);
m.attr("_OesTestRequestReq") = c;
}
void generate_class_OesTestRequestRspT(pybind11::module &m)
{
pybind11::class_<OesTestRequestRspT> c(m, "OesTestRequestRspT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesTestRequestRspT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesTestRequestRspT, "testReqId", testReqId);
c.AUTOCXXPY_DEF_PROPERTY(OesTestRequestRspT, "origSendTime", origSendTime);
c.AUTOCXXPY_DEF_PROPERTY(OesTestRequestRspT, "__filler1", __filler1);
@ -237,11 +272,13 @@ void generate_class_OesTestRequestRspT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(OesTestRequestRspT, "__collectedTime", __collectedTime);
c.AUTOCXXPY_DEF_PROPERTY(OesTestRequestRspT, "__pushingTime", __pushingTime);
AUTOCXXPY_POST_REGISTER_CLASS(OesTestRequestRspT, c);
m.attr("_OesTestRequestRsp") = c;
}
void generate_class_OesChangePasswordReqT(pybind11::module &m)
{
pybind11::class_<OesChangePasswordReqT> c(m, "OesChangePasswordReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesChangePasswordReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesChangePasswordReqT, "encryptMethod", encryptMethod);
c.AUTOCXXPY_DEF_PROPERTY(OesChangePasswordReqT, "__filler", __filler);
c.AUTOCXXPY_DEF_PROPERTY(OesChangePasswordReqT, "username", username);
@ -249,11 +286,13 @@ void generate_class_OesChangePasswordReqT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(OesChangePasswordReqT, "oldPassword", oldPassword);
c.AUTOCXXPY_DEF_PROPERTY(OesChangePasswordReqT, "newPassword", newPassword);
AUTOCXXPY_POST_REGISTER_CLASS(OesChangePasswordReqT, c);
m.attr("_OesChangePasswordReq") = c;
}
void generate_class_OesChangePasswordRspT(pybind11::module &m)
{
pybind11::class_<OesChangePasswordRspT> c(m, "OesChangePasswordRspT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesChangePasswordRspT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesChangePasswordRspT, "encryptMethod", encryptMethod);
c.AUTOCXXPY_DEF_PROPERTY(OesChangePasswordRspT, "__filler", __filler);
c.AUTOCXXPY_DEF_PROPERTY(OesChangePasswordRspT, "username", username);
@ -265,38 +304,46 @@ void generate_class_OesChangePasswordRspT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(OesChangePasswordRspT, "transTime", transTime);
c.AUTOCXXPY_DEF_PROPERTY(OesChangePasswordRspT, "rejReason", rejReason);
AUTOCXXPY_POST_REGISTER_CLASS(OesChangePasswordRspT, c);
m.attr("_OesChangePasswordRsp") = c;
}
void generate_class_OesBatchOrdersHeadT(pybind11::module &m)
{
pybind11::class_<OesBatchOrdersHeadT> c(m, "OesBatchOrdersHeadT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesBatchOrdersHeadT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesBatchOrdersHeadT, "itemCount", itemCount);
c.AUTOCXXPY_DEF_PROPERTY(OesBatchOrdersHeadT, "__filler", __filler);
AUTOCXXPY_POST_REGISTER_CLASS(OesBatchOrdersHeadT, c);
m.attr("_OesBatchOrdersHead") = c;
}
void generate_class_OesBatchOrdersReqT(pybind11::module &m)
{
pybind11::class_<OesBatchOrdersReqT> c(m, "OesBatchOrdersReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesBatchOrdersReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesBatchOrdersReqT, "batchHead", batchHead);
c.AUTOCXXPY_DEF_PROPERTY(OesBatchOrdersReqT, "items", items);
AUTOCXXPY_POST_REGISTER_CLASS(OesBatchOrdersReqT, c);
m.attr("_OesBatchOrdersReq") = c;
}
void generate_class_OesRptMsgHeadT(pybind11::module &m)
{
pybind11::class_<OesRptMsgHeadT> c(m, "OesRptMsgHeadT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesRptMsgHeadT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesRptMsgHeadT, "rptSeqNum", rptSeqNum);
c.AUTOCXXPY_DEF_PROPERTY(OesRptMsgHeadT, "rptMsgType", rptMsgType);
c.AUTOCXXPY_DEF_PROPERTY(OesRptMsgHeadT, "execType", execType);
c.AUTOCXXPY_DEF_PROPERTY(OesRptMsgHeadT, "bodyLength", bodyLength);
c.AUTOCXXPY_DEF_PROPERTY(OesRptMsgHeadT, "ordRejReason", ordRejReason);
AUTOCXXPY_POST_REGISTER_CLASS(OesRptMsgHeadT, c);
m.attr("_OesRptMsgHead") = c;
}
void generate_class_OesRptMsgBodyT(pybind11::module &m)
{
pybind11::class_<OesRptMsgBodyT> c(m, "OesRptMsgBodyT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesRptMsgBodyT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesRptMsgBodyT, "ordInsertRsp", ordInsertRsp);
c.AUTOCXXPY_DEF_PROPERTY(OesRptMsgBodyT, "ordRejectRsp", ordRejectRsp);
c.AUTOCXXPY_DEF_PROPERTY(OesRptMsgBodyT, "ordCnfm", ordCnfm);
@ -307,19 +354,23 @@ void generate_class_OesRptMsgBodyT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(OesRptMsgBodyT, "stkHoldingRpt", stkHoldingRpt);
c.AUTOCXXPY_DEF_PROPERTY(OesRptMsgBodyT, "optHoldingRpt", optHoldingRpt);
AUTOCXXPY_POST_REGISTER_CLASS(OesRptMsgBodyT, c);
m.attr("_OesRptMsgBody") = c;
}
void generate_class_OesRptMsgT(pybind11::module &m)
{
pybind11::class_<OesRptMsgT> c(m, "OesRptMsgT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesRptMsgT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesRptMsgT, "rptHead", rptHead);
c.AUTOCXXPY_DEF_PROPERTY(OesRptMsgT, "rptBody", rptBody);
AUTOCXXPY_POST_REGISTER_CLASS(OesRptMsgT, c);
m.attr("_OesRptMsg") = c;
}
void generate_class_OesReqMsgBodyT(pybind11::module &m)
{
pybind11::class_<OesReqMsgBodyT> c(m, "OesReqMsgBodyT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesReqMsgBodyT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesReqMsgBodyT, "ordReq", ordReq);
c.AUTOCXXPY_DEF_PROPERTY(OesReqMsgBodyT, "ordCancelReq", ordCancelReq);
c.AUTOCXXPY_DEF_PROPERTY(OesReqMsgBodyT, "batchOrdersReq", batchOrdersReq);
@ -329,11 +380,13 @@ void generate_class_OesReqMsgBodyT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(OesReqMsgBodyT, "rptSyncReq", rptSyncReq);
c.AUTOCXXPY_DEF_PROPERTY(OesReqMsgBodyT, "logonReq", logonReq);
AUTOCXXPY_POST_REGISTER_CLASS(OesReqMsgBodyT, c);
m.attr("_OesReqMsgBody") = c;
}
void generate_class_OesRspMsgBodyT(pybind11::module &m)
{
pybind11::class_<OesRspMsgBodyT> c(m, "OesRspMsgBodyT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesRspMsgBodyT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesRspMsgBodyT, "rptMsg", rptMsg);
c.AUTOCXXPY_DEF_PROPERTY(OesRspMsgBodyT, "mktStateRpt", mktStateRpt);
c.AUTOCXXPY_DEF_PROPERTY(OesRspMsgBodyT, "changePasswordRsp", changePasswordRsp);
@ -341,11 +394,13 @@ void generate_class_OesRspMsgBodyT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(OesRspMsgBodyT, "reportSynchronizationRsp", reportSynchronizationRsp);
c.AUTOCXXPY_DEF_PROPERTY(OesRspMsgBodyT, "logonRsp", logonRsp);
AUTOCXXPY_POST_REGISTER_CLASS(OesRspMsgBodyT, c);
m.attr("_OesRspMsgBody") = c;
}
void generate_class_SErrMsgT(pybind11::module &m)
{
pybind11::class_<SErrMsgT> c(m, "SErrMsgT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<SErrMsgT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(SErrMsgT, "__index", __index);
c.AUTOCXXPY_DEF_PROPERTY(SErrMsgT, "MODULE", MODULE);
c.AUTOCXXPY_DEF_PROPERTY(SErrMsgT, "CODE", CODE);
@ -353,21 +408,25 @@ void generate_class_SErrMsgT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(SErrMsgT, "__msgSize", __msgSize);
c.AUTOCXXPY_DEF_PROPERTY(SErrMsgT, "MSG", MSG);
AUTOCXXPY_POST_REGISTER_CLASS(SErrMsgT, c);
m.attr("_SErrMsg") = c;
}
void generate_class_SDataBufferT(pybind11::module &m)
{
pybind11::class_<SDataBufferT> c(m, "SDataBufferT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<SDataBufferT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(SDataBufferT, "dataSize", dataSize);
c.AUTOCXXPY_DEF_PROPERTY(SDataBufferT, "bufSize", bufSize);
c.AUTOCXXPY_DEF_PROPERTY(SDataBufferT, "buffer", buffer);
c.AUTOCXXPY_DEF_PROPERTY(SDataBufferT, "__ref", __ref);
AUTOCXXPY_POST_REGISTER_CLASS(SDataBufferT, c);
m.attr("_SDataBuffer") = c;
}
void generate_class__SDataBufferVar(pybind11::module &m)
{
pybind11::class_<_SDataBufferVar> c(m, "_SDataBufferVar");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<_SDataBufferVar>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(_SDataBufferVar, "dataSize", dataSize);
c.AUTOCXXPY_DEF_PROPERTY(_SDataBufferVar, "bufSize", bufSize);
c.AUTOCXXPY_DEF_PROPERTY(_SDataBufferVar, "buffer", buffer);
@ -377,22 +436,27 @@ void generate_class__SDataBufferVar(pybind11::module &m)
void generate_class_SSocketUriInfoT(pybind11::module &m)
{
pybind11::class_<SSocketUriInfoT> c(m, "SSocketUriInfoT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<SSocketUriInfoT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(SSocketUriInfoT, "uri", uri);
AUTOCXXPY_POST_REGISTER_CLASS(SSocketUriInfoT, c);
m.attr("_SSocketUriInfo") = c;
}
void generate_class_SSocketIpPortInfoT(pybind11::module &m)
{
pybind11::class_<SSocketIpPortInfoT> c(m, "SSocketIpPortInfoT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<SSocketIpPortInfoT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(SSocketIpPortInfoT, "port", port);
c.AUTOCXXPY_DEF_PROPERTY(SSocketIpPortInfoT, "ip", ip);
AUTOCXXPY_POST_REGISTER_CLASS(SSocketIpPortInfoT, c);
m.attr("_SSocketIpPortInfo") = c;
}
void generate_class_SSocketChannelInfoT(pybind11::module &m)
{
pybind11::class_<SSocketChannelInfoT> c(m, "SSocketChannelInfoT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<SSocketChannelInfoT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(SSocketChannelInfoT, "remotePort", remotePort);
c.AUTOCXXPY_DEF_PROPERTY(SSocketChannelInfoT, "protocolType", protocolType);
c.AUTOCXXPY_DEF_PROPERTY(SSocketChannelInfoT, "_isNetByteOrder", _isNetByteOrder);
@ -400,11 +464,13 @@ void generate_class_SSocketChannelInfoT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(SSocketChannelInfoT, "_isSendBroken", _isSendBroken);
c.AUTOCXXPY_DEF_PROPERTY(SSocketChannelInfoT, "remoteAddr", remoteAddr);
AUTOCXXPY_POST_REGISTER_CLASS(SSocketChannelInfoT, c);
m.attr("_SSocketChannelInfo") = c;
}
void generate_class_SSocketOptionConfigT(pybind11::module &m)
{
pybind11::class_<SSocketOptionConfigT> c(m, "SSocketOptionConfigT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<SSocketOptionConfigT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(SSocketOptionConfigT, "soRcvbuf", soRcvbuf);
c.AUTOCXXPY_DEF_PROPERTY(SSocketOptionConfigT, "soSndbuf", soSndbuf);
c.AUTOCXXPY_DEF_PROPERTY(SSocketOptionConfigT, "tcpNodelay", tcpNodelay);
@ -422,11 +488,13 @@ void generate_class_SSocketOptionConfigT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(SSocketOptionConfigT, "localSendingIp", localSendingIp);
c.AUTOCXXPY_DEF_PROPERTY(SSocketOptionConfigT, "mcastInterfaceIp", mcastInterfaceIp);
AUTOCXXPY_POST_REGISTER_CLASS(SSocketOptionConfigT, c);
m.attr("_SSocketOptionConfig") = c;
}
void generate_class_SGeneralClientChannelT(pybind11::module &m)
{
pybind11::class_<SGeneralClientChannelT> c(m, "SGeneralClientChannelT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<SGeneralClientChannelT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientChannelT, "heartBtInt", heartBtInt);
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientChannelT, "testReqInt", testReqInt);
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientChannelT, "protocolType", protocolType);
@ -463,11 +531,15 @@ void generate_class_SGeneralClientChannelT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientChannelT, "__reserveData", __reserveData);
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientChannelT, "__extData", __extData);
AUTOCXXPY_POST_REGISTER_CLASS(SGeneralClientChannelT, c);
m.attr("MdsApiSessionInfoT") = c;
m.attr("_SGeneralClientChannel") = c;
m.attr("OesApiSessionInfoT") = c;
}
void generate_class_SGeneralClientChannelGroupT(pybind11::module &m)
{
pybind11::class_<SGeneralClientChannelGroupT> c(m, "SGeneralClientChannelGroupT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<SGeneralClientChannelGroupT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientChannelGroupT, "channelCount", channelCount);
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientChannelGroupT, "__customFlag", __customFlag);
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientChannelGroupT, "channelList", channelList);
@ -476,11 +548,15 @@ void generate_class_SGeneralClientChannelGroupT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientChannelGroupT, "__filler", __filler);
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientChannelGroupT, "__fdSet", __fdSet);
AUTOCXXPY_POST_REGISTER_CLASS(SGeneralClientChannelGroupT, c);
m.attr("_SGeneralClientChannelGroup") = c;
m.attr("OesApiChannelGroupT") = c;
m.attr("MdsApiChannelGroupT") = c;
}
void generate_class_SGeneralClientAddrInfoT(pybind11::module &m)
{
pybind11::class_<SGeneralClientAddrInfoT> c(m, "SGeneralClientAddrInfoT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<SGeneralClientAddrInfoT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientAddrInfoT, "uri", uri);
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientAddrInfoT, "targetCompId", targetCompId);
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientAddrInfoT, "username", username);
@ -488,11 +564,15 @@ void generate_class_SGeneralClientAddrInfoT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientAddrInfoT, "hostNum", hostNum);
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientAddrInfoT, "__filler", __filler);
AUTOCXXPY_POST_REGISTER_CLASS(SGeneralClientAddrInfoT, c);
m.attr("MdsApiAddrInfoT") = c;
m.attr("OesApiAddrInfoT") = c;
m.attr("_SGeneralClientAddrInfo") = c;
}
void generate_class_SGeneralClientRemoteCfgT(pybind11::module &m)
{
pybind11::class_<SGeneralClientRemoteCfgT> c(m, "SGeneralClientRemoteCfgT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<SGeneralClientRemoteCfgT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientRemoteCfgT, "addrCnt", addrCnt);
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientRemoteCfgT, "heartBtInt", heartBtInt);
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientRemoteCfgT, "clusterType", clusterType);
@ -505,39 +585,49 @@ void generate_class_SGeneralClientRemoteCfgT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientRemoteCfgT, "addrList", addrList);
c.AUTOCXXPY_DEF_PROPERTY(SGeneralClientRemoteCfgT, "socketOpt", socketOpt);
AUTOCXXPY_POST_REGISTER_CLASS(SGeneralClientRemoteCfgT, c);
m.attr("_SGeneralClientRemoteCfg") = c;
m.attr("MdsApiRemoteCfgT") = c;
m.attr("OesApiRemoteCfgT") = c;
}
void generate_class_OesApiSubscribeInfoT(pybind11::module &m)
{
pybind11::class_<OesApiSubscribeInfoT> c(m, "OesApiSubscribeInfoT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesApiSubscribeInfoT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesApiSubscribeInfoT, "clEnvId", clEnvId);
c.AUTOCXXPY_DEF_PROPERTY(OesApiSubscribeInfoT, "__filler", __filler);
c.AUTOCXXPY_DEF_PROPERTY(OesApiSubscribeInfoT, "rptTypes", rptTypes);
AUTOCXXPY_POST_REGISTER_CLASS(OesApiSubscribeInfoT, c);
m.attr("_OesApiSubscribeInfo") = c;
}
void generate_class_OesApiClientCfgT(pybind11::module &m)
{
pybind11::class_<OesApiClientCfgT> c(m, "OesApiClientCfgT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesApiClientCfgT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesApiClientCfgT, "ordChannelCfg", ordChannelCfg);
c.AUTOCXXPY_DEF_PROPERTY(OesApiClientCfgT, "rptChannelCfg", rptChannelCfg);
c.AUTOCXXPY_DEF_PROPERTY(OesApiClientCfgT, "qryChannelCfg", qryChannelCfg);
c.AUTOCXXPY_DEF_PROPERTY(OesApiClientCfgT, "subscribeInfo", subscribeInfo);
AUTOCXXPY_POST_REGISTER_CLASS(OesApiClientCfgT, c);
m.attr("_OesApiClientCfg") = c;
}
void generate_class_OesApiClientEnvT(pybind11::module &m)
{
pybind11::class_<OesApiClientEnvT> c(m, "OesApiClientEnvT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<OesApiClientEnvT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(OesApiClientEnvT, "ordChannel", ordChannel);
c.AUTOCXXPY_DEF_PROPERTY(OesApiClientEnvT, "rptChannel", rptChannel);
c.AUTOCXXPY_DEF_PROPERTY(OesApiClientEnvT, "qryChannel", qryChannel);
AUTOCXXPY_POST_REGISTER_CLASS(OesApiClientEnvT, c);
m.attr("_OesApiClientEnv") = c;
}
void generate_class_MdsTradingSessionStatusMsgT(pybind11::module &m)
{
pybind11::class_<MdsTradingSessionStatusMsgT> c(m, "MdsTradingSessionStatusMsgT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsTradingSessionStatusMsgT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsTradingSessionStatusMsgT, "exchId", exchId);
c.AUTOCXXPY_DEF_PROPERTY(MdsTradingSessionStatusMsgT, "securityType", securityType);
c.AUTOCXXPY_DEF_PROPERTY(MdsTradingSessionStatusMsgT, "__isRepeated", __isRepeated);
@ -557,11 +647,13 @@ void generate_class_MdsTradingSessionStatusMsgT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsTradingSessionStatusMsgT, "__processedTime", __processedTime);
c.AUTOCXXPY_DEF_PROPERTY(MdsTradingSessionStatusMsgT, "__pushingTime", __pushingTime);
AUTOCXXPY_POST_REGISTER_CLASS(MdsTradingSessionStatusMsgT, c);
m.attr("_MdsTradingSessionStatusMsg") = c;
}
void generate_class_MdsSecurityStatusMsgT(pybind11::module &m)
{
pybind11::class_<MdsSecurityStatusMsgT> c(m, "MdsSecurityStatusMsgT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsSecurityStatusMsgT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsSecurityStatusMsgT, "exchId", exchId);
c.AUTOCXXPY_DEF_PROPERTY(MdsSecurityStatusMsgT, "securityType", securityType);
c.AUTOCXXPY_DEF_PROPERTY(MdsSecurityStatusMsgT, "__isRepeated", __isRepeated);
@ -586,20 +678,24 @@ void generate_class_MdsSecurityStatusMsgT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsSecurityStatusMsgT, "__processedTime", __processedTime);
c.AUTOCXXPY_DEF_PROPERTY(MdsSecurityStatusMsgT, "__pushingTime", __pushingTime);
AUTOCXXPY_POST_REGISTER_CLASS(MdsSecurityStatusMsgT, c);
m.attr("_MdsSecurityStatusMsg") = c;
}
void generate_class_MdsPriceLevelEntryT(pybind11::module &m)
{
pybind11::class_<MdsPriceLevelEntryT> c(m, "MdsPriceLevelEntryT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsPriceLevelEntryT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsPriceLevelEntryT, "Price", Price);
c.AUTOCXXPY_DEF_PROPERTY(MdsPriceLevelEntryT, "NumberOfOrders", NumberOfOrders);
c.AUTOCXXPY_DEF_PROPERTY(MdsPriceLevelEntryT, "OrderQty", OrderQty);
AUTOCXXPY_POST_REGISTER_CLASS(MdsPriceLevelEntryT, c);
m.attr("_MdsPriceLevelEntry") = c;
}
void generate_class_MdsMktDataSnapshotHeadT(pybind11::module &m)
{
pybind11::class_<MdsMktDataSnapshotHeadT> c(m, "MdsMktDataSnapshotHeadT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsMktDataSnapshotHeadT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotHeadT, "exchId", exchId);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotHeadT, "securityType", securityType);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotHeadT, "__isRepeated", __isRepeated);
@ -618,11 +714,13 @@ void generate_class_MdsMktDataSnapshotHeadT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotHeadT, "__processedTime", __processedTime);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotHeadT, "__pushingTime", __pushingTime);
AUTOCXXPY_POST_REGISTER_CLASS(MdsMktDataSnapshotHeadT, c);
m.attr("_MdsMktDataSnapshotHead") = c;
}
void generate_class_MdsIndexSnapshotBodyT(pybind11::module &m)
{
pybind11::class_<MdsIndexSnapshotBodyT> c(m, "MdsIndexSnapshotBodyT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsIndexSnapshotBodyT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsIndexSnapshotBodyT, "SecurityID", SecurityID);
c.AUTOCXXPY_DEF_PROPERTY(MdsIndexSnapshotBodyT, "TradingPhaseCode", TradingPhaseCode);
c.AUTOCXXPY_DEF_PROPERTY(MdsIndexSnapshotBodyT, "__filler", __filler);
@ -638,11 +736,13 @@ void generate_class_MdsIndexSnapshotBodyT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsIndexSnapshotBodyT, "StockNum", StockNum);
c.AUTOCXXPY_DEF_PROPERTY(MdsIndexSnapshotBodyT, "__filler1", __filler1);
AUTOCXXPY_POST_REGISTER_CLASS(MdsIndexSnapshotBodyT, c);
m.attr("_MdsIndexSnapshotBody") = c;
}
void generate_class_MdsStockSnapshotBodyT(pybind11::module &m)
{
pybind11::class_<MdsStockSnapshotBodyT> c(m, "MdsStockSnapshotBodyT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsStockSnapshotBodyT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsStockSnapshotBodyT, "SecurityID", SecurityID);
c.AUTOCXXPY_DEF_PROPERTY(MdsStockSnapshotBodyT, "TradingPhaseCode", TradingPhaseCode);
c.AUTOCXXPY_DEF_PROPERTY(MdsStockSnapshotBodyT, "__filler", __filler);
@ -661,20 +761,24 @@ void generate_class_MdsStockSnapshotBodyT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsStockSnapshotBodyT, "BidLevels", BidLevels);
c.AUTOCXXPY_DEF_PROPERTY(MdsStockSnapshotBodyT, "OfferLevels", OfferLevels);
AUTOCXXPY_POST_REGISTER_CLASS(MdsStockSnapshotBodyT, c);
m.attr("_MdsStockSnapshotBody") = c;
}
void generate_class_MdsL1SnapshotBodyT(pybind11::module &m)
{
pybind11::class_<MdsL1SnapshotBodyT> c(m, "MdsL1SnapshotBodyT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsL1SnapshotBodyT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsL1SnapshotBodyT, "stock", stock);
c.AUTOCXXPY_DEF_PROPERTY(MdsL1SnapshotBodyT, "option", option);
c.AUTOCXXPY_DEF_PROPERTY(MdsL1SnapshotBodyT, "index", index);
AUTOCXXPY_POST_REGISTER_CLASS(MdsL1SnapshotBodyT, c);
m.attr("_MdsL1SnapshotBody") = c;
}
void generate_class_MdsL2StockSnapshotBodyT(pybind11::module &m)
{
pybind11::class_<MdsL2StockSnapshotBodyT> c(m, "MdsL2StockSnapshotBodyT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsL2StockSnapshotBodyT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsL2StockSnapshotBodyT, "SecurityID", SecurityID);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2StockSnapshotBodyT, "TradingPhaseCode", TradingPhaseCode);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2StockSnapshotBodyT, "__filler", __filler);
@ -699,11 +803,13 @@ void generate_class_MdsL2StockSnapshotBodyT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsL2StockSnapshotBodyT, "BidLevels", BidLevels);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2StockSnapshotBodyT, "OfferLevels", OfferLevels);
AUTOCXXPY_POST_REGISTER_CLASS(MdsL2StockSnapshotBodyT, c);
m.attr("_MdsL2StockSnapshotBody") = c;
}
void generate_class_MdsL2StockSnapshotIncrementalT(pybind11::module &m)
{
pybind11::class_<MdsL2StockSnapshotIncrementalT> c(m, "MdsL2StockSnapshotIncrementalT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsL2StockSnapshotIncrementalT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsL2StockSnapshotIncrementalT, "NumTrades", NumTrades);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2StockSnapshotIncrementalT, "TotalVolumeTraded", TotalVolumeTraded);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2StockSnapshotIncrementalT, "TotalValueTraded", TotalValueTraded);
@ -728,11 +834,13 @@ void generate_class_MdsL2StockSnapshotIncrementalT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsL2StockSnapshotIncrementalT, "PriceLevelOperator", PriceLevelOperator);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2StockSnapshotIncrementalT, "PriceLevels", PriceLevels);
AUTOCXXPY_POST_REGISTER_CLASS(MdsL2StockSnapshotIncrementalT, c);
m.attr("_MdsL2StockSnapshotIncremental") = c;
}
void generate_class_MdsL2BestOrdersSnapshotBodyT(pybind11::module &m)
{
pybind11::class_<MdsL2BestOrdersSnapshotBodyT> c(m, "MdsL2BestOrdersSnapshotBodyT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsL2BestOrdersSnapshotBodyT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsL2BestOrdersSnapshotBodyT, "SecurityID", SecurityID);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2BestOrdersSnapshotBodyT, "__filler", __filler);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2BestOrdersSnapshotBodyT, "NoBidOrders", NoBidOrders);
@ -743,11 +851,13 @@ void generate_class_MdsL2BestOrdersSnapshotBodyT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsL2BestOrdersSnapshotBodyT, "BidOrderQty", BidOrderQty);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2BestOrdersSnapshotBodyT, "OfferOrderQty", OfferOrderQty);
AUTOCXXPY_POST_REGISTER_CLASS(MdsL2BestOrdersSnapshotBodyT, c);
m.attr("_MdsL2BestOrdersSnapshotBody") = c;
}
void generate_class_MdsL2BestOrdersSnapshotIncrementalT(pybind11::module &m)
{
pybind11::class_<MdsL2BestOrdersSnapshotIncrementalT> c(m, "MdsL2BestOrdersSnapshotIncrementalT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsL2BestOrdersSnapshotIncrementalT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsL2BestOrdersSnapshotIncrementalT, "TotalVolumeTraded", TotalVolumeTraded);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2BestOrdersSnapshotIncrementalT, "BestBidPrice", BestBidPrice);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2BestOrdersSnapshotIncrementalT, "HasContainedBestBidLevel", HasContainedBestBidLevel);
@ -762,11 +872,13 @@ void generate_class_MdsL2BestOrdersSnapshotIncrementalT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsL2BestOrdersSnapshotIncrementalT, "OperatorEntryID", OperatorEntryID);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2BestOrdersSnapshotIncrementalT, "OrderQty", OrderQty);
AUTOCXXPY_POST_REGISTER_CLASS(MdsL2BestOrdersSnapshotIncrementalT, c);
m.attr("_MdsL2BestOrdersSnapshotIncremental") = c;
}
void generate_class_MdsL2VirtualAuctionPriceT(pybind11::module &m)
{
pybind11::class_<MdsL2VirtualAuctionPriceT> c(m, "MdsL2VirtualAuctionPriceT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsL2VirtualAuctionPriceT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsL2VirtualAuctionPriceT, "SecurityID", SecurityID);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2VirtualAuctionPriceT, "LeavesSide", LeavesSide);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2VirtualAuctionPriceT, "__filler", __filler);
@ -774,21 +886,25 @@ void generate_class_MdsL2VirtualAuctionPriceT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsL2VirtualAuctionPriceT, "VirtualAuctionQty", VirtualAuctionQty);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2VirtualAuctionPriceT, "LeavesQty", LeavesQty);
AUTOCXXPY_POST_REGISTER_CLASS(MdsL2VirtualAuctionPriceT, c);
m.attr("_MdsL2VirtualAuctionPrice") = c;
}
void generate_class_MdsL2MarketOverviewT(pybind11::module &m)
{
pybind11::class_<MdsL2MarketOverviewT> c(m, "MdsL2MarketOverviewT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsL2MarketOverviewT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsL2MarketOverviewT, "OrigDate", OrigDate);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2MarketOverviewT, "OrigTime", OrigTime);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2MarketOverviewT, "__exchSendingTime", __exchSendingTime);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2MarketOverviewT, "__mdsRecvTime", __mdsRecvTime);
AUTOCXXPY_POST_REGISTER_CLASS(MdsL2MarketOverviewT, c);
m.attr("_MdsL2MarketOverview") = c;
}
void generate_class_MdsL2SnapshotBodyT(pybind11::module &m)
{
pybind11::class_<MdsL2SnapshotBodyT> c(m, "MdsL2SnapshotBodyT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsL2SnapshotBodyT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsL2SnapshotBodyT, "l2Stock", l2Stock);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2SnapshotBodyT, "l2StockIncremental", l2StockIncremental);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2SnapshotBodyT, "l2BestOrders", l2BestOrders);
@ -797,11 +913,13 @@ void generate_class_MdsL2SnapshotBodyT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsL2SnapshotBodyT, "l2VirtualAuctionPrice", l2VirtualAuctionPrice);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2SnapshotBodyT, "l2MarketOverview", l2MarketOverview);
AUTOCXXPY_POST_REGISTER_CLASS(MdsL2SnapshotBodyT, c);
m.attr("_MdsL2SnapshotBody") = c;
}
void generate_class_MdsMktDataSnapshotT(pybind11::module &m)
{
pybind11::class_<MdsMktDataSnapshotT> c(m, "MdsMktDataSnapshotT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsMktDataSnapshotT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "head", head);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "l2Stock", l2Stock);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "l2StockIncremental", l2StockIncremental);
@ -813,11 +931,13 @@ void generate_class_MdsMktDataSnapshotT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "l2VirtualAuctionPrice", l2VirtualAuctionPrice);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataSnapshotT, "l2MarketOverview", l2MarketOverview);
AUTOCXXPY_POST_REGISTER_CLASS(MdsMktDataSnapshotT, c);
m.attr("_MdsMktDataSnapshot") = c;
}
void generate_class_MdsL2TradeT(pybind11::module &m)
{
pybind11::class_<MdsL2TradeT> c(m, "MdsL2TradeT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsL2TradeT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsL2TradeT, "exchId", exchId);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2TradeT, "securityType", securityType);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2TradeT, "__isRepeated", __isRepeated);
@ -844,11 +964,13 @@ void generate_class_MdsL2TradeT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsL2TradeT, "__processedTime", __processedTime);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2TradeT, "__pushingTime", __pushingTime);
AUTOCXXPY_POST_REGISTER_CLASS(MdsL2TradeT, c);
m.attr("_MdsL2Trade") = c;
}
void generate_class_MdsL2OrderT(pybind11::module &m)
{
pybind11::class_<MdsL2OrderT> c(m, "MdsL2OrderT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsL2OrderT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsL2OrderT, "exchId", exchId);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2OrderT, "securityType", securityType);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2OrderT, "__isRepeated", __isRepeated);
@ -872,11 +994,13 @@ void generate_class_MdsL2OrderT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsL2OrderT, "__processedTime", __processedTime);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2OrderT, "__pushingTime", __pushingTime);
AUTOCXXPY_POST_REGISTER_CLASS(MdsL2OrderT, c);
m.attr("_MdsL2Order") = c;
}
void generate_class_MdsL2TickLostT(pybind11::module &m)
{
pybind11::class_<MdsL2TickLostT> c(m, "MdsL2TickLostT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsL2TickLostT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsL2TickLostT, "exchId", exchId);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2TickLostT, "__filler3", __filler3);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2TickLostT, "tradeDate", tradeDate);
@ -886,41 +1010,50 @@ void generate_class_MdsL2TickLostT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsL2TickLostT, "endApplSeqNum", endApplSeqNum);
c.AUTOCXXPY_DEF_PROPERTY(MdsL2TickLostT, "__origTickSeq", __origTickSeq);
AUTOCXXPY_POST_REGISTER_CLASS(MdsL2TickLostT, c);
m.attr("_MdsL2TickLost") = c;
}
void generate_class_MdsQryMktDataSnapshotReqT(pybind11::module &m)
{
pybind11::class_<MdsQryMktDataSnapshotReqT> c(m, "MdsQryMktDataSnapshotReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsQryMktDataSnapshotReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsQryMktDataSnapshotReqT, "exchId", exchId);
c.AUTOCXXPY_DEF_PROPERTY(MdsQryMktDataSnapshotReqT, "securityType", securityType);
c.AUTOCXXPY_DEF_PROPERTY(MdsQryMktDataSnapshotReqT, "__filler", __filler);
c.AUTOCXXPY_DEF_PROPERTY(MdsQryMktDataSnapshotReqT, "instrId", instrId);
AUTOCXXPY_POST_REGISTER_CLASS(MdsQryMktDataSnapshotReqT, c);
m.attr("MdsQrySecurityStatusReqT") = c;
m.attr("_MdsQryMktDataSnapshotReq") = c;
}
void generate_class_MdsQryTrdSessionStatusReqT(pybind11::module &m)
{
pybind11::class_<MdsQryTrdSessionStatusReqT> c(m, "MdsQryTrdSessionStatusReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsQryTrdSessionStatusReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsQryTrdSessionStatusReqT, "exchId", exchId);
c.AUTOCXXPY_DEF_PROPERTY(MdsQryTrdSessionStatusReqT, "securityType", securityType);
c.AUTOCXXPY_DEF_PROPERTY(MdsQryTrdSessionStatusReqT, "__filler", __filler);
AUTOCXXPY_POST_REGISTER_CLASS(MdsQryTrdSessionStatusReqT, c);
m.attr("_MdsQryTrdSessionStatusReq") = c;
}
void generate_class_MdsLogonReqT(pybind11::module &m)
{
pybind11::class_<MdsLogonReqT> c(m, "MdsLogonReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsLogonReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsLogonReqT, "encryptMethod", encryptMethod);
c.AUTOCXXPY_DEF_PROPERTY(MdsLogonReqT, "heartBtInt", heartBtInt);
c.AUTOCXXPY_DEF_PROPERTY(MdsLogonReqT, "username", username);
c.AUTOCXXPY_DEF_PROPERTY(MdsLogonReqT, "password", password);
c.AUTOCXXPY_DEF_PROPERTY(MdsLogonReqT, "applVerId", applVerId);
AUTOCXXPY_POST_REGISTER_CLASS(MdsLogonReqT, c);
m.attr("_MdsLogonReq") = c;
}
void generate_class_MdsLogonRspT(pybind11::module &m)
{
pybind11::class_<MdsLogonRspT> c(m, "MdsLogonRspT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsLogonRspT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsLogonRspT, "encryptMethod", encryptMethod);
c.AUTOCXXPY_DEF_PROPERTY(MdsLogonRspT, "heartBtInt", heartBtInt);
c.AUTOCXXPY_DEF_PROPERTY(MdsLogonRspT, "username", username);
@ -931,21 +1064,25 @@ void generate_class_MdsLogonRspT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsLogonRspT, "leaderHostNum", leaderHostNum);
c.AUTOCXXPY_DEF_PROPERTY(MdsLogonRspT, "__filler", __filler);
AUTOCXXPY_POST_REGISTER_CLASS(MdsLogonRspT, c);
m.attr("_MdsLogonRsp") = c;
}
void generate_class_MdsMktDataRequestEntryT(pybind11::module &m)
{
pybind11::class_<MdsMktDataRequestEntryT> c(m, "MdsMktDataRequestEntryT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsMktDataRequestEntryT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestEntryT, "exchId", exchId);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestEntryT, "securityType", securityType);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestEntryT, "__filler", __filler);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestEntryT, "instrId", instrId);
AUTOCXXPY_POST_REGISTER_CLASS(MdsMktDataRequestEntryT, c);
m.attr("_MdsMktDataRequestEntry") = c;
}
void generate_class_MdsMktDataRequestReqT(pybind11::module &m)
{
pybind11::class_<MdsMktDataRequestReqT> c(m, "MdsMktDataRequestReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsMktDataRequestReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestReqT, "subMode", subMode);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestReqT, "tickType", tickType);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestReqT, "sseStockFlag", sseStockFlag);
@ -962,19 +1099,24 @@ void generate_class_MdsMktDataRequestReqT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestReqT, "beginTime", beginTime);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestReqT, "subSecurityCnt", subSecurityCnt);
AUTOCXXPY_POST_REGISTER_CLASS(MdsMktDataRequestReqT, c);
m.attr("_MdsMktDataRequestReq") = c;
}
void generate_class_MdsMktDataRequestReqBufT(pybind11::module &m)
{
pybind11::class_<MdsMktDataRequestReqBufT> c(m, "MdsMktDataRequestReqBufT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsMktDataRequestReqBufT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestReqBufT, "mktDataRequestReq", mktDataRequestReq);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestReqBufT, "entries", entries);
AUTOCXXPY_POST_REGISTER_CLASS(MdsMktDataRequestReqBufT, c);
m.attr("MdsApiSubscribeInfoT") = c;
m.attr("_MdsMktDataRequestReqBuf") = c;
}
void generate_class_MdsMktDataRequestRspT(pybind11::module &m)
{
pybind11::class_<MdsMktDataRequestRspT> c(m, "MdsMktDataRequestRspT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsMktDataRequestRspT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestRspT, "subMode", subMode);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestRspT, "tickType", tickType);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestRspT, "isRequireInitialMktData", isRequireInitialMktData);
@ -990,20 +1132,24 @@ void generate_class_MdsMktDataRequestRspT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestRspT, "szseIndexSubscribed", szseIndexSubscribed);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktDataRequestRspT, "szseOptionSubscribed", szseOptionSubscribed);
AUTOCXXPY_POST_REGISTER_CLASS(MdsMktDataRequestRspT, c);
m.attr("_MdsMktDataRequestRsp") = c;
}
void generate_class_MdsTestRequestReqT(pybind11::module &m)
{
pybind11::class_<MdsTestRequestReqT> c(m, "MdsTestRequestReqT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsTestRequestReqT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsTestRequestReqT, "testReqId", testReqId);
c.AUTOCXXPY_DEF_PROPERTY(MdsTestRequestReqT, "sendTime", sendTime);
c.AUTOCXXPY_DEF_PROPERTY(MdsTestRequestReqT, "__filler", __filler);
AUTOCXXPY_POST_REGISTER_CLASS(MdsTestRequestReqT, c);
m.attr("_MdsTestRequestReq") = c;
}
void generate_class_MdsTestRequestRspT(pybind11::module &m)
{
pybind11::class_<MdsTestRequestRspT> c(m, "MdsTestRequestRspT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsTestRequestRspT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsTestRequestRspT, "testReqId", testReqId);
c.AUTOCXXPY_DEF_PROPERTY(MdsTestRequestRspT, "origSendTime", origSendTime);
c.AUTOCXXPY_DEF_PROPERTY(MdsTestRequestRspT, "__filler1", __filler1);
@ -1013,11 +1159,13 @@ void generate_class_MdsTestRequestRspT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsTestRequestRspT, "__collectedTime", __collectedTime);
c.AUTOCXXPY_DEF_PROPERTY(MdsTestRequestRspT, "__pushingTime", __pushingTime);
AUTOCXXPY_POST_REGISTER_CLASS(MdsTestRequestRspT, c);
m.attr("_MdsTestRequestRsp") = c;
}
void generate_class_MdsMktReqMsgBodyT(pybind11::module &m)
{
pybind11::class_<MdsMktReqMsgBodyT> c(m, "MdsMktReqMsgBodyT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsMktReqMsgBodyT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsMktReqMsgBodyT, "wholeMktDataReqBuf", wholeMktDataReqBuf);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktReqMsgBodyT, "mktDataRequestReq", mktDataRequestReq);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktReqMsgBodyT, "testRequestReq", testRequestReq);
@ -1026,11 +1174,13 @@ void generate_class_MdsMktReqMsgBodyT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsMktReqMsgBodyT, "qrySecurityStatusReq", qrySecurityStatusReq);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktReqMsgBodyT, "qryTrdSessionStatusReq", qryTrdSessionStatusReq);
AUTOCXXPY_POST_REGISTER_CLASS(MdsMktReqMsgBodyT, c);
m.attr("_MdsMktReqMsgBody") = c;
}
void generate_class_MdsMktRspMsgBodyT(pybind11::module &m)
{
pybind11::class_<MdsMktRspMsgBodyT> c(m, "MdsMktRspMsgBodyT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsMktRspMsgBodyT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsMktRspMsgBodyT, "mktDataRequestRsp", mktDataRequestRsp);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktRspMsgBodyT, "testRequestRsp", testRequestRsp);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktRspMsgBodyT, "logonRsp", logonRsp);
@ -1041,20 +1191,24 @@ void generate_class_MdsMktRspMsgBodyT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsMktRspMsgBodyT, "trdSessionStatus", trdSessionStatus);
c.AUTOCXXPY_DEF_PROPERTY(MdsMktRspMsgBodyT, "securityStatus", securityStatus);
AUTOCXXPY_POST_REGISTER_CLASS(MdsMktRspMsgBodyT, c);
m.attr("_MdsMktRspMsgBody") = c;
}
void generate_class_MdsUdpPktHeadT(pybind11::module &m)
{
pybind11::class_<MdsUdpPktHeadT> c(m, "MdsUdpPktHeadT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsUdpPktHeadT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsUdpPktHeadT, "msgCnt", msgCnt);
c.AUTOCXXPY_DEF_PROPERTY(MdsUdpPktHeadT, "pktSiz", pktSiz);
c.AUTOCXXPY_DEF_PROPERTY(MdsUdpPktHeadT, "pktSeq", pktSeq);
AUTOCXXPY_POST_REGISTER_CLASS(MdsUdpPktHeadT, c);
m.attr("_MdsUdpPktHead") = c;
}
void generate_class_MdsApiClientCfgT(pybind11::module &m)
{
pybind11::class_<MdsApiClientCfgT> c(m, "MdsApiClientCfgT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsApiClientCfgT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsApiClientCfgT, "tcpChannelCfg", tcpChannelCfg);
c.AUTOCXXPY_DEF_PROPERTY(MdsApiClientCfgT, "qryChannelCfg", qryChannelCfg);
c.AUTOCXXPY_DEF_PROPERTY(MdsApiClientCfgT, "udpL1ChannelCfg", udpL1ChannelCfg);
@ -1063,11 +1217,13 @@ void generate_class_MdsApiClientCfgT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsApiClientCfgT, "udpOrderChannelCfg", udpOrderChannelCfg);
c.AUTOCXXPY_DEF_PROPERTY(MdsApiClientCfgT, "subscribeInfo", subscribeInfo);
AUTOCXXPY_POST_REGISTER_CLASS(MdsApiClientCfgT, c);
m.attr("_MdsApiClientCfg") = c;
}
void generate_class_MdsApiClientEnvT(pybind11::module &m)
{
pybind11::class_<MdsApiClientEnvT> c(m, "MdsApiClientEnvT");
c.def(pybind11::init<>());
if constexpr (std::is_default_constructible_v<MdsApiClientEnvT>)
c.def(pybind11::init<>());
c.AUTOCXXPY_DEF_PROPERTY(MdsApiClientEnvT, "tcpChannel", tcpChannel);
c.AUTOCXXPY_DEF_PROPERTY(MdsApiClientEnvT, "qryChannel", qryChannel);
c.AUTOCXXPY_DEF_PROPERTY(MdsApiClientEnvT, "udpL1Channel", udpL1Channel);
@ -1076,4 +1232,5 @@ void generate_class_MdsApiClientEnvT(pybind11::module &m)
c.AUTOCXXPY_DEF_PROPERTY(MdsApiClientEnvT, "udpOrderChannel", udpOrderChannel);
c.AUTOCXXPY_DEF_PROPERTY(MdsApiClientEnvT, "udpChannelGroup", udpChannelGroup);
AUTOCXXPY_POST_REGISTER_CLASS(MdsApiClientEnvT, c);
m.attr("_MdsApiClientEnv") = c;
}

147
vnpy/api/oes/vnoes/generated_files/module.cpp
View File

@ -646,12 +646,6 @@ void generate_functions(pybind11::module &m)
>,
pybind11::call_guard<pybind11::gil_scoped_release>()
);
m.def("OesApi_WaitOnChannelGroup",
autocxxpy::calling_wrapper_v<
&::OesApi_WaitOnChannelGroup
>,
pybind11::call_guard<pybind11::gil_scoped_release>()
);
m.def("OesApi_SetThreadUsername",
autocxxpy::calling_wrapper_v<
&::OesApi_SetThreadUsername
@ -814,18 +808,6 @@ void generate_functions(pybind11::module &m)
>,
pybind11::call_guard<pybind11::gil_scoped_release>()
);
m.def("MdsApi_SubscribeByString",
autocxxpy::calling_wrapper_v<
&::MdsApi_SubscribeByString
>,
pybind11::call_guard<pybind11::gil_scoped_release>()
);
m.def("MdsApi_SubscribeByStringAndPrefixes",
autocxxpy::calling_wrapper_v<
&::MdsApi_SubscribeByStringAndPrefixes
>,
pybind11::call_guard<pybind11::gil_scoped_release>()
);
m.def("MdsApi_SendHeartbeat",
autocxxpy::calling_wrapper_v<
&::MdsApi_SendHeartbeat
@ -1030,24 +1012,6 @@ void generate_functions(pybind11::module &m)
>,
pybind11::call_guard<pybind11::gil_scoped_release>()
);
m.def("MdsApi_WaitOnTcpChannelGroup",
autocxxpy::calling_wrapper_v<
&::MdsApi_WaitOnTcpChannelGroup
>,
pybind11::call_guard<pybind11::gil_scoped_release>()
);
m.def("MdsApi_WaitOnTcpChannelGroupCompressible",
autocxxpy::calling_wrapper_v<
&::MdsApi_WaitOnTcpChannelGroupCompressible
>,
pybind11::call_guard<pybind11::gil_scoped_release>()
);
m.def("MdsApi_WaitOnUdpChannelGroup",
autocxxpy::calling_wrapper_v<
&::MdsApi_WaitOnUdpChannelGroup
>,
pybind11::call_guard<pybind11::gil_scoped_release>()
);
m.def("MdsApi_SetThreadUsername",
autocxxpy::calling_wrapper_v<
&::MdsApi_SetThreadUsername
@ -2012,6 +1976,32 @@ void generate_constants(pybind11::module &m)
}
void generate_constants_class(pybind11::module &m)
{
struct constants_class{};
pybind11::class_<constants_class> c(m, "constants");
c.attr("OES_APPL_VER_ID") = pybind11::str("0.15.7.4");
c.attr("OES_MIN_APPL_VER_ID") = pybind11::str("0.15.5");
c.attr("OESAPI_CFG_DEFAULT_SECTION") = pybind11::str("oes_client");
c.attr("OESAPI_CFG_DEFAULT_SECTION_LOGGER") = pybind11::str("log");
c.attr("OESAPI_CFG_DEFAULT_KEY_ORD_ADDR") = pybind11::str("ordServer");
c.attr("OESAPI_CFG_DEFAULT_KEY_RPT_ADDR") = pybind11::str("rptServer");
c.attr("OESAPI_CFG_DEFAULT_KEY_QRY_ADDR") = pybind11::str("qryServer");
c.attr("OESAPI_DEFAULT_STRING_DELIM") = pybind11::str(",;| \t\r\n");
c.attr("MDS_APPL_VER_ID") = pybind11::str("0.15.7.4");
c.attr("MDS_MIN_APPL_VER_ID") = pybind11::str("0.15.5");
c.attr("MDSAPI_CFG_DEFAULT_SECTION") = pybind11::str("mds_client");
c.attr("MDSAPI_CFG_DEFAULT_SECTION_LOGGER") = pybind11::str("log");
c.attr("MDSAPI_CFG_DEFAULT_KEY_TCP_ADDR") = pybind11::str("tcpServer");
c.attr("MDSAPI_CFG_DEFAULT_KEY_QRY_ADDR") = pybind11::str("qryServer");
c.attr("MDSAPI_CFG_DEFAULT_KEY_UDP_ADDR_L1") = pybind11::str("udpServer.L1");
c.attr("MDSAPI_CFG_DEFAULT_KEY_UDP_ADDR_L2") = pybind11::str("udpServer.L2");
c.attr("MDSAPI_CFG_DEFAULT_KEY_UDP_ADDR_TICK_TRADE") = pybind11::str("udpServer.TickTrade");
c.attr("MDSAPI_CFG_DEFAULT_KEY_UDP_ADDR_TICK_ORDER") = pybind11::str("udpServer.TickOrder");
c.attr("MDSAPI_DEFAULT_STRING_DELIM") = pybind11::str(",;| \t\r\n");
}
void init_caster(pybind11::module &m)
{
auto c = autocxxpy::caster::bind(m, "cast");
@ -2036,12 +2026,12 @@ void init_caster(pybind11::module &m)
c.def("toOesOrdCnfmT",
&autocxxpy::caster::copy<OesOrdItemT>
);
c.def("to_OesOrdCnfm",
&autocxxpy::caster::copy<OesOrdCnfmT>
);
c.def("toOesOrdItemT",
&autocxxpy::caster::copy<OesOrdItemT>
);
c.def("to_OesOrdCnfm",
&autocxxpy::caster::copy<OesOrdCnfmT>
);
c.def("toOesTrdBaseInfoT",
&autocxxpy::caster::copy<OesTrdBaseInfoT>
);
@ -2051,21 +2041,21 @@ void init_caster(pybind11::module &m)
c.def("toOesTrdCnfmT",
&autocxxpy::caster::copy<OesTrdItemT>
);
c.def("to_OesTrdCnfm",
&autocxxpy::caster::copy<OesTrdCnfmT>
);
c.def("toOesTrdItemT",
&autocxxpy::caster::copy<OesTrdItemT>
);
c.def("to_OesTrdCnfm",
&autocxxpy::caster::copy<OesTrdCnfmT>
);
c.def("toOesLotWinningBaseInfoT",
&autocxxpy::caster::copy<OesLotWinningItemT>
);
c.def("toOesLotWinningItemT",
&autocxxpy::caster::copy<OesLotWinningItemT>
);
c.def("to_OesLotWinningBaseInfo",
&autocxxpy::caster::copy<OesLotWinningBaseInfoT>
);
c.def("toOesLotWinningItemT",
&autocxxpy::caster::copy<OesLotWinningItemT>
);
c.def("toOesFundTrsfBaseInfoT",
&autocxxpy::caster::copy<OesFundTrsfBaseInfoT>
);
@ -2096,12 +2086,12 @@ void init_caster(pybind11::module &m)
c.def("toOesIssueBaseInfoT",
&autocxxpy::caster::copy<OesIssueItemT>
);
c.def("toOesIssueItemT",
&autocxxpy::caster::copy<OesIssueItemT>
);
c.def("to_OesIssueBaseInfo",
&autocxxpy::caster::copy<OesIssueBaseInfoT>
);
c.def("toOesIssueItemT",
&autocxxpy::caster::copy<OesIssueItemT>
);
c.def("toOesPriceLimitT",
&autocxxpy::caster::copy<OesPriceLimitT>
);
@ -2111,12 +2101,12 @@ void init_caster(pybind11::module &m)
c.def("toOesStockBaseInfoT",
&autocxxpy::caster::copy<OesStockItemT>
);
c.def("to_OesStockBaseInfo",
&autocxxpy::caster::copy<OesStockBaseInfoT>
);
c.def("toOesStockItemT",
&autocxxpy::caster::copy<OesStockItemT>
);
c.def("to_OesStockBaseInfo",
&autocxxpy::caster::copy<OesStockBaseInfoT>
);
c.def("toOesEtfBaseInfoT",
&autocxxpy::caster::copy<OesEtfItemT>
);
@ -2135,12 +2125,12 @@ void init_caster(pybind11::module &m)
c.def("toOesOptionBaseInfoT",
&autocxxpy::caster::copy<OesOptionItemT>
);
c.def("toOesOptionItemT",
&autocxxpy::caster::copy<OesOptionItemT>
);
c.def("to_OesOptionBaseInfo",
&autocxxpy::caster::copy<OesOptionBaseInfoT>
);
c.def("toOesOptionItemT",
&autocxxpy::caster::copy<OesOptionItemT>
);
c.def("toOesCashAssetBaseInfoT",
&autocxxpy::caster::copy<OesCashAssetBaseInfoT>
);
@ -2150,12 +2140,12 @@ void init_caster(pybind11::module &m)
c.def("toOesCustBaseInfoT",
&autocxxpy::caster::copy<OesCustItemT>
);
c.def("to_OesCustBaseInfo",
&autocxxpy::caster::copy<OesCustBaseInfoT>
);
c.def("toOesCustItemT",
&autocxxpy::caster::copy<OesCustItemT>
);
c.def("to_OesCustBaseInfo",
&autocxxpy::caster::copy<OesCustBaseInfoT>
);
c.def("toOesInvAcctBaseInfoT",
&autocxxpy::caster::copy<OesInvAcctBaseInfoT>
);
@ -2300,12 +2290,12 @@ void init_caster(pybind11::module &m)
c.def("toOesQryStkHoldingFilterT",
&autocxxpy::caster::copy<OesQryOptHoldingFilterT>
);
c.def("to_OesQryStkHoldingFilter",
&autocxxpy::caster::copy<OesQryStkHoldingFilterT>
);
c.def("toOesQryOptHoldingFilterT",
&autocxxpy::caster::copy<OesQryOptHoldingFilterT>
);
c.def("to_OesQryStkHoldingFilter",
&autocxxpy::caster::copy<OesQryStkHoldingFilterT>
);
c.def("toOesStkHoldingItemT",
&autocxxpy::caster::copy<OesStkHoldingItemT>
);
@ -2732,50 +2722,50 @@ void init_caster(pybind11::module &m)
c.def("toSGeneralClientChannelT",
&autocxxpy::caster::copy<MdsApiSessionInfoT>
);
c.def("toOesApiSessionInfoT",
&autocxxpy::caster::copy<OesApiSessionInfoT>
c.def("toMdsApiSessionInfoT",
&autocxxpy::caster::copy<MdsApiSessionInfoT>
);
c.def("to_SGeneralClientChannel",
&autocxxpy::caster::copy<SGeneralClientChannelT>
);
c.def("toMdsApiSessionInfoT",
&autocxxpy::caster::copy<MdsApiSessionInfoT>
c.def("toOesApiSessionInfoT",
&autocxxpy::caster::copy<OesApiSessionInfoT>
);
c.def("toSGeneralClientChannelGroupT",
&autocxxpy::caster::copy<MdsApiChannelGroupT>
);
c.def("toOesApiChannelGroupT",
&autocxxpy::caster::copy<OesApiChannelGroupT>
);
c.def("to_SGeneralClientChannelGroup",
&autocxxpy::caster::copy<SGeneralClientChannelGroupT>
);
c.def("toOesApiChannelGroupT",
&autocxxpy::caster::copy<OesApiChannelGroupT>
);
c.def("toMdsApiChannelGroupT",
&autocxxpy::caster::copy<MdsApiChannelGroupT>
);
c.def("toSGeneralClientAddrInfoT",
&autocxxpy::caster::copy<MdsApiAddrInfoT>
);
c.def("to_SGeneralClientAddrInfo",
&autocxxpy::caster::copy<SGeneralClientAddrInfoT>
c.def("toMdsApiAddrInfoT",
&autocxxpy::caster::copy<MdsApiAddrInfoT>
);
c.def("toOesApiAddrInfoT",
&autocxxpy::caster::copy<OesApiAddrInfoT>
);
c.def("toMdsApiAddrInfoT",
&autocxxpy::caster::copy<MdsApiAddrInfoT>
c.def("to_SGeneralClientAddrInfo",
&autocxxpy::caster::copy<SGeneralClientAddrInfoT>
);
c.def("toSGeneralClientRemoteCfgT",
&autocxxpy::caster::copy<MdsApiRemoteCfgT>
);
c.def("toOesApiRemoteCfgT",
&autocxxpy::caster::copy<OesApiRemoteCfgT>
c.def("to_SGeneralClientRemoteCfg",
&autocxxpy::caster::copy<SGeneralClientRemoteCfgT>
);
c.def("toMdsApiRemoteCfgT",
&autocxxpy::caster::copy<MdsApiRemoteCfgT>
);
c.def("to_SGeneralClientRemoteCfg",
&autocxxpy::caster::copy<SGeneralClientRemoteCfgT>
c.def("toOesApiRemoteCfgT",
&autocxxpy::caster::copy<OesApiRemoteCfgT>
);
c.def("toOesApiSubscribeInfoT",
&autocxxpy::caster::copy<OesApiSubscribeInfoT>
@ -2906,12 +2896,12 @@ void init_caster(pybind11::module &m)
c.def("toMdsQryMktDataSnapshotReqT",
&autocxxpy::caster::copy<MdsQrySecurityStatusReqT>
);
c.def("to_MdsQryMktDataSnapshotReq",
&autocxxpy::caster::copy<MdsQryMktDataSnapshotReqT>
);
c.def("toMdsQrySecurityStatusReqT",
&autocxxpy::caster::copy<MdsQrySecurityStatusReqT>
);
c.def("to_MdsQryMktDataSnapshotReq",
&autocxxpy::caster::copy<MdsQryMktDataSnapshotReqT>
);
c.def("toMdsQryTrdSessionStatusReqT",
&autocxxpy::caster::copy<MdsQryTrdSessionStatusReqT>
);
@ -3018,6 +3008,7 @@ PYBIND11_MODULE(vnoes, m)
generate_classes(m);
generate_functions(m);
generate_constants(m);
generate_constants_class(m);
generate_enums(m);
init_caster(m);

466
vnpy/api/oes/vnoes/generated_files/vnoes.pyi
View File

File diff suppressed because it is too large Load Diff