├── .gitignore ├── .gitmodules ├── README.md ├── include └── qluacpp │ ├── api │ ├── extended │ └── qlua ├── src └── qlua │ ├── api.hpp │ ├── api │ ├── bitmask.hpp │ ├── charts.hpp │ ├── current_trades_receive.hpp │ ├── current_trades_request.hpp │ ├── labels.hpp │ ├── level2_quotes.hpp │ ├── macros.h │ ├── securities.hpp │ ├── service.hpp │ ├── table.hpp │ ├── table_data.hpp │ └── workplace.hpp │ ├── callbacks.hpp │ ├── extended.hpp │ ├── extended │ ├── api_overloads │ │ ├── charts.hpp │ │ ├── current_trades_receive.hpp │ │ ├── current_trades_request.hpp │ │ ├── level2_quotes.hpp │ │ ├── securities.hpp │ │ ├── service.hpp │ │ ├── table.hpp │ │ ├── table_data.hpp │ │ └── workplace.hpp │ └── quik_thread_safe.hpp │ └── structs │ ├── datasource.hpp │ ├── datetime.hpp │ ├── function_results.hpp │ ├── level2_quotes.hpp │ └── standalone.hpp └── test ├── CMakeLists.txt └── qluacpp_test.cpp /.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "contrib/luacpp"] 2 | path = contrib/luacpp 3 | url = https://github.com/elelel/luacpp 4 | branch = master 5 | 6 | [submodule "contrib/Catch"] 7 | path = contrib/Catch 8 | url = https://github.com/philsquared/Catch.git 9 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # QluaCpp 2 | 3 | C++ interface for Quik trading terminal via Lua bindings 4 | 5 | Интерфейс для написания на C++ плагинов к торговому терминалу Quik через байндинги Lua 6 | 7 | ```c++ 8 | // ... 9 | #include 10 | 11 | static struct luaL_reg ls_lib[] = { 12 | { NULL, NULL } 13 | }; 14 | 15 | void my_main(lua::state& l) { 16 | qlua::api q(l); 17 | std::string name; 18 | q.getSecurityInfo("TQBR", "SBER", 19 | [&name] (const auto& sec_info) { // C++14 style lambda 20 | name = sec_info().name(); 21 | return 1; // How many stack items should be cleaned up (poped) 22 | }); 23 | std::string text = "qluacpp: Hello, world! Ticker's SBER name is " + name; 24 | q.message(msg.c_str()); 25 | } 26 | 27 | LUACPP_STATIC_FUNCTION2(main, my_main) 28 | 29 | extern "C" { 30 | LUALIB_API int luaopen_lualib_hello(lua_State *L) { 31 | lua::state l(L); 32 | 33 | ::lua::function::main().register_in_lua(l, my_main); 34 | 35 | luaL_openlib(L, "lualib_hello", ls_lib, 0); 36 | return 0; 37 | } 38 | } 39 | ``` 40 | 41 | ## Преимущества 42 | - Позволяет писать плагины к терминалу Quik на типизированном языке с развитой экосистемой 43 | и избежать программирования на сложном для отладке языке Lua 44 | - Предельная быстрота: в отличие от других интерфейсов к Quik данные не пересылаются и в 45 | большинстве случаев даже не копируются, чтение осуществляется непосредственно через ссылки 46 | на память терминала. В ряде случаев даже быстрее, чем доступ через встроенный интерпретатор 47 | Lua (благодаря C-интерфейсу к API Lua, предоставляющему больше возможностей, чем языковые средства). 48 | 49 | ## Requirements / Требования 50 | 51 | - Lua 5.1 or Lua 5.3 library (depending on target Quik) 52 | - C++17-compliant compiler (C++17 compliant, tested with VS 2017 15.0) 53 | 54 | ## Usage example / Пример использования 55 | 56 | See [tutorials](https://github.com/elelel/qluacpp-tutorial) for code examples, as well as step by step instruction for creating qluacpp projects. 57 | 58 | [Примеры](https://github.com/elelel/qluacpp-tutorial) содержат пошаговые инструкции и исходные коды небольших плагинов 59 | 60 | ## License / Лицензия 61 | 62 | GPL v3.0. 63 | 64 | Distribute your source code if you distribute the binaries. 65 | 66 | Если распространяете бинарники, прилагайте и исходный код. 67 | 68 | -------------------------------------------------------------------------------- /include/qluacpp/api: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../src/qlua/api.hpp" -------------------------------------------------------------------------------- /include/qluacpp/extended: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "api" 4 | #include "../../src/qlua/extended.hpp" -------------------------------------------------------------------------------- /include/qluacpp/qlua: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "api" 4 | #include "extended" 5 | -------------------------------------------------------------------------------- /src/qlua/api.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | 7 | #include "api/macros.h" 8 | #include "structs/datetime.hpp" 9 | #include "structs/standalone.hpp" 10 | #include "structs/function_results.hpp" 11 | #include "structs/datasource.hpp" 12 | #include "structs/level2_quotes.hpp" 13 | #include "callbacks.hpp" 14 | 15 | // TODO: type policies in numeric_tuples.hpp 16 | 17 | namespace qlua { 18 | struct api { 19 | typedef api type; 20 | api(const lua::state& l) : 21 | l_(l) { 22 | } 23 | 24 | api(const type& other) : 25 | l_(other.l_) { 26 | } 27 | 28 | api(type&& other) : 29 | l_(std::move(other.l_)) { 30 | } 31 | 32 | void swap(type& other) { 33 | std::swap(l_, other.l_); 34 | } 35 | 36 | type& operator=(const type& other) { 37 | type tmp(other); 38 | swap(tmp); 39 | return *this; 40 | } 41 | 42 | template 43 | Constant constant(const char* name) const { 44 | l_.getglobal(name); 45 | if (!l_.isnil(-1)) { 46 | auto rslt = l_.at(-1).get(); 47 | l_.pop(1); 48 | return rslt; 49 | } else { 50 | l_.pop(1); 51 | throw std::runtime_error("QluaCpp error: QLua constant " + std::string(name) + " is nil in globals list"); 52 | } 53 | } 54 | 55 | const lua::state& lua_state() const { 56 | return l_; 57 | } 58 | 59 | // Service "Сервисные функции" 60 | #include "api/service.hpp" 61 | // Table data access Функции для обращения к строкам произвольных таблиц QUIK 62 | #include "api/table_data.hpp" 63 | // Securities "Функции для обращения к спискам доступных параметров" 64 | #include "api/securities.hpp" 65 | // Workplace "Функции взаимодействия скрипта Lua и Рабочего места QUIK" 66 | #include "api/workplace.hpp" 67 | // Current trades receive "Функции получения значений Таблицы текущих торгов" 68 | #include "api/current_trades_receive.hpp" 69 | // Charts "Функции для работы с графиками" 70 | #include "api/charts.hpp" 71 | // Table manipulations "Функции для работы с таблицами Рабочего места QUIK" 72 | #include "api/table.hpp" 73 | // "Функции для работы с метками" 74 | #include "api/labels.hpp" 75 | // Level 2 quotes "Функции для заказа стакана котировок" 76 | #include "api/level2_quotes.hpp" 77 | // Current trades request Функции для заказа параметров Таблицы текущих торгов 78 | #include "api/current_trades_request.hpp" 79 | // Bitmask Функции для работы с битовыми масками в структурах данных 80 | #include "api/bitmask.hpp" 81 | 82 | protected: 83 | lua::state l_; 84 | }; 85 | } 86 | -------------------------------------------------------------------------------- /src/qlua/api/bitmask.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | -------------------------------------------------------------------------------- /src/qlua/api/charts.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // getLinesCount - Функция предназначена для получения количества линий в графике (индикаторе) по выбранному идентификатору. 4 | QLUACPP_DETAIL_API_FUNCTION4(unsigned int, 5 | getLinesCount, 6 | const char*, tag) 7 | // getNumCandles - Функция предназначена для получения информации о количестве свечек по выбранному идентификатору. 8 | QLUACPP_DETAIL_API_FUNCTION4(unsigned int, 9 | getNumCandles, 10 | const char*, tag) 11 | 12 | // getCandlesByIndex - Функция предназначена для получения информации о свечках по идентификатору 13 | void getCandlesByIndex(const char* tag, // строковый идентификатор графика или индикатора 14 | unsigned int line, // номер линии графика или индикатора. Первая линия имеет номер 0 15 | unsigned int first_candle, // индекс первой свечки. Первая (самая левая) свечка имеет индекс 0 16 | unsigned int count, // количество запрашиваемых свечек 17 | std::function>&, // структура (lua-таблица) со свечкой 19 | const unsigned int index, // индекс свечки 20 | const ::lua::entity<::lua::type_policy>&, // количество свечек в таблице t 21 | const ::lua::entity<::lua::type_policy>& // легенда (подпись) графика 22 | )> lambda 23 | ) const { 24 | auto f = [&lambda] (const ::lua::state& s) { 25 | unsigned int len = s.objlen(-3); 26 | for (unsigned int i = 0; i < len; ++i) { 27 | s.rawgeti(-3, i + 1); 28 | const auto& t = s.at<::qlua::table::candle>(-1); 29 | const auto& l = s.at(-2); 30 | const auto& n = s.at(-3); 31 | lambda(t, i, n, l); 32 | s.pop(); // pop candle 33 | } 34 | return 3; 35 | }; 36 | l_.call_and_apply(f, 3, "getCandlesByIndex", tag, line, first_candle, count); 37 | } 38 | 39 | 40 | // CreateDataSource - Функция предназначена для создания таблицы Lua и позволяет работать со свечками, полученными с сервера QUIK, а также реагировать на их изменение. 41 | ::qlua::data_source CreateDataSource(const char* class_code, 42 | const char* sec_code, 43 | unsigned int interval, 44 | const char* param = nullptr) const { 45 | return ::qlua::data_source(l_, class_code, sec_code, interval, param); 46 | } 47 | 48 | -------------------------------------------------------------------------------- /src/qlua/api/current_trades_receive.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // getParamEx - Функция предназначена для получения значений всех параметров биржевой информации из Таблицы текущих торгов. 4 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY8(::qlua::table::current_trades_getParamEx, 5 | getParamEx, 6 | const char*, class_code, 7 | const char*, sec_code, 8 | const char*, param_name 9 | ) 10 | // getParamEx2 - Функция предназначена для получения значений всех параметров биржевой информации из Таблицы текущих торгов с возможностью в дальнейшем отказаться от получения определенных параметров, заказанных с помощью функции ParamRequest. 11 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY8(::qlua::table::current_trades_getParamEx, 12 | getParamEx2, 13 | const char*, class_code, // код класса; 14 | const char*, sec_code, // код бумаги; 15 | const char*, param_name // код параметра. 16 | ) 17 | -------------------------------------------------------------------------------- /src/qlua/api/current_trades_request.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // ParamRequest - заказывает получение параметров Таблицы текущих торгов. 4 | QLUACPP_DETAIL_API_FUNCTION8(bool, // В случае успешного завершения функция возвращает «true», иначе – «false». 5 | ParamRequest, 6 | const char*, class_code, // код класса; 7 | const char*, sec_code, // код бумаги; 8 | const char*, db_name // код параметра 9 | ) 10 | // CancelParamRequest - отменяет заказ на получение параметров Таблицы текущих торгов. 11 | QLUACPP_DETAIL_API_FUNCTION8(bool, // В случае успешного завершения функция возвращает «true», иначе – «false». 12 | CancelParamRequest, 13 | const char*, class_code, // код класса; 14 | const char*, sec_code, // код бумаги; 15 | const char*, db_name // код параметра. 16 | ) 17 | 18 | -------------------------------------------------------------------------------- /src/qlua/api/labels.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // AddLabel - добавляет метку с заданными параметрами 4 | // DelLabel - удаляет метку с заданными параметрами 5 | // DelAllLabels - удаляет все метки на диаграмме с указанным графиком 6 | // GetLabelParams - позволяет получить параметры метки 7 | // SetLabelParams - задает параметры для метки с указанным идентификатором 8 | -------------------------------------------------------------------------------- /src/qlua/api/level2_quotes.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // Subscribe_Level_II_Quotes - заказывает на сервер получение стакана по указанному классу и бумаге. 4 | QLUACPP_DETAIL_API_FUNCTION6(bool, // В случае успешного завершения функция возвращает «true». 5 | Subscribe_Level_II_Quotes, 6 | const char*, class_code, // код класса; 7 | const char*, sec_code // код бумаги. 8 | ) 9 | // Unsubscribe_Level_II_Quotes - отменяет заказ на получение с сервера стакана по указанному классу и бумаге. 10 | QLUACPP_DETAIL_API_FUNCTION6(bool, // В случае успешного завершения функция возвращает «true». 11 | Unsubscribe_Level_II_Quotes, 12 | const char*, class_code, // код класса; 13 | const char*, sec_code // код бумаги. 14 | ) 15 | // IsSubscribed_Level_II_Quotes - позволяет узнать, заказан ли с сервера стакан по указанному классу и бумаге. 16 | QLUACPP_DETAIL_API_FUNCTION6(bool, // Функция возвращает «true», если стакан по классу class_code и бумаге sec_code уже заказан. 17 | IsSubscribed_Level_II_Quotes, 18 | const char*, class_code, // код класса; 19 | const char*, sec_code // код бумаги. 20 | ) 21 | -------------------------------------------------------------------------------- /src/qlua/api/macros.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define QLUACPP_DETAIL_API_FUNCTION2(RETURN_TYPE, NAME) \ 4 | RETURN_TYPE NAME() const { \ 5 | typedef RETURN_TYPE bare_return_type; \ 6 | typedef std::tuple return_type; \ 7 | return std::get<0>(l_.call(#NAME)); \ 8 | } \ 9 | 10 | #define QLUACPP_DETAIL_API_FUNCTION4(RETURN_TYPE, NAME, \ 11 | ARG1_TYPE, ARG1) \ 12 | RETURN_TYPE NAME(ARG1_TYPE ARG1) const { \ 13 | typedef RETURN_TYPE bare_return_type; \ 14 | typedef std::tuple return_type; \ 15 | return std::get<0>(l_.call(#NAME, ARG1)); \ 16 | } \ 17 | 18 | #define QLUACPP_DETAIL_API_FUNCTION6(RETURN_TYPE, NAME, \ 19 | ARG1_TYPE, ARG1, \ 20 | ARG2_TYPE, ARG2) \ 21 | RETURN_TYPE NAME(ARG1_TYPE ARG1, ARG2_TYPE ARG2) const { \ 22 | typedef std::tuple return_type; \ 23 | return std::get<0>(l_.call(#NAME, \ 24 | ARG1, \ 25 | ARG2 \ 26 | )); \ 27 | } \ 28 | 29 | #define QLUACPP_DETAIL_API_FUNCTION8(RETURN_TYPE, NAME, \ 30 | ARG1_TYPE, ARG1, \ 31 | ARG2_TYPE, ARG2, \ 32 | ARG3_TYPE, ARG3) \ 33 | RETURN_TYPE NAME(ARG1_TYPE ARG1, ARG2_TYPE ARG2, \ 34 | ARG3_TYPE ARG3) const { \ 35 | typedef std::tuple return_type; \ 36 | return std::get<0>(l_.call(#NAME, \ 37 | ARG1, \ 38 | ARG2, \ 39 | ARG3 \ 40 | )); \ 41 | } \ 42 | 43 | #define QLUACPP_DETAIL_API_FUNCTION10(RETURN_TYPE, NAME, \ 44 | ARG1_TYPE, ARG1, \ 45 | ARG2_TYPE, ARG2, \ 46 | ARG3_TYPE, ARG3, \ 47 | ARG4_TYPE, ARG4) \ 48 | RETURN_TYPE NAME(ARG1_TYPE ARG1, \ 49 | ARG2_TYPE ARG2, \ 50 | ARG3_TYPE ARG3, \ 51 | ARG4_TYPE ARG4) const { \ 52 | typedef std::tuple return_type; \ 53 | return std::get<0>(l_.call(#NAME, \ 54 | ARG1, \ 55 | ARG2, \ 56 | ARG3, \ 57 | ARG4)); \ 58 | } \ 59 | 60 | 61 | #define QLUACPP_DETAIL_API_FUNCTION12(RETURN_TYPE, NAME, \ 62 | ARG1_TYPE, ARG1, \ 63 | ARG2_TYPE, ARG2, \ 64 | ARG3_TYPE, ARG3, \ 65 | ARG4_TYPE, ARG4, \ 66 | ARG5_TYPE, ARG5) \ 67 | RETURN_TYPE NAME(ARG1_TYPE ARG1, \ 68 | ARG2_TYPE ARG2, \ 69 | ARG3_TYPE ARG3, \ 70 | ARG4_TYPE ARG4, \ 71 | ARG5_TYPE ARG5) const { \ 72 | typedef std::tuple return_type; \ 73 | return std::get<0>(l_.call(#NAME, \ 74 | ARG1, \ 75 | ARG2, \ 76 | ARG3, \ 77 | ARG4, \ 78 | ARG5)); \ 79 | } \ 80 | 81 | #define QLUACPP_DETAIL_API_FUNCTION14(RETURN_TYPE, NAME, \ 82 | ARG1_TYPE, ARG1, \ 83 | ARG2_TYPE, ARG2, \ 84 | ARG3_TYPE, ARG3, \ 85 | ARG4_TYPE, ARG4, \ 86 | ARG5_TYPE, ARG5, \ 87 | ARG6_TYPE, ARG6) \ 88 | RETURN_TYPE NAME(ARG1_TYPE ARG1, \ 89 | ARG2_TYPE ARG2, \ 90 | ARG3_TYPE ARG3, \ 91 | ARG4_TYPE ARG4, \ 92 | ARG5_TYPE ARG5, \ 93 | ARG6_TYPE ARG6) const { \ 94 | typedef std::tuple return_type; \ 95 | return std::get<0>(l_.call(#NAME, \ 96 | ARG1, \ 97 | ARG2, \ 98 | ARG3, \ 99 | ARG4, \ 100 | ARG5, \ 101 | ARG6)); \ 102 | } \ 103 | 104 | #define QLUACPP_DETAIL_API_FUNCTION16(RETURN_TYPE, NAME, \ 105 | ARG1_TYPE, ARG1, \ 106 | ARG2_TYPE, ARG2, \ 107 | ARG3_TYPE, ARG3, \ 108 | ARG4_TYPE, ARG4, \ 109 | ARG5_TYPE, ARG5, \ 110 | ARG6_TYPE, ARG6, \ 111 | ARG7_TYPE, ARG7) \ 112 | RETURN_TYPE NAME(ARG1_TYPE ARG1, \ 113 | ARG2_TYPE ARG2, \ 114 | ARG3_TYPE ARG3, \ 115 | ARG4_TYPE ARG4, \ 116 | ARG5_TYPE ARG5, \ 117 | ARG6_TYPE ARG6, \ 118 | ARG7_TYPE ARG7) const { \ 119 | typedef std::tuple return_type; \ 120 | return std::get<0>(l_.call(#NAME, \ 121 | ARG1, \ 122 | ARG2, \ 123 | ARG3, \ 124 | ARG4, \ 125 | ARG5, \ 126 | ARG6, \ 127 | ARG7)); \ 128 | } \ 129 | 130 | 131 | #define QLUACPP_DETAIL_API_FUNCTION_VOID3(NAME, \ 132 | ARG1_TYPE, ARG1) \ 133 | void NAME(ARG1_TYPE ARG1) const { \ 134 | l_.call>(#NAME, ARG1); \ 135 | } \ 136 | 137 | 138 | #define QLUACPP_DETAIL_API_FUNCTION_TUPLE2_5(T1, T2, NAME, \ 139 | ARG1_TYPE, ARG1) \ 140 | std::tuple NAME(ARG1_TYPE ARG1) const { \ 141 | typedef std::tuple return_type; \ 142 | return l_.call(#NAME, ARG1); \ 143 | } \ 144 | 145 | #define QLUACPP_DETAIL_API_FUNCTION_TUPLE2_17(T1, T2, NAME, \ 146 | ARG1_TYPE, ARG1, \ 147 | ARG2_TYPE, ARG2, \ 148 | ARG3_TYPE, ARG3, \ 149 | ARG4_TYPE, ARG4, \ 150 | ARG5_TYPE, ARG5, \ 151 | ARG6_TYPE, ARG6, \ 152 | ARG7_TYPE, ARG7 \ 153 | ) \ 154 | std::tuple NAME(ARG1_TYPE ARG1, \ 155 | ARG2_TYPE ARG2, \ 156 | ARG3_TYPE ARG3, \ 157 | ARG4_TYPE ARG4, \ 158 | ARG5_TYPE ARG5, \ 159 | ARG6_TYPE ARG6, \ 160 | ARG7_TYPE ARG7 \ 161 | ) const { \ 162 | typedef std::tuple return_type; \ 163 | return l_.call(#NAME, \ 164 | ARG1, \ 165 | ARG2, \ 166 | ARG3, \ 167 | ARG4, \ 168 | ARG5, \ 169 | ARG6, \ 170 | ARG7 \ 171 | ); \ 172 | } \ 173 | 174 | 175 | #define QLUACPP_DETAIL_API_FUNCTION_TUPLE4_7(T1, T2, T3, T4, NAME, \ 176 | ARG1_TYPE, ARG1) \ 177 | std::tuple NAME(ARG1_TYPE ARG1) const { \ 178 | typedef std::tuple return_type; \ 179 | return l_.call(#NAME, ARG1); \ 180 | } \ 181 | 182 | 183 | #define QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY2( RETURN_TYPE, NAME) \ 184 | void NAME(std::function>&)> lambda) const { \ 185 | auto f = [&lambda] (const ::lua::state& s) { \ 186 | auto v = s.at(-1); \ 187 | lambda(v); \ 188 | return 1; \ 189 | }; \ 190 | l_.call_and_apply(f, 1, #NAME); \ 191 | } \ 192 | 193 | #define QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY4( RETURN_TYPE, NAME, \ 194 | ARG1_TYPE, ARG1) \ 195 | void NAME(ARG1_TYPE ARG1, \ 196 | std::function>&)> lambda) const { \ 197 | auto f = [&lambda] (const ::lua::state& s) { \ 198 | auto v = s.at(-1); \ 199 | lambda(v); \ 200 | return 1; \ 201 | }; \ 202 | l_.call_and_apply(f, 1, #NAME, ARG1); \ 203 | } \ 204 | 205 | 206 | #define QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY6( RETURN_TYPE, NAME, \ 207 | ARG1_TYPE, ARG1, \ 208 | ARG2_TYPE, ARG2) \ 209 | void NAME(ARG1_TYPE ARG1, ARG2_TYPE ARG2, \ 210 | std::function>&)> lambda) const { \ 211 | auto f = [&lambda] (const ::lua::state& s) { \ 212 | auto v = s.at(-1); \ 213 | lambda(v); \ 214 | return 1; \ 215 | }; \ 216 | l_.call_and_apply(f, 1, #NAME, ARG1, ARG2); \ 217 | } \ 218 | 219 | #define QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY8( RETURN_TYPE, NAME, \ 220 | ARG1_TYPE, ARG1, \ 221 | ARG2_TYPE, ARG2, \ 222 | ARG3_TYPE, ARG3) \ 223 | void NAME(ARG1_TYPE ARG1, ARG2_TYPE ARG2, ARG3_TYPE ARG3, \ 224 | std::function>&)> lambda) const { \ 225 | auto f = [&lambda] (const ::lua::state& s) { \ 226 | auto v = s.at(-1); \ 227 | lambda(v); \ 228 | return 1; \ 229 | }; \ 230 | l_.call_and_apply(f, 1, #NAME, ARG1, ARG2, ARG3); \ 231 | } \ 232 | 233 | #define QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY10( RETURN_TYPE, NAME, \ 234 | ARG1_TYPE, ARG1, \ 235 | ARG2_TYPE, ARG2, \ 236 | ARG3_TYPE, ARG3, \ 237 | ARG4_TYPE, ARG4) \ 238 | void NAME(ARG1_TYPE ARG1, ARG2_TYPE ARG2, ARG3_TYPE ARG3, \ 239 | ARG4_TYPE ARG4, \ 240 | std::function>&)> lambda) const { \ 241 | auto f = [&lambda] (const ::lua::state& s) { \ 242 | auto v = s.at(-1); \ 243 | lambda(v); \ 244 | return 1; \ 245 | }; \ 246 | l_.call_and_apply(f, 1, #NAME, ARG1, ARG2, ARG3, ARG4); \ 247 | } \ 248 | 249 | #define QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY12( RETURN_TYPE, NAME, \ 250 | ARG1_TYPE, ARG1, \ 251 | ARG2_TYPE, ARG2, \ 252 | ARG3_TYPE, ARG3, \ 253 | ARG4_TYPE, ARG4, \ 254 | ARG5_TYPE, ARG5) \ 255 | void NAME(ARG1_TYPE ARG1, ARG2_TYPE ARG2, ARG3_TYPE ARG3, \ 256 | ARG4_TYPE ARG4, ARG5_TYPE ARG5, \ 257 | std::function>&)> lambda) const { \ 258 | auto f = [&lambda] (const ::lua::state& s) { \ 259 | auto v = s.at(-1); \ 260 | lambda(v); \ 261 | return 1; \ 262 | }; \ 263 | l_.call_and_apply(f, 1, #NAME, ARG1, ARG2, ARG3, ARG4, ARG5); \ 264 | } \ 265 | 266 | -------------------------------------------------------------------------------- /src/qlua/api/securities.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../structs/function_results.hpp" 4 | 5 | // getClassesList - функция для получения списка кодов классов, полученных с сервера в ходе сеанса связи 6 | QLUACPP_DETAIL_API_FUNCTION2(const char*, getClassesList) 7 | // getClassInfo - функция для получения информации о классе 8 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY4(::qlua::table::class_info_getClassInfo, 9 | getClassInfo, 10 | const char*, class_name 11 | ) 12 | 13 | // getClassSecurities - функция для получения списка кодов бумаг для списка классов, заданного списком кодов 14 | QLUACPP_DETAIL_API_FUNCTION4(const char*, 15 | getClassSecurities, 16 | const char*, class_name) 17 | 18 | -------------------------------------------------------------------------------- /src/qlua/api/service.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // This file should be included only from qlua.hpp 4 | 5 | // isConnected - определяет состояние подключения клиентского места к серверу 6 | QLUACPP_DETAIL_API_FUNCTION2(unsigned int, // Возвращает «1», если клиентское место подключено и «0», если не подключено. 7 | isConnected) 8 | // getScriptPath - возвращает путь, по которому находится запускаемый скрипт 9 | QLUACPP_DETAIL_API_FUNCTION2(const char*, // Функция возвращает путь, по которому находится запускаемый скрипт 10 | getScriptPath) 11 | // getInfoParam - позволяет получить параметры для информационного окна (Система / О программе / Информационное окно…) 12 | QLUACPP_DETAIL_API_FUNCTION4(const char*, // Функция возвращает значения параметров информационного окна 13 | getInfoParam, 14 | const char*, param_name /* Параметр «param_name» может принимать значения, представленные в таблице. 15 | Значение параметра Описание 16 | VERSION Версия программы 17 | TRADEDATE Дата торгов 18 | SERVERTIME Время сервера 19 | LASTRECORDTIME Время последней записи 20 | NUMRECORDS Число записей 21 | LASTRECORD Последняя запись 22 | LATERECORD Отставшая запись 23 | CONNECTION Соединение 24 | IPADDRESS IP-адрес сервера 25 | IPPORT Порт сервера 26 | IPCOMMENT Описание соединения 27 | SERVER Описание сервера 28 | SESSIONID Идентификатор сессии 29 | USER Пользователь 30 | USERID ID пользователя 31 | ORG Организация 32 | MEMORY Занято памяти 33 | LOCALTIME Текущее время 34 | CONNECTIONTIME Время на связи 35 | MESSAGESSENT Передано сообщений 36 | ALLSENT Передано всего байт 37 | BYTESSENT Передано полезных байт 38 | BYTESPERSECSENT Передано за секунду 39 | MESSAGESRECV Принято сообщений 40 | BYTESRECV Принято полезных байт 41 | ALLRECV Принято всего байт 42 | BYTESPERSECRECV Принято за секунду 43 | AVGSENT Средняя скорость передачи 44 | AVGRECV Средняя скорость приема 45 | LASTPINGTIME Время последней проверки связи 46 | LASTPINGDURATION Задержка данных при обмене с сервером 47 | AVGPINGDURATION Средняя задержка данных 48 | MAXPINGTIME Время максимальной задержки 49 | MAXPINGDURATION Максимальная задержка данных 50 | */ 51 | ) 52 | // message - отображает сообщения в терминале QUIK 53 | QLUACPP_DETAIL_API_FUNCTION6(unsigned int, // Возвращает «nil» при ошибке выполнения или при обнаружении ошибки во входных параметрах. В остальных случаях возвращает «1». 54 | message, 55 | const char*, text, // Строка, отображаемая в окне сообщений терминала QUIK 56 | const unsigned int, icon_type) 57 | // message - отображает сообщения в терминале QUIK 58 | QLUACPP_DETAIL_API_FUNCTION4(unsigned int, // Возвращает «nil» при ошибке выполнения или при обнаружении ошибки во входных параметрах. В остальных случаях возвращает «1». 59 | message, 60 | const char*, text // Строка, отображаемая в окне сообщений терминала QUIK 61 | ) 62 | // sleep - приостанавливает выполнение кода скрипта 63 | QLUACPP_DETAIL_API_FUNCTION4(unsigned int, // Время, на которое приостанавливается выполнение, в миллисекундах 64 | sleep, 65 | int, time // Время, на которое приостанавливается выполнение, в миллисекундах 66 | ) 67 | // getWorkingFolder - возвращает путь, по которому находится файл info.exe, исполняющий скрипт 68 | QLUACPP_DETAIL_API_FUNCTION2(const char*, getWorkingFolder) 69 | // PrintDbgStr - для вывода отладочной информации 70 | QLUACPP_DETAIL_API_FUNCTION_VOID3(PrintDbgStr, 71 | const char*, s) 72 | 73 | -------------------------------------------------------------------------------- /src/qlua/api/table.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // AddColumn - добавляет колонки в таблицу 4 | QLUACPP_DETAIL_API_FUNCTION14(unsigned int, // Функция возвращает «1», если колонка в таблицу добавлена, иначе – «0». 5 | AddColumn, 6 | const unsigned int, t_id, 7 | const unsigned int, iCode, // код параметра, выводимого в колонке 8 | const char*, name, // название колонки 9 | const bool, is_default, // параметр не используется 10 | const unsigned int, par_type, /* тип данных в колонке, одна из следующих констант: 11 | QTABLE_INT_TYPE – целое число, 12 | QTABLE_DOUBLE_TYPE – число с плавающей точкой, 13 | QTABLE_INT64_TYPE – 64-битное целое число, 14 | QTABLE_CACHED_STRING_TYPE – кэшируемая строка, 15 | QTABLE_TIME_TYPE – время, 16 | QTABLE_DATE_TYPE – дата, 17 | QTABLE_STRING_TYPE – строка */ 18 | const unsigned int, width // ширина в условных единицах 19 | ) 20 | 21 | // AllocTable - создает структуру, описывающую таблицу 22 | QLUACPP_DETAIL_API_FUNCTION2(unsigned int, // Функция возвращает целочисленный идентификатор таблицы, предназначенный для совершения с ней дальнейших операций. 23 | AllocTable 24 | ) 25 | // Clear - удаляет содержимое таблицы 26 | QLUACPP_DETAIL_API_FUNCTION4(bool, // Функция возвращает «true» в случае успешного завершения, иначе – «false». 27 | Clear, 28 | const unsigned int, t_id 29 | ) 30 | 31 | // CreateWindow - создает окно таблицы 32 | QLUACPP_DETAIL_API_FUNCTION4(unsigned int, // Функция возвращает «1» при успешном создании окна, иначе – «0». 33 | CreateWindow, 34 | const unsigned int, t_id 35 | ) 36 | 37 | // DeleteRow - удаляет строку из таблицы 38 | QLUACPP_DETAIL_API_FUNCTION6(bool, // В случае успешного выполнения возвращает «true», иначе – «false». 39 | DeleteRow, 40 | const unsigned int, t_id, 41 | const unsigned int, key 42 | ) 43 | // DestroyTable - закрывает окно таблицы 44 | QLUACPP_DETAIL_API_FUNCTION4(bool, // В случае успешного выполнения возвращает «true», иначе – «false». 45 | DestroyTable, 46 | const unsigned int, t_id 47 | ) 48 | // InsertRow - добавляет строку в таблицу 49 | QLUACPP_DETAIL_API_FUNCTION6(int, // Функция возвращает номер добавленной строки при успешном выполнении, иначе – «-1». 50 | InsertRow, 51 | const unsigned int, t_id, 52 | const unsigned int, key 53 | ) 54 | // IsWindowClosed - возвращает «true», если закрыто окно с таблицей 55 | QLUACPP_DETAIL_API_FUNCTION4(bool, // Функция возвращает «nil» в случае неуспешного завершения. 56 | IsWindowClosed, 57 | const unsigned int, t_id 58 | ) 59 | 60 | template 61 | T GetCell(const unsigned int t_id, 62 | const unsigned int key, 63 | const unsigned int code) const { 64 | typedef std::tuple return_type; 65 | return std::get<0>(l_.call(GetCell, t_id, key, code)); 66 | } 67 | 68 | // GetTableSize - получает количество строк и столбцов 69 | QLUACPP_DETAIL_API_FUNCTION_TUPLE2_5(int, int, 70 | GetTableSize, 71 | const unsigned int, t_id 72 | ) 73 | 74 | // GetWindowCaption - получает текущий заголовок окна 75 | QLUACPP_DETAIL_API_FUNCTION4(const char*, 76 | GetWindowCaption, 77 | const unsigned int, t_id 78 | ) 79 | // GetWindowRect - получает координаты верхнего левого и нижнего правого угла окна, содержащего таблицу 80 | QLUACPP_DETAIL_API_FUNCTION_TUPLE4_7(int, int, int, int, // Функция возвращает координаты верхнего левого и нижнего правого угла окна, содержащего таблицу «t_id». 81 | GetWindowRect, 82 | const unsigned int, t_id 83 | ) 84 | 85 | // Highlight - подсвечивает выбранный диапазон ячеек с плавным «затуханием» для таблицы 86 | QLUACPP_DETAIL_API_FUNCTION14(bool, 87 | Highlight, 88 | const unsigned int, t_id, 89 | const unsigned int, row, 90 | const unsigned int, col, 91 | const unsigned int, b_color, // цвет фона 92 | const unsigned int, f_color, // цвет текста 93 | const unsigned int, timeout // время подсветки, в миллисекундах 94 | ) 95 | 96 | // RGB - преобразовывает компоненты RGB в одно число для дальнейшего использования в функции SetColor 97 | QLUACPP_DETAIL_API_FUNCTION8(unsigned int, 98 | RGB, 99 | const unsigned int, red, 100 | const unsigned int, green, 101 | const unsigned int, blue) 102 | 103 | // SetCell - задает значение для ячейки в таблице 104 | QLUACPP_DETAIL_API_FUNCTION10(bool, 105 | SetCell, 106 | const unsigned int, t_id, 107 | const unsigned int, key, 108 | const unsigned int, code, 109 | const char*, text // задает строковое представление значение параметра «value». 110 | ) 111 | 112 | // SetCell - задает значение для ячейки в таблице 113 | QLUACPP_DETAIL_API_FUNCTION12(bool, 114 | SetCell, 115 | const unsigned int, t_id, 116 | const unsigned int, key, 117 | const unsigned int, code, 118 | const char*, text, // задает строковое представление значение параметра «value». 119 | const double, value // Параметр «value» необязательный и по умолчанию равен «0». Для столбцов со строковыми типами данных параметр «value» не задается. 120 | ) 121 | 122 | // SetColor - устанавливает цвет ячейки, столбца или строки для таблицы 123 | QLUACPP_DETAIL_API_FUNCTION16(bool, 124 | SetColor, 125 | const unsigned int, t_id, 126 | const unsigned int, row, 127 | const unsigned int, col, 128 | const unsigned int, b_color, // цвет фона 129 | const unsigned int, f_color, // цвет текста 130 | const int, sel_b_color, // цвет фона выделенной ячейки 131 | const int, sel_f_color /* цвет текста выделенной ячейки. 132 | В зависимости от переданных параметров row и col можно менять цвет всей таблицы, столбца, строки и отдельной ячейки. 133 | 134 | Если в качестве цвета задана константа QTABLE_DEFAULT_COLOR, то используется цвет, заданный в цветовой схеме операционной системе Windows. 135 | 136 | При работе функции используется константа QTABLE_NO_INDEX, равная «-1». 137 | */ 138 | ) 139 | 140 | /* TODO 141 | // SetTableNotificationCallback - задает функцию обратного вызова для обработки событий в таблице 142 | QLUACPP_DETAIL_API_FUNCTION(NUMBER, 143 | SetTableNotificationCallback, 144 | unsigned int, t_id, // идентификатор таблицы 145 | FUNCTION f_cb, // функция обратного вызова для обработки событий в таблице 146 | ) */ 147 | 148 | // SetWindowCaption - задает заголовок окна 149 | QLUACPP_DETAIL_API_FUNCTION6(bool, // В случае успешного выполнения возвращает «true», иначе – «false». 150 | SetWindowCaption, 151 | const unsigned int, t_id, 152 | const char*, str 153 | ) 154 | 155 | // SetWindowPos - устанавливает положение окна с таблицей 156 | QLUACPP_DETAIL_API_FUNCTION12(bool, // В случае успешного выполнения возвращает «true», иначе – «false». 157 | SetWindowPos, 158 | const unsigned int, t_id, 159 | const int, x, 160 | const int, y, 161 | const int, dx, 162 | const int, dy 163 | ) 164 | 165 | // SetSelectedRow - выделяет определенную строку таблицы 166 | QLUACPP_DETAIL_API_FUNCTION6(int, // В случае успешного завершения функция возвращает номер выделенной строки, иначе – «-1». 167 | SetSelectedRow, 168 | const unsigned int, table_id, // идентификатор таблицы 169 | const int, row // номер строки. Если задано значение row=-1, то выделяется последняя видимая строка в таблице. 170 | ) 171 | -------------------------------------------------------------------------------- /src/qlua/api/table_data.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | 4 | // getItem - Функция возвращает таблицу Lua, содержащую информацию о данных из строки с номером «Index» из таблицы с именем «TableName». 5 | template 6 | void getItem(unsigned int Index, 7 | std::function>&)> lambda) const { 8 | auto f = [&lambda] (const ::lua::state& s) { 9 | auto v = s.at(-1); 10 | lambda(v); 11 | return 1; 12 | }; 13 | l_.call_and_apply(f, 1, "getItem", ::qlua::table::detail::name_for_type
::value(), Index); 14 | } 15 | 16 | /* TODO: tuple 17 | // getOrderByNumber - Функция возвращает таблицу Lua, содержащую описание параметров Таблицы заявок и индекс заявки в хранилище терминала. 18 | QLUACPP_DETAIL_API_FUNCTION_TUPLE2_7(::qlua::table::orders, unsigned int, 19 | getOrderByNumber, 20 | const char*, class_code, 21 | unsigned int, order_id 22 | ) 23 | */ 24 | 25 | // getNumberOf - Функция возвращает количество записей в таблице «TableName». 26 | QLUACPP_DETAIL_API_FUNCTION4(unsigned int, 27 | getNumberOf, 28 | const char*, TableName 29 | ); 30 | 31 | template 32 | unsigned int getNumberOf() const { 33 | return getNumberOf(::qlua::table::detail::name_for_type
::value()); 34 | } 35 | 36 | 37 | /* TODO: 38 | // SearchItems - Функция позволяет реализовать быструю выборку элементов из хранилища терминала и возвращает таблицу с индексами элементов, удовлетворяющих условию поиска. 39 | QLUACPP_DETAIL_API_FUNCTION(TABLE, 40 | SearchItems, 41 | const char*, table_name, // строка, определяющая таблицу для поиска; 42 | unsigned int, start_index, // индекс стартового элемента для поиска; 43 | unsigned int, end_index, // индекс конечного элемента поиска; 44 | FUNCTION fn – функция обратного вызова, возвращающая одно из следующих значений: 45 | true – текущий индекс учитывается в результате; 46 | false – текущий индекс не учитывается в результате; 47 | nil – поиск прерывается, функция SearchItems возвращает таблицу с индексами, найденными ранее, включая текущий индекс. 48 | 49 | ) 50 | 51 | QLUACPP_DETAIL_API_FUNCTION(TABLE, 52 | SearchItems, 53 | const char* table_name, NUMBER start_index, NUMBER end_index, FUNCTION fn , const char* params 54 | ) 55 | */ 56 | -------------------------------------------------------------------------------- /src/qlua/api/workplace.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../structs/function_results.hpp" 4 | 5 | // regex ^ +\(.*\) \([A-Za-z0-9]+?\) *(\(.*\)) -> QLUACPP_DETAIL_API_FUNCTION(\1,JJ\2,JJ\3JJ) 6 | 7 | // getDepo - функция для получения информации по бумажным лимитам 8 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY10(::qlua::table::depo_limits_getDepo, 9 | getDepo, 10 | const char*, client_code, 11 | const char*, firmid, 12 | const char*, sec_code, 13 | const char*, trdaccid 14 | ) 15 | // getDepoEx - функция для получения информации по бумажным лимитам указанного типа 16 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY12(::qlua::table::depo_limits, 17 | getDepoEx, 18 | const char*, firmid, 19 | const char*, client_code, 20 | const char*, sec_code, 21 | const char*, trdaccid, 22 | const int, limit_kind 23 | ) 24 | 25 | // getMoney - функция для получения информации по денежным лимитам 26 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY10(::qlua::table::money_limits_getMoney, 27 | getMoney, 28 | const char*, client_code, 29 | const char*, firmid, 30 | const char*, tag, 31 | const char*, currcode 32 | ) 33 | // getMoneyEx - функция для получения информации по денежным лимитам указанного типа 34 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY12(::qlua::table::money_limits, 35 | getMoneyEx, 36 | const char*, firmid, 37 | const char*, client_code, 38 | const char*, tag, 39 | const char*, currcode, 40 | const int, limit_kind 41 | ) 42 | // getFuturesLimit - функция для получения информации по фьючерсным лимитам 43 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY10(::qlua::table::futures_client_limits, 44 | getFuturesLimit, 45 | const char*, firmid, 46 | const char*, trdaccid, 47 | const int, limit_type, 48 | const char*, currcode 49 | ) 50 | // getFuturesHolding - функция для получения информации по фьючерсным позициям 51 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY10(::qlua::table::futures_client_holding, 52 | getFuturesHolding, 53 | const char*, firmid, 54 | const char*, trdaccid, 55 | const char*, sec_code, 56 | const int, type 57 | ) 58 | 59 | // getQuoteLevel2 - функция для получения стакана по указанному классу и бумаге 60 | /*QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY6(::qlua::table::level2_quotes, 61 | getQuoteLevel2, 62 | const char*, class_code, 63 | const char*, sec_code 64 | )*/ 65 | void getQuoteLevel2(const char* class_code, 66 | const char* sec_code, 67 | std::function lambda) const { 68 | auto f = [&lambda] (const ::lua::state& s) { 69 | auto v = ::qlua::table::level2_quotes(s, -1); 70 | lambda(v); 71 | return 1; 72 | }; 73 | l_.call_and_apply(f, 1, "getQuoteLevel2", class_code, sec_code); 74 | } 75 | 76 | // getSecurityInfo - функция для получения информации по инструменту 77 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY6(::qlua::table::securities, 78 | getSecurityInfo, 79 | const char*, class_code, 80 | const char*, sec_code 81 | ) 82 | // getTradeDate - функция для получения даты торговой сессии 83 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY2(::qlua::table::date_, 84 | getTradeDate 85 | ) 86 | 87 | // sendTransaction - функция для работы с заявками 88 | void sendTransaction(const std::map& transaction // Поля таблицы в соответствии с описанием .tri файла по quik.chm 89 | ) { 90 | l_.getglobal("sendTransaction"); 91 | l_.newtable(); 92 | for (const auto& p : transaction) { 93 | l_.pushstring(p.first.c_str()); 94 | l_.pushstring(p.second.c_str()); 95 | l_.settable(-3); 96 | } 97 | l_.pcall(1, 1, 0); 98 | if (l_.isstring(-1)) { 99 | const auto& msg = l_.at(-1)(); 100 | if (msg[0] == 0) { 101 | l_.pop(1); 102 | } else { 103 | const std::string msg_str = msg; 104 | l_.pop(1); 105 | throw std::runtime_error("sendTransaction error: " + msg_str); 106 | } 107 | } else { 108 | l_.pop(1); 109 | throw std::runtime_error("sendTransaction returned unexpected type"); 110 | } 111 | } 112 | 113 | // CalcBuySell - функция для расчета максимально возможного количества лотов в заявке 114 | QLUACPP_DETAIL_API_FUNCTION_TUPLE2_17(unsigned int, double, // qty, comission, 115 | CalcBuySell, 116 | const char*, class_code, 117 | const char*, sec_code, 118 | const char*, client_code, 119 | const char*, account, 120 | const double, price, 121 | const bool, is_buy, 122 | const bool, is_market 123 | ) 124 | 125 | // getPortfolioInfo - функция для получения значений параметров таблицы «Клиентский портфель» 126 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY6(::qlua::table::portfolio_info_getPortfolioInfo, 127 | getPortfolioInfo, 128 | const char*, firm_id, 129 | const char*, client_code 130 | ) 131 | // getPortfolioInfoEx - функция для получения значений параметров таблицы «Клиентский портфель» с учетом вида лимита 132 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY8(::qlua::table::portfolio_info_getPortfolioInfoEx, 133 | getPortfolioInfoEx, 134 | const char*, firm_id, 135 | const char*, client_code, 136 | const int, limit_kind 137 | ) 138 | // getBuySellInfo - функция для получения параметров таблицы «Купить/Продать» 139 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY12(::qlua::table::buy_sell_info_getBuySellInfo, 140 | getBuySellInfo, 141 | const char*, firm_id, 142 | const char*, client_code, 143 | const char*, class_code, 144 | const char*, sec_code, 145 | const double, price 146 | ) 147 | // getBuySellInfoEx - функция для получения параметров (включая вид лимита) таблицы «Купить/Продать» 148 | QLUACPP_DETAIL_API_FUNCTION_RES1_APPLY12(::qlua::table::buy_sell_info_getBuySellInfoEx, 149 | getBuySellInfoEx, 150 | const char*, firm_id, 151 | const char*, client_code, 152 | const char*, class_code, 153 | const char*, sec_code, 154 | const double, price 155 | ) 156 | -------------------------------------------------------------------------------- /src/qlua/callbacks.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "structs/standalone.hpp" 4 | 5 | namespace qlua { 6 | namespace callback { 7 | 8 | /* These are just names and type signature for future typechecks. 9 | For now, to install qlua callback just declare appropriate luacpp static function, e.g.: 10 | LUACPP_STATIC_FUNCTION2(main, my_main_handler_function); // In root namespace 11 | ::lua::functions::main.register_to_lua(lua_state, my_main_handler_function); // Later in code 12 | */ 13 | 14 | struct main { // реализация основного потока исполнения в скрипте 15 | static const char* name() { static const char name[] = "main"; return name; } 16 | typedef void return_type; 17 | typedef std::tuple<> args_type; 18 | }; 19 | 20 | struct OnAccountBalance { // изменение позиции по счету 21 | static const char* name() { static const char name[] = "OnAccountBalance"; return name; } 22 | typedef void return_type; 23 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 24 | }; 25 | 26 | struct OnAccountPosition { // изменение позиции по счету 27 | static const char* name() { static const char name[] = "OnAccountPosition"; return name; } 28 | typedef void return_type; 29 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 30 | }; 31 | 32 | struct OnAllTrade { // новая обезличенная сделка 33 | static const char* name() { static const char name[] = "OnAllTrade"; return name; } 34 | typedef void return_type; 35 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 36 | }; 37 | 38 | struct OnCleanUp { // смена торговой сессии 39 | static const char* name() { static const char name[] = "OnCleanUp"; return name; } 40 | typedef void return_type; 41 | typedef std::tuple<> args_type; 42 | }; 43 | 44 | struct OnClose { // закрытие терминала QUIK или выгрузка файла qlua.dll 45 | static const char* name() { static const char name[] = "OnClose"; return name; } 46 | typedef void return_type; 47 | typedef std::tuple<> args_type; 48 | }; 49 | 50 | struct OnConnected { // установление связи с сервером QUIK 51 | static const char* name() { static const char name[] = "OnConnected"; return name; } 52 | typedef void return_type; 53 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 54 | }; 55 | 56 | struct OnDepoLimit { // изменение бумажного лимита 57 | static const char* name() { static const char name[] = "OnDepoLimit"; return name; } 58 | typedef void return_type; 59 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 60 | }; 61 | 62 | struct OnDepoLimitDelete { // удаление бумажного лимита 63 | static const char* name() { static const char name[] = "OnDepoLimitDelete"; return name; } 64 | typedef void return_type; 65 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 66 | }; 67 | 68 | struct OnDisconnected { // отключение от сервера QUIK 69 | static const char* name() { static const char name[] = "OnDisconnected"; return name; } 70 | typedef void return_type; 71 | typedef std::tuple<> args_type; 72 | }; 73 | 74 | struct OnFirm { // получение описания новой фирмы 75 | static const char* name() { static const char name[] = "OnFirm"; return name; } 76 | typedef void return_type; 77 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 78 | }; 79 | 80 | struct OnFuturesClientHolding { // изменение позиции по срочному рынку 81 | static const char* name() { static const char name[] = "OnFuturesClientHolding"; return name; } 82 | typedef void return_type; 83 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 84 | }; 85 | 86 | struct OnFuturesLimitChange { // изменение ограничений по срочному рынку 87 | static const char* name() { static const char name[] = "OnFuturesLimitChange"; return name; } 88 | typedef void return_type; 89 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 90 | }; 91 | 92 | struct OnFuturesLimitDelete { // удаление лимита по срочному рынку 93 | static const char* name() { static const char name[] = "OnFuturesLimitDelete"; return name; } 94 | typedef void return_type; 95 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 96 | }; 97 | 98 | struct OnInit { // инициализация функции main 99 | static const char* name() { static const char name[] = "OnInit"; return name; } 100 | typedef void return_type; 101 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 102 | }; 103 | 104 | struct OnMoneyLimit { // изменение денежного лимита 105 | static const char* name() { static const char name[] = "OnMoneyLimit"; return name; } 106 | typedef void return_type; 107 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 108 | }; 109 | 110 | struct OnMoneyLimitDelete { // удаление денежного лимита 111 | static const char* name() { static const char name[] = "OnMoneyLimitDelete"; return name; } 112 | typedef void return_type; 113 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 114 | }; 115 | 116 | struct OnNegDeal { // новая заявка на внебиржевую сделку или изменение параметров существующей заявки на внебиржевую сделку 117 | static const char* name() { static const char name[] = "OnNegDeal"; return name; } 118 | typedef void return_type; 119 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 120 | }; 121 | 122 | struct OnNegTrade { // новая сделка для исполнения или изменение существующей сделки для исполнения 123 | static const char* name() { static const char name[] = "OnNegTrade"; return name; } 124 | typedef void return_type; 125 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 126 | }; 127 | 128 | struct OnOrder { // новая заявка или изменение параметров существующей заявки 129 | static const char* name() { static const char name[] = "OnOrder"; return name; } 130 | typedef void return_type; 131 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 132 | }; 133 | 134 | struct OnParam { // изменение текущих параметров 135 | static const char* name() { static const char name[] = "OnParam"; return name; } 136 | typedef void return_type; 137 | typedef std::tuple< 138 | ::lua::entity<::lua::type_policy>, 139 | ::lua::entity<::lua::type_policy> 140 | > args_type; 141 | }; 142 | 143 | struct OnQuote { // изменение стакана котировок 144 | static const char* name() { static const char name[] = "OnQuote"; return name; } 145 | typedef void return_type; 146 | typedef std::tuple< 147 | ::lua::entity<::lua::type_policy>, 148 | ::lua::entity<::lua::type_policy> 149 | > args_type; 150 | }; 151 | 152 | struct OnStop { // остановка скрипта из диалога управления 153 | static const char* name() { static const char name[] = "OnStop"; return name; } 154 | typedef int return_type; 155 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 156 | }; 157 | 158 | struct OnStopOrder { // новая стоп-заявка или изменение параметров существующей стоп-заявки 159 | static const char* name() { static const char name[] = "OnStopOrder"; return name; } 160 | typedef void return_type; 161 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 162 | }; 163 | 164 | struct OnTrade { // новая сделка или изменение параметров существующей сделки 165 | static const char* name() { static const char name[] = "OnTrade"; return name; } 166 | typedef void return_type; 167 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 168 | }; 169 | 170 | struct OnTransReply { // ответ на транзакцию 171 | static const char* name() { static const char name[] = "OnTransReply"; return name; } 172 | typedef void return_type; 173 | typedef std::tuple<::lua::entity<::lua::type_policy>> args_type; 174 | }; 175 | } 176 | 177 | } 178 | -------------------------------------------------------------------------------- /src/qlua/extended.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace qlua { 6 | struct extended : api { 7 | using api::api; 8 | 9 | void swap(type& other) { 10 | api::swap(other); 11 | } 12 | 13 | type& operator=(const type& other) { 14 | return api::operator=(other); 15 | } 16 | 17 | template 18 | Constant constant(const std::string& name) const { 19 | return api::constant(name.c_str()); 20 | } 21 | 22 | // Convinience overloads, mostly for std::string in arguments 23 | #include "extended/api_overloads/service.hpp" 24 | #include "extended/api_overloads/table_data.hpp" 25 | #include "extended/api_overloads/securities.hpp" 26 | #include "extended/api_overloads/workplace.hpp" 27 | #include "extended/api_overloads/current_trades_receive.hpp" 28 | #include "extended/api_overloads/charts.hpp" 29 | #include "extended/api_overloads/table.hpp" 30 | // TODO #include "extended/api_overloads/labels.hpp" 31 | #include "extended/api_overloads/level2_quotes.hpp" 32 | #include "extended/api_overloads/current_trades_request.hpp" 33 | // #include "extended/api_overloads/bitmask.hpp" 34 | 35 | #include "extended/quik_thread_safe.hpp" 36 | }; 37 | } 38 | 39 | -------------------------------------------------------------------------------- /src/qlua/extended/api_overloads/charts.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | unsigned int getLinesCount(const std::string& tag) const { 4 | return api::getLinesCount(tag.c_str()); 5 | } 6 | 7 | unsigned int getLinesCount(const char* tag) const { 8 | return api::getLinesCount(tag); 9 | } 10 | 11 | unsigned int getNumCandles(const std::string& tag) const { 12 | return api::getNumCandles(tag.c_str()); 13 | } 14 | 15 | unsigned int getNumCandles(const char* tag) const { 16 | return api::getNumCandles(tag); 17 | } 18 | 19 | void getCandlesByIndex(const std::string& tag, 20 | unsigned int line, 21 | unsigned int first_candle, 22 | unsigned int count, 23 | std::function>&, 25 | const unsigned int index, 26 | const ::lua::entity<::lua::type_policy>&, 27 | const ::lua::entity<::lua::type_policy>& 28 | )> lambda 29 | ) const { 30 | return api::getCandlesByIndex(tag.c_str(), line, first_candle, count, lambda); 31 | } 32 | 33 | void getCandlesByIndex(const char* tag, 34 | unsigned int line, 35 | unsigned int first_candle, 36 | unsigned int count, 37 | std::function>&, 39 | const unsigned int index, 40 | const ::lua::entity<::lua::type_policy>&, 41 | const ::lua::entity<::lua::type_policy>& 42 | )> lambda 43 | ) const { 44 | return api::getCandlesByIndex(tag, line, first_candle, count, lambda); 45 | } 46 | 47 | ::qlua::data_source CreateDataSource(const std::string& class_code, 48 | const std::string& sec_code, 49 | unsigned int interval) const { 50 | return api::CreateDataSource(class_code.c_str(), sec_code.c_str(), interval, nullptr); 51 | } 52 | 53 | ::qlua::data_source CreateDataSource(const std::string& class_code, 54 | const std::string& sec_code, 55 | unsigned int interval, 56 | const std::string& param) const { 57 | return api::CreateDataSource(class_code.c_str(), sec_code.c_str(), interval, param.c_str()); 58 | } 59 | 60 | ::qlua::data_source CreateDataSource(const char* class_code, 61 | const char* sec_code, 62 | unsigned int interval, 63 | const char* param = nullptr) const { 64 | return api::CreateDataSource(class_code, sec_code, interval, param); 65 | } 66 | 67 | -------------------------------------------------------------------------------- /src/qlua/extended/api_overloads/current_trades_receive.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void getParamEx(const std::string& class_code, 4 | const std::string& sec_code, 5 | const std::string& param_name, 6 | std::function>&)> lambda) const { 7 | api::getParamEx(class_code.c_str(), sec_code.c_str(), param_name.c_str(), lambda); 8 | } 9 | 10 | void getParamEx(const char* class_code, 11 | const char* sec_code, 12 | const char* param_name, 13 | std::function>&)> lambda) const { 14 | api::getParamEx(class_code, sec_code, param_name, lambda); 15 | } 16 | 17 | void getParamEx2(const std::string& class_code, 18 | const std::string& sec_code, 19 | const std::string& param_name, 20 | std::function>&)> lambda) const { 21 | api::getParamEx2(class_code.c_str(), sec_code.c_str(), param_name.c_str(), lambda); 22 | } 23 | 24 | 25 | void getParamEx2(const char* class_code, 26 | const char* sec_code, 27 | const char* param_name, 28 | std::function>&)> lambda) const { 29 | api::getParamEx2(class_code, sec_code, param_name, lambda); 30 | } 31 | -------------------------------------------------------------------------------- /src/qlua/extended/api_overloads/current_trades_request.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | bool ParamRequest(const std::string& class_code, 4 | const std::string& sec_code, 5 | const std::string& db_name) const { 6 | return api::ParamRequest(class_code.c_str(), sec_code.c_str(), db_name.c_str()); 7 | } 8 | 9 | bool ParamRequest(const char* class_code, 10 | const char* sec_code, 11 | const char* db_name) const { 12 | return api::ParamRequest(class_code, sec_code, db_name); 13 | } 14 | 15 | bool CancelParamRequest(const std::string& class_code, 16 | const std::string& sec_code, 17 | const std::string& db_name) const { 18 | return api::CancelParamRequest(class_code.c_str(), sec_code.c_str(), db_name.c_str()); 19 | } 20 | 21 | bool CancelParamRequest(const char* class_code, 22 | const char* sec_code, 23 | const char* db_name) const { 24 | return api::CancelParamRequest(class_code, sec_code, db_name); 25 | } 26 | 27 | -------------------------------------------------------------------------------- /src/qlua/extended/api_overloads/level2_quotes.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | bool Subscribe_Level_II_Quotes(const std::string& class_code, 4 | const std::string& sec_code) const { 5 | return api::Subscribe_Level_II_Quotes(class_code.c_str(), sec_code.c_str()); 6 | } 7 | 8 | bool Subscribe_Level_II_Quotes(const char* class_code, 9 | const char* sec_code) const { 10 | return api::Subscribe_Level_II_Quotes(class_code, sec_code); 11 | } 12 | 13 | bool Unsubscribe_Level_II_Quotes(const std::string& class_code, 14 | const std::string& sec_code) const { 15 | return api::Unsubscribe_Level_II_Quotes(class_code.c_str(), sec_code.c_str()); 16 | } 17 | 18 | bool Unsubscribe_Level_II_Quotes(const char* class_code, 19 | const char* sec_code) const { 20 | return api::Unsubscribe_Level_II_Quotes(class_code, sec_code); 21 | } 22 | 23 | bool IsSubscribed_Level_II_Quotes(const std::string& class_code, 24 | const std::string& sec_code) const { 25 | return api::IsSubscribed_Level_II_Quotes(class_code.c_str(), sec_code.c_str()); 26 | } 27 | 28 | bool IsSubscribed_Level_II_Quotes(const char* class_code, 29 | const char* sec_code) const { 30 | return api::IsSubscribed_Level_II_Quotes(class_code, sec_code); 31 | } 32 | -------------------------------------------------------------------------------- /src/qlua/extended/api_overloads/securities.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void getClassInfo(const std::string& class_name, 4 | std::function>&)> lambda) const { 5 | api::getClassInfo(class_name.c_str(), lambda); 6 | } 7 | 8 | void getClassInfo(const char* class_name, 9 | std::function>&)> lambda) const { 10 | api::getClassInfo(class_name, lambda); 11 | } 12 | 13 | const char* getClassSecurities(const std::string& class_name) const { 14 | return api::getClassSecurities(class_name.c_str()); 15 | } 16 | 17 | const char* getClassSecurities(const char* class_name) const { 18 | return api::getClassSecurities(class_name); 19 | } 20 | -------------------------------------------------------------------------------- /src/qlua/extended/api_overloads/service.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | const char* getInfoParam(const std::string& param_name) const { return api::getInfoParam(param_name.c_str()); } 4 | const char* getInfoParam(const char* param_name) const { return api::getInfoParam(param_name); } 5 | unsigned int message(const std::string& text, const unsigned int icon_type) const { return api::message(text.c_str(), icon_type); } 6 | unsigned int message(const char* text, const unsigned int icon_type) const { return api::message(text, icon_type); } 7 | unsigned int message(const std::string& text) const { return api::message(text.c_str()); } 8 | unsigned int message(const char* text) const { return api::message(text); } 9 | void PrintDbgStr(const std::string& s) const { api::PrintDbgStr(s.c_str()); } 10 | void PrintDbgStr(const char* s) const { api::PrintDbgStr(s); } 11 | 12 | -------------------------------------------------------------------------------- /src/qlua/extended/api_overloads/table.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | unsigned int AddColumn(const unsigned int t_id, 4 | const unsigned int iCode, 5 | const std::string& name, 6 | const bool is_default, 7 | const unsigned int par_type, 8 | const unsigned int width) const { 9 | return api::AddColumn(t_id, iCode, name.c_str(), is_default, par_type, width); 10 | } 11 | 12 | unsigned int AddColumn(const unsigned int t_id, 13 | const unsigned int iCode, 14 | const char* name, 15 | const bool is_default, 16 | const unsigned int par_type, 17 | const unsigned int width) const { 18 | return api::AddColumn(t_id, iCode, name, is_default, par_type, width); 19 | } 20 | 21 | bool SetCell(const unsigned int t_id, 22 | const unsigned int key, 23 | const unsigned int code, 24 | const std::string& text) { 25 | return api::SetCell(t_id, key, code, text.c_str()); 26 | } 27 | 28 | 29 | bool SetCell(const unsigned int t_id, 30 | const unsigned int key, 31 | const unsigned int code, 32 | const char* text) const { 33 | return api::SetCell(t_id, key, code, text); 34 | } 35 | 36 | bool SetCell(const unsigned int t_id, 37 | const unsigned int key, 38 | const unsigned int code, 39 | const std::string& text, 40 | const double value) const { 41 | return api::SetCell(t_id, key, code, text.c_str(), value); 42 | } 43 | 44 | 45 | bool SetCell(const unsigned int t_id, 46 | const unsigned int key, 47 | const unsigned int code, 48 | const char* text, 49 | const double value) const { 50 | return api::SetCell(t_id, key, code, text, value); 51 | } 52 | 53 | bool SetWindowCaption(const unsigned int t_id, 54 | const std::string& str) const { 55 | return api::SetWindowCaption(t_id, str.c_str()); 56 | } 57 | 58 | bool SetWindowCaption(const unsigned int t_id, 59 | const char* str) const { 60 | return api::SetWindowCaption(t_id, str); 61 | } 62 | 63 | -------------------------------------------------------------------------------- /src/qlua/extended/api_overloads/table_data.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | unsigned int getNumberOf(const std::string& TableName) { return api::getNumberOf(TableName.c_str()); } 4 | unsigned int getNumberOf(const char* TableName) { return api::getNumberOf(TableName); } 5 | 6 | template 7 | unsigned int getNumberOf() const { 8 | return api::getNumberOf(::qlua::table::detail::name_for_type
::value()); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /src/qlua/extended/api_overloads/workplace.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void getDepo(const std::string& client_code, 4 | const std::string& firmid, 5 | const std::string& sec_code, 6 | const std::string& trdaccid, 7 | std::function>&)> lambda) const { 8 | api::getDepo(client_code.c_str(), firmid.c_str(), sec_code.c_str(), trdaccid.c_str(), lambda); 9 | } 10 | 11 | void getDepo(const char* client_code, 12 | const char* firmid, 13 | const char* sec_code, 14 | const char* trdaccid, 15 | std::function>&)> lambda) const { 16 | api::getDepo(client_code, firmid, sec_code, trdaccid, lambda); 17 | } 18 | 19 | void getDepoEx(const std::string& firmid, 20 | const std::string& client_code, 21 | const std::string& sec_code, 22 | const std::string& trdaccid, 23 | const int limit_kind, 24 | std::function>&)> lambda) const { 25 | api::getDepoEx(firmid.c_str(), client_code.c_str(), sec_code.c_str(), trdaccid.c_str(), limit_kind, lambda); 26 | } 27 | 28 | void getDepoEx(const char* firmid, 29 | const char* client_code, 30 | const char* sec_code, 31 | const char* trdaccid, 32 | const int limit_kind, 33 | std::function>&)> lambda) const { 34 | api::getDepoEx(firmid, client_code, sec_code, trdaccid, limit_kind, lambda); 35 | } 36 | 37 | void getMoney(const std::string& client_code, 38 | const std::string& firmid, 39 | const std::string& tag, 40 | const std::string& currcode, 41 | std::function>&)> lambda) const { 42 | api::getMoney(client_code.c_str(), firmid.c_str(), tag.c_str(), currcode.c_str(), lambda); 43 | } 44 | 45 | void getMoney(const char* client_code, 46 | const char* firmid, 47 | const char* tag, 48 | const char* currcode, 49 | std::function>&)> lambda) const { 50 | api::getMoney(client_code, firmid, tag, currcode, lambda); 51 | } 52 | 53 | void getMoneyEx(const std::string& firmid, 54 | const std::string& client_code, 55 | const std::string& tag, 56 | const std::string& currcode, 57 | const int limit_kind, 58 | std::function>&)> lambda) const { 59 | api::getMoneyEx(firmid.c_str(), client_code.c_str(), tag.c_str(), currcode.c_str(), limit_kind, lambda); 60 | } 61 | 62 | void getMoneyEx(const char* firmid, 63 | const char* client_code, 64 | const char* tag, 65 | const char* currcode, 66 | const int limit_kind, 67 | std::function>&)> lambda) const { 68 | api::getMoneyEx(firmid, client_code, tag, currcode, limit_kind, lambda); 69 | } 70 | 71 | void getFuturesLimit(const std::string& firmid, 72 | const std::string& trdaccid, 73 | const int limit_type, 74 | const std::string& currcode, 75 | std::function>&)> lambda) const { 76 | api::getFuturesLimit(firmid.c_str(), trdaccid.c_str(), limit_type, currcode.c_str(), lambda); 77 | } 78 | 79 | void getFuturesLimit(const char* firmid, 80 | const char* trdaccid, 81 | const int limit_type, 82 | const char* currcode, 83 | std::function>&)> lambda) const { 84 | api::getFuturesLimit(firmid, trdaccid, limit_type, currcode, lambda); 85 | } 86 | 87 | void getFuturesHolding(const std::string& firmid, 88 | const std::string& trdaccid, 89 | const std::string& sec_code, 90 | const int type, 91 | std::function>&)> lambda) const { 92 | api::getFuturesHolding(firmid.c_str(), trdaccid.c_str(), sec_code.c_str(), type, lambda); 93 | } 94 | 95 | void getFuturesHolding(const char* firmid, 96 | const char* trdaccid, 97 | const char* sec_code, 98 | const int type, 99 | std::function>&)> lambda) const { 100 | api::getFuturesHolding(firmid, trdaccid, sec_code, type, lambda); 101 | } 102 | 103 | void getQuoteLevel2(const std::string& class_code, 104 | const std::string& sec_code, 105 | std::function lambda) const { 106 | api::getQuoteLevel2(class_code.c_str(), sec_code.c_str(), lambda); 107 | } 108 | 109 | void getQuoteLevel2(const char* class_code, 110 | const char* sec_code, 111 | std::function lambda) const { 112 | api::getQuoteLevel2(class_code, sec_code, lambda); 113 | } 114 | 115 | void getSecurityInfo(const std::string& class_code, 116 | const std::string& sec_code, 117 | std::function>&)> lambda) const { 118 | api::getSecurityInfo(class_code.c_str(), sec_code.c_str(), lambda); 119 | } 120 | 121 | 122 | void getSecurityInfo(const char* class_code, 123 | const char* sec_code, 124 | std::function>&)> lambda) const { 125 | api::getSecurityInfo(class_code, sec_code, lambda); 126 | } 127 | 128 | std::tuple CalcBuySell(const std::string& class_code, 129 | const std::string& sec_code, 130 | const std::string& client_code, 131 | const std::string& account, 132 | const double price, 133 | const bool is_buy, 134 | const bool is_market) { 135 | return api::CalcBuySell(class_code.c_str(), sec_code.c_str(), client_code.c_str(), account.c_str(), price, is_buy, is_market); 136 | } 137 | 138 | std::tuple CalcBuySell(const char* class_code, 139 | const char* sec_code, 140 | const char* client_code, 141 | const char* account, 142 | const double price, 143 | const bool is_buy, 144 | const bool is_market) { 145 | return api::CalcBuySell(class_code, sec_code, client_code, account, price, is_buy, is_market); 146 | } 147 | 148 | void getPortfolioInfo(const std::string& firm_id, 149 | const std::string& client_code, 150 | std::function>&)> lambda) const { 151 | api::getPortfolioInfo(firm_id.c_str(), client_code.c_str(), lambda); 152 | } 153 | 154 | void getPortfolioInfo(const char* firm_id, 155 | const char* client_code, 156 | std::function>&)> lambda) const { 157 | api::getPortfolioInfo(firm_id, client_code, lambda); 158 | } 159 | 160 | void getPortfolioInfoEx(const std::string& firm_id, 161 | const std::string& client_code, 162 | const int limit_kind, 163 | std::function>&)> lambda) const { 164 | api::getPortfolioInfoEx(firm_id.c_str(), client_code.c_str(), limit_kind, lambda); 165 | } 166 | 167 | void getPortfolioInfoEx(const char* firm_id, 168 | const char* client_code, 169 | const int limit_kind, 170 | std::function>&)> lambda) const { 171 | api::getPortfolioInfoEx(firm_id, client_code, limit_kind, lambda); 172 | } 173 | 174 | void getBuySellInfo(const std::string& firm_id, 175 | const std::string& client_code, 176 | const std::string& class_code, 177 | const std::string& sec_code, 178 | const double price, 179 | std::function>&)> lambda) const { 180 | api::getBuySellInfo(firm_id.c_str(), client_code.c_str(), class_code.c_str(), sec_code.c_str(), price, lambda); 181 | } 182 | 183 | void getBuySellInfo(const char* firm_id, 184 | const char* client_code, 185 | const char* class_code, 186 | const char* sec_code, 187 | const double price, 188 | std::function>&)> lambda) const { 189 | api::getBuySellInfo(firm_id, client_code, class_code, sec_code, price, lambda); 190 | } 191 | 192 | void getBuySellInfoEx(const std::string& firm_id, 193 | const std::string& client_code, 194 | const std::string& class_code, 195 | const std::string& sec_code, 196 | const double price, 197 | std::function>&)> lambda) const { 198 | api::getBuySellInfoEx(firm_id.c_str(), client_code.c_str(), class_code.c_str(), sec_code.c_str(), price, lambda); 199 | } 200 | 201 | void getBuySellInfoEx(const char* firm_id, 202 | const char* client_code, 203 | const char* class_code, 204 | const char* sec_code, 205 | const double price, 206 | std::function>&)> lambda) const { 207 | api::getBuySellInfoEx(firm_id, client_code, class_code, sec_code, price, lambda); 208 | } 209 | -------------------------------------------------------------------------------- /src/qlua/extended/quik_thread_safe.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /* Call a function within Quik's critical section for this script (for thread safety). 4 | sync_name - name of the sync object, has to be unique in global namespace 5 | function_name_in_lua - name of the function to call with prototype: bool func(T, T) 6 | In C++/QLuaCPP it corresponds, for example to: 7 | std::tuple func(const lua::state& l, 8 | ::lua::entity<::lua::type_policy>, 9 | ::lua::entity<::lua::type_policy>) 10 | Two int parameters are unused but must be present in the declaration. 11 | The value of returned bool is unimportant (preferably true). 12 | Declare/register it as usual with LuaCPP macros/calls. 13 | */ 14 | static void thread_safe_exec(const lua::state& l, 15 | const char* sync_name, 16 | const std::string& function_name_in_lua) { 17 | l.getglobal("table"); 18 | int i = 1; 19 | if (l.istable(-1)) { 20 | l.getfield(-1, "ssort"); 21 | ++i; 22 | if (l.isfunction(-1)) { 23 | l.getglobal(sync_name); 24 | ++i; 25 | // Create table if doesn't exist 26 | if (l.isnil(-1)) { 27 | l.pop(1); 28 | --i; 29 | l.newtable(); 30 | l.setglobal(sync_name); 31 | l.getglobal(sync_name); 32 | ++i; 33 | if (l.istable(-1)) { 34 | l.push(1); 35 | l.rawseti(-2, 1); 36 | l.push(2); 37 | l.rawseti(-2, 2); 38 | } else { 39 | l.pop(i); 40 | throw std::runtime_error("quik_thread_safe - failed to create table"); 41 | } 42 | } 43 | 44 | if (l.istable(-1)) { 45 | auto len = luaL_getn(l.C_state(), -1); 46 | if (len == 2) { 47 | l.getglobal(function_name_in_lua.c_str()); 48 | ++i; 49 | if (l.isfunction(-3) && l.isfunction(-1)) { 50 | l.pcall(2, 0, 0); 51 | i -= 3; 52 | l.pop(i); 53 | } else { 54 | l.pop(i); 55 | throw std::runtime_error("quik_thread_safe - function to run is not registered in globals list"); 56 | } 57 | } else { 58 | l.pop(i); 59 | throw std::runtime_error("quik_thread_safe - incorrect table size"); 60 | } 61 | } else { 62 | l.pop(i); 63 | throw std::runtime_error("quik_thread_safe - table name is occupied by a symbol of another type"); 64 | } 65 | } else { 66 | l.pop(i); 67 | throw std::runtime_error("quik_thread_safe - function ssort not found in the table"); 68 | } 69 | } else { 70 | l.pop(i); 71 | throw std::runtime_error("quik_thread_safe - library table is not loaded"); 72 | } 73 | } 74 | 75 | -------------------------------------------------------------------------------- /src/qlua/structs/datasource.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // DataSource (раздел "Функции для работы с графиками" qlua.chm) 4 | 5 | #include "function_results.hpp" 6 | 7 | namespace qlua { 8 | struct data_source { 9 | struct time { 10 | unsigned int year; 11 | unsigned int month; 12 | unsigned int day; 13 | unsigned int week_day; 14 | unsigned int hour; 15 | unsigned int min; 16 | unsigned int sec; 17 | unsigned int ms; 18 | unsigned int count; 19 | }; 20 | 21 | data_source(const lua::state& l, 22 | const char* class_code, // код класса 23 | const char* sec_code, // код бумаги 24 | const unsigned int interval, // интервал запрашиваемого графика, INTERVAL_* 25 | const char* param = nullptr // Необязательный параметр (что запрашивать) 26 | ) : l_(l) { 27 | auto f = [this] (const lua::state& l) -> int { 28 | // Check if CreateDataSource returned a table in first rslt 29 | if (l_.istable(-2)) { 30 | // Copy the table 31 | l_.pushvalue(-2); 32 | // Create reference 33 | if (l_.istable(-4)) { 34 | ref_key_ = luaL_ref(l_.C_state(), -4); 35 | if (ref_key_ != LUA_NOREF) { 36 | l_.pop(2); 37 | return 0; 38 | } else { 39 | l_.pop(1); // pushvalue 40 | throw std::runtime_error("Failed to create reference to datasource"); 41 | } 42 | } else { 43 | } 44 | } else { 45 | auto err = l_.at(-1); 46 | std::string msg("Failed to create datasource, qlua returned: "); 47 | msg += err(); 48 | l_.pop(2); 49 | throw std::runtime_error(msg.c_str()); 50 | } 51 | return 0; 52 | }; 53 | 54 | // Take references descriptor table 55 | l_.getglobal(data_source::desc_table_name()); 56 | if (l_.isnil(-1)) { // Create table if doesn't exist 57 | l_.pop(1); 58 | l_.newtable(); 59 | l_.setglobal(data_source::desc_table_name()); 60 | l_.getglobal(data_source::desc_table_name()); 61 | } 62 | if (l_.istable(-1)) { 63 | // Call CreateDataSource and handle the results 64 | if (param != nullptr) { 65 | l_.call_and_apply(f, 2, "CreateDataSource", class_code, sec_code, interval, param); 66 | } else { 67 | l_.call_and_apply(f, 2, "CreateDataSource", class_code, sec_code, interval); 68 | } 69 | } else { 70 | l_.pop(1); // getglobal desc table 71 | throw std::runtime_error("Failed to create lua table " + std::string(data_source::desc_table_name()) + " in globals for datasource descriptor"); 72 | } 73 | } 74 | 75 | double O(const unsigned int candle_idx) { 76 | return candle_method_call("O", candle_idx); 77 | } 78 | 79 | double C(const unsigned int candle_idx) { 80 | return candle_method_call("C", candle_idx); 81 | } 82 | 83 | double H(const unsigned int candle_idx) { 84 | return candle_method_call("H", candle_idx); 85 | } 86 | 87 | double L(const unsigned int candle_idx) { 88 | return candle_method_call("L", candle_idx); 89 | } 90 | 91 | double V(const unsigned int candle_idx) { 92 | return candle_method_call("V", candle_idx); 93 | } 94 | 95 | // Time 96 | time T(const unsigned int candle_idx) const { 97 | if (ref_key_ == LUA_NOREF) 98 | throw std::runtime_error("Can't call datasource method: no reference to the object"); 99 | 100 | l_.getglobal(data_source::desc_table_name()); 101 | auto i = 1; 102 | if (l_.istable(-1)) { 103 | l_.pushnumber(ref_key_); 104 | l_.rawget(-2); 105 | ++i; 106 | l_.pushstring("T"); 107 | l_.rawget(-2); // Push function from table to stack 108 | ++i; 109 | if (l_.isfunction(-1)) { 110 | l_.pushvalue(-2); // Push 'this' 111 | l_.pushnumber(candle_idx); 112 | const int nargs = 2; 113 | const int nres = 1; 114 | l_.pcall(nargs, nres, 0); 115 | i = i - 1 + nres; // 1 for function name popped by pcall 116 | auto t = l_.at(-1)(); 117 | time rslt = {t.year(), t.month(), t.day(), t.week_day(), t.hour(), t.min(), t.sec(), t.ms(), t.count()}; 118 | l_.pop(i); 119 | return rslt; 120 | } else { 121 | l_.pop(i); 122 | throw std::runtime_error("Call to datasource method failed: T method is not a function in object table"); 123 | } 124 | } else { 125 | l_.pop(i); 126 | throw std::runtime_error("Call to datasource method failed: " + std::string(data_source::desc_table_name()) + " is not a table in lua globals"); 127 | } 128 | } 129 | 130 | bool SetUpdateCallback(const char* lua_function_name) { 131 | if (ref_key_ == LUA_NOREF) 132 | throw std::runtime_error("Can't call datasource method: no reference to the object"); 133 | 134 | l_.getglobal(data_source::desc_table_name()); 135 | auto i = 1; 136 | if (l_.istable(-1)) { 137 | l_.pushnumber(ref_key_); 138 | l_.rawget(-2); 139 | ++i; 140 | l_.pushstring("SetUpdateCallback"); 141 | l_.rawget(-2); // Push function from table to stack 142 | ++i; 143 | if (l_.isfunction(-1)) { 144 | l_.pushvalue(-2); // Push 'this' 145 | ++i; 146 | l_.getglobal(lua_function_name); 147 | ++i; 148 | if (l_.isfunction(-1)) { 149 | l_.pcall(2, 1, 0); 150 | ++i; 151 | auto rslt = l_.at(-1)(); 152 | l_.pop(i - 3); // Function address and arguments 153 | return rslt; 154 | } else { 155 | throw std::runtime_error("Call to datasource method failed: " + std::string(lua_function_name) + " is not a function in lua globals"); 156 | } 157 | } else { 158 | l_.pop(i); 159 | throw std::runtime_error("Call to datasource method failed: SetUpdateCallback method is not a function in object table"); 160 | } 161 | } else { 162 | l_.pop(i); 163 | throw std::runtime_error("Call to datasource method failed: " + std::string(data_source::desc_table_name()) + " is not a table in lua globals"); 164 | } 165 | } 166 | 167 | bool SetEmptyCallback() { 168 | return ds_method_call("SetEmptyCallback"); 169 | } 170 | 171 | unsigned int Size() { 172 | return ds_method_call("Size"); 173 | } 174 | 175 | bool Close() { 176 | return ds_method_call("Close"); 177 | } 178 | 179 | static const char* desc_table_name() { 180 | static const char* s = "qluacpp_datasource_object_refs"; 181 | return s; 182 | } 183 | 184 | private: 185 | lua::state l_; 186 | int ref_key_{LUA_NOREF}; 187 | 188 | template 189 | inline T candle_method_call(const char* name, const unsigned int candle_idx) const { 190 | if (ref_key_ == LUA_NOREF) 191 | throw std::runtime_error("Can't call datasource method: no reference to the object"); 192 | l_.getglobal(data_source::desc_table_name()); 193 | auto i = 1; // Stack counter for items not cleaned by pcall; [desc_table] 194 | if (l_.istable(-1)) { 195 | l_.pushnumber(ref_key_); 196 | l_.rawget(-2); 197 | ++i; // [desc_table, ref] 198 | l_.pushstring(name); 199 | l_.rawget(-2); // Push function from table to stack 200 | ++i; // [desc_table, ref, func] 201 | if (l_.isfunction(-1)) { 202 | l_.pushvalue(-2); // Push 'this' 203 | l_.pushnumber(candle_idx); 204 | const int nargs = 2; 205 | const int nres = 1; 206 | l_.pcall(nargs, nres, 0); 207 | i = i - 1 + nres; // 1 for function name popped by pcall 208 | auto rslt = l_.at(-1)(); 209 | l_.pop(i); 210 | return rslt; 211 | } else { 212 | l_.pop(i); 213 | throw std::runtime_error("Call to datasource method failed: " + std::string(name) + " method is not a function in object table"); 214 | } 215 | } else { 216 | l_.pop(i); 217 | throw std::runtime_error("Call to datasource method failed: " + std::string(data_source::desc_table_name()) + " is not a table in lua globals"); 218 | } 219 | } 220 | 221 | template 222 | inline T ds_method_call(const char* name) const { 223 | if (ref_key_ == LUA_NOREF) 224 | throw std::runtime_error("Can't call datasource method: no reference to the object"); 225 | l_.getglobal(data_source::desc_table_name()); 226 | auto i = 1; // Stack counter for items not cleaned by pcall; [desc_table] 227 | if (l_.istable(-1)) { 228 | l_.pushnumber(ref_key_); 229 | l_.rawget(-2); 230 | ++i; // [desc_table, ref] 231 | l_.pushstring(name); 232 | l_.rawget(-2); // Push function from table to stack 233 | ++i; // [desc_table, ref, func] 234 | if (l_.isfunction(-1)) { 235 | l_.pushvalue(-2); // Push 'this' 236 | const int nargs = 1; 237 | const int nres = 1; 238 | l_.pcall(nargs, nres, 0); 239 | i = i - 1 + nres; // 1 for function name popped by pcall 240 | auto rslt = l_.at(-1)(); 241 | l_.pop(i); 242 | return rslt; 243 | } else { 244 | l_.pop(i); 245 | throw std::runtime_error("Call to datasource method failed: " + std::string(name) + " method is not a function in object table"); 246 | } 247 | } else { 248 | l_.pop(i); 249 | throw std::runtime_error("Call to datasource method failed: " + std::string(data_source::desc_table_name()) + " is not a table in lua globals"); 250 | } 251 | } 252 | 253 | }; 254 | 255 | } 256 | -------------------------------------------------------------------------------- /src/qlua/structs/datetime.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // date and datetime tables 4 | 5 | #define QLUACPP_DATETIME_TABLE_FIELD( NAME ) \ 6 | static constexpr const char _##NAME##_field_name[] = #NAME; \ 7 | ::lua::entity> NAME{s_, idx_}; \ 8 | 9 | 10 | // --- Direct macro table generators --- 11 | 12 | // date 13 | namespace qlua { 14 | namespace table { 15 | LUACPP_STATIC_TABLE_BEGIN(date_) 16 | LUACPP_TABLE_FIELD(date, std::string) 17 | LUACPP_TABLE_FIELD(year, unsigned int) 18 | LUACPP_TABLE_FIELD(month, unsigned int) 19 | LUACPP_TABLE_FIELD(day, unsigned int) 20 | LUACPP_STATIC_TABLE_END() 21 | } 22 | } 23 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::date_) 24 | 25 | // datetime "Формат даты и времени, используемый таблицах" 26 | namespace qlua { 27 | namespace table { 28 | LUACPP_STATIC_TABLE_BEGIN(datetime) 29 | LUACPP_TABLE_FIELD(mcs, int) 30 | LUACPP_TABLE_FIELD(ms, int) 31 | LUACPP_TABLE_FIELD(sec, int) 32 | LUACPP_TABLE_FIELD(min, int) 33 | LUACPP_TABLE_FIELD(hour, int) 34 | LUACPP_TABLE_FIELD(day, int) 35 | LUACPP_TABLE_FIELD(week_day, int) 36 | LUACPP_TABLE_FIELD(month, int) 37 | LUACPP_TABLE_FIELD(year, int) 38 | LUACPP_STATIC_TABLE_END() 39 | } 40 | } 41 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::datetime) 42 | 43 | // --- For nested tables --- 44 | 45 | // datetime "Формат даты и времени, используемый таблицах" 46 | namespace qlua { 47 | // Plain C structure to hold date_time 48 | struct c_date_time { 49 | int mcs; 50 | int ms; 51 | int sec; 52 | int min; 53 | int hour; 54 | int day; 55 | int week_day; 56 | int month; 57 | int year; 58 | }; 59 | 60 | namespace table { 61 | namespace detail { 62 | 63 | template 64 | struct datetime_type_policy { 65 | using write_type = const c_date_time&; 66 | using read_type = c_date_time; 67 | 68 | static inline bool type_matches(::lua::state s, int idx) { 69 | return s.istable(idx); // Check that we're at a table 70 | } 71 | 72 | static inline read_type get_unsafe(::lua::state s, int idx) { 73 | read_type rslt{0}; 74 | int table_idx = idx; 75 | s.push(FieldName); 76 | if (idx <= 0) 77 | s.gettable(idx - 1); 78 | else 79 | s.gettable(idx); 80 | if (s.istable(-1)) { 81 | rslt.mcs = get_field(s, "mcs"); 82 | rslt.ms = get_field(s, "ms"); 83 | rslt.sec = get_field(s, "sec"); 84 | rslt.min = get_field(s, "min"); 85 | rslt.hour = get_field(s, "hour"); 86 | rslt.day = get_field(s, "day"); 87 | rslt.week_day = get_field(s, "week_day"); 88 | rslt.month = get_field(s, "month"); 89 | rslt.year = get_field(s, "year"); 90 | } else { 91 | s.pop(1); 92 | throw std::runtime_error("table does not have "+std::string(FieldName)+" table member"); 93 | } 94 | s.pop(1); 95 | return rslt; 96 | } 97 | 98 | static inline void apply_unsafe(::lua::state s, int idx, std::function f) { 99 | throw std::runtime_error("apply_unsafe is not implemented for datetime"); 100 | } 101 | 102 | static inline void set(::lua::state s, int idx, c_date_time value) { 103 | throw std::runtime_error("set is not implemented for datetime"); 104 | } 105 | 106 | private: 107 | template 108 | static inline const T get_field(::lua::state s, const char* name) { 109 | s.push(name); 110 | s.rawget(-2); 111 | auto rslt = ::lua::entity<::lua::type_policy>(s, -1).get(); 112 | s.pop(1); 113 | return rslt; 114 | } 115 | 116 | }; 117 | 118 | } 119 | } 120 | } 121 | -------------------------------------------------------------------------------- /src/qlua/structs/function_results.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // depo_limits_getDepo (table returned from getDepo API) 4 | namespace qlua { 5 | namespace table { 6 | LUACPP_STATIC_TABLE_BEGIN(depo_limits_getDepo) 7 | LUACPP_TABLE_FIELD(depo_limit_locked_buy_value, double) // Стоимость ценных бумаг, заблокированных на покупку 8 | LUACPP_TABLE_FIELD(depo_current_balance, double) // Текущий остаток по бумагам 9 | LUACPP_TABLE_FIELD(depo_limit_locked_buy, double) // Количество лотов ценных бумаг, заблокированных на покупку 10 | LUACPP_TABLE_FIELD(depo_limit_locked, double) // Заблокированное Количество лотов ценных бумаг 11 | LUACPP_TABLE_FIELD(depo_limit_available, double) // Доступное количество ценных бумаг 12 | LUACPP_TABLE_FIELD(depo_current_limit, double) // Текущий лимит по бумагам 13 | LUACPP_TABLE_FIELD(depo_open_balance, double) // Входящий остаток по бумагам 14 | LUACPP_TABLE_FIELD(depo_open_limit, double) // Входящий лимит по бумагам 15 | LUACPP_STATIC_TABLE_END() 16 | } 17 | } 18 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::depo_limits_getDepo) 19 | 20 | // money_limits_getMoney (table returned from getMoney API) 21 | namespace qlua { 22 | namespace table { 23 | LUACPP_STATIC_TABLE_BEGIN(money_limits_getMoney) 24 | LUACPP_TABLE_FIELD(money_open_limit, double) // Входящий лимит по денежным средствам 25 | LUACPP_TABLE_FIELD(money_limit_locked_nonmarginal_value, double) // Стоимость немаржинальных бумаг в заявках на покупку 26 | LUACPP_TABLE_FIELD(money_limit_locked, double) // Заблокированное в заявках на покупку количество денежных средств 27 | LUACPP_TABLE_FIELD(money_open_balance, double) // Входящий остаток по денежным средствам 28 | LUACPP_TABLE_FIELD(money_current_limit, double) // Текущий лимит по денежным средствам 29 | LUACPP_TABLE_FIELD(money_current_balance, double) // Текущий остаток по денежным средствам 30 | LUACPP_TABLE_FIELD(money_limit_available, double) // Доступное количество денежных средств 31 | LUACPP_STATIC_TABLE_END() 32 | } 33 | } 34 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::money_limits_getMoney) 35 | 36 | /* 37 | // level2_quotes_record 38 | namespace qlua { 39 | namespace table { 40 | LUACPP_STATIC_TABLE_BEGIN(level2_quotes_record) 41 | LUACPP_TABLE_FIELD(price, std::string) 42 | LUACPP_TABLE_FIELD(quantity, std::string) 43 | LUACPP_STATIC_TABLE_END() 44 | } 45 | } 46 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::level2_quotes_record) 47 | 48 | // level2_quotes (table returned from getQuoteLevel2) 49 | namespace qlua { 50 | namespace table { 51 | LUACPP_STATIC_TABLE_BEGIN(level2_quotes) 52 | LUACPP_TABLE_FIELD(bid_count, std::string) // Количество котировок покупки. При отсутствии спроса возвращается значение «0» 53 | LUACPP_TABLE_FIELD(offer_count, std::string) // Количество котировок продажи. При отсутствии предложения возвращается значение «0» 54 | LUACPP_TABLE_FIELD(bid, ::std::vector) // Котировки спроса (покупки). При отсутствии спроса возвращается пустая строка 55 | LUACPP_TABLE_FIELD(offer, ::std::vector) // Котировки предложений (продажи). При отсутствии предложения возвращается пустая строка 56 | LUACPP_STATIC_TABLE_END() 57 | } 58 | } 59 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::level2_quotes) 60 | */ 61 | // portfolio_info_getPortfolioInfo (table returned from getPortfolioInfo) 62 | namespace qlua { 63 | namespace table { 64 | LUACPP_STATIC_TABLE_BEGIN(portfolio_info_getPortfolioInfo) 65 | LUACPP_TABLE_FIELD(is_leverage, std::string) /*Признак использования схемы кредитования с контролем текущей стоимости активов. Возможные значения: 66 | «МЛ» – используется схема ведения позиции «по плечу», «плечо» рассчитано по значению Входящего лимита, 67 | «МП» – используется схема ведения позиции «по плечу», «плечо» указано явным образом, 68 | «МОП» – используется схема ведения позиции «лимит на открытую позицию»; 69 | «МД» – используется схема ведения позиции «по дисконтам»; 70 | «C» – используется схема ведения позиций «срочный рынок». Для клиентов срочного рынка без единой денежной позиции; 71 | <пусто> – используется схема ведения позиции «по лимитам» 72 | Тип клиента */ 73 | LUACPP_TABLE_FIELD(in_assets, std::string) // Оценка собственных средств клиента до начала торгов Вход. активы 74 | LUACPP_TABLE_FIELD(leverage, std::string) // Плечо. Если не задано явно, то отношение Входящего лимита к Входящим активам Плечо 75 | LUACPP_TABLE_FIELD(open_limit, std::string) // Оценка максимальной величины заемных средств до начала торгов Вход. лимит 76 | LUACPP_TABLE_FIELD(val_short, std::string) // Оценка стоимости коротких позиций. Значение всегда отрицательное Шорты 77 | LUACPP_TABLE_FIELD(val_long, std::string) // Оценка стоимости длинных позиций Лонги 78 | LUACPP_TABLE_FIELD(val_long_margin, std::string) // Оценка стоимости длинных позиций по маржинальным бумагам, принимаемым в обеспечение Лонги МО 79 | LUACPP_TABLE_FIELD(val_long_asset, std::string) // Оценка стоимости длинных позиций по немаржинальным бумагам, принимаемым в обеспечение Лонги О 80 | LUACPP_TABLE_FIELD(assets, std::string) // Оценка собственных средств клиента по текущим позициям и ценам Тек. активы 81 | LUACPP_TABLE_FIELD(cur_leverage, std::string) // Текущее плечо Тек.плечо 82 | LUACPP_TABLE_FIELD(margin, std::string) // Уровень маржи, в процентах Ур. маржи 83 | LUACPP_TABLE_FIELD(lim_all, std::string) // Текущая оценка максимальной величины заемных средств Тек. лимит 84 | LUACPP_TABLE_FIELD(av_lim_all, std::string) // Оценка величины заемных средств, доступных для дальнейшего открытия позиций ДостТекЛимит 85 | LUACPP_TABLE_FIELD(locked_buy, std::string) // Оценка стоимости активов в заявках на покупку Блок. покупка 86 | LUACPP_TABLE_FIELD(locked_buy_margin, std::string) // Оценка стоимости активов в заявках на покупку маржинальных бумаг, принимаемых в обеспечение Блок. пок. маржин. 87 | LUACPP_TABLE_FIELD(locked_buy_asset, std::string) // Оценка стоимости активов в заявках на покупку немаржинальных бумаг, принимаемых в обеспечение Блок.пок. обесп. 88 | LUACPP_TABLE_FIELD(locked_sell, std::string) // Оценка стоимости активов в заявках на продажу маржинальных бумаг Блок. продажа 89 | LUACPP_TABLE_FIELD(locked_value_coef, std::string) // Оценка стоимости активов в заявках на покупку немаржинальных бумаг Блок. пок. немарж. 90 | LUACPP_TABLE_FIELD(in_all_assets, std::string) // Оценка стоимости всех позиций клиента в ценах закрытия предыдущей торговой сессии, включая позиции по немаржинальным бумагам ВходСредства 91 | LUACPP_TABLE_FIELD(all_assets, std::string) // Текущая оценка стоимости всех позиций клиента ТекСредства 92 | LUACPP_TABLE_FIELD(profit_loss, std::string) // Абсолютная величина изменения стоимости всех позиций клиента Прибыль/убытки 93 | LUACPP_TABLE_FIELD(rate_change, std::string) // Относительная величина изменения стоимости всех позиций клиента ПроцИзмен 94 | LUACPP_TABLE_FIELD(lim_buy, std::string) // Оценка денежных средств, доступных для покупки маржинальных бумаг На покупку 95 | LUACPP_TABLE_FIELD(lim_sell, std::string) // Оценка стоимости маржинальных бумаг, доступных для продажи На продажу 96 | LUACPP_TABLE_FIELD(lim_non_margin, std::string) // Оценка денежных средств, доступных для покупки немаржинальных бумаг НаПокупНеМаржин 97 | LUACPP_TABLE_FIELD(lim_buy_asset, std::string) // Оценка денежных средств, доступных для покупки бумаг, принимаемых в обеспечение НаПокупОбесп 98 | LUACPP_TABLE_FIELD(val_short_net, std::string) // Оценка стоимости коротких позиций. При расчете не используется коэффициент дисконтирования ** Шорты (нетто) 99 | LUACPP_TABLE_FIELD(val_long_net, std::string) // Оценка стоимости длинных позиций. При расчете не используется коэффициент дисконтирования ** Лонги (нетто) 100 | LUACPP_TABLE_FIELD(total_money_bal, std::string) // Сумма остатков по денежным средствам по всем лимитам, без учета средств, заблокированных под исполнение обязательств, выраженная в выбранной валюте расчета Сумма ден. остатков 101 | LUACPP_TABLE_FIELD(total_locked_money, std::string) // Cумма заблокированных средств со всех денежных лимитов клиента, пересчитанная в валюту расчетов через кросс-курсы на сервере Суммарно заблок. 102 | LUACPP_TABLE_FIELD(haircuts, std::string) // Сумма дисконтов стоимости длинных (только по бумагам обеспечения) и коротких бумажных позиций, дисконтов корреляции между инструментами, а также дисконтов на задолженности по валютам, не покрытые бумажным обеспечением в этих же валютах Сумма дисконтов 103 | LUACPP_TABLE_FIELD(assets_without_hc, std::string) // Суммарная величина денежных остатков, стоимости длинных позиций по бумагам обеспечения и стоимости коротких позиций, без учета дисконтирующих коэффициентов, без учета неттинга стоимости бумаг в рамках объединенной бумажной позиции и без учета корреляции между инструментами ТекАктБезДиск 104 | LUACPP_TABLE_FIELD(status_coef, std::string) // Отношение суммы дисконтов к текущим активам без учета дисконтов Статус счета 105 | LUACPP_TABLE_FIELD(varmargin, std::string) // Текущая вариационная маржа по позициям клиента, по всем инструментам Вариац. маржа 106 | LUACPP_TABLE_FIELD(go_for_positions, std::string) // Размер денежных средств, уплаченных под все открытые позиции на срочном рынке ГО поз. 107 | LUACPP_TABLE_FIELD(go_for_orders, std::string) // Оценка стоимости активов в заявках на срочном рынке ГО заяв. 108 | LUACPP_TABLE_FIELD(rate_futures, std::string) // Отношение ликвидационной стоимости портфеля к ГО по срочному рынку Активы/ГО 109 | LUACPP_TABLE_FIELD(is_qual_client, std::string) // Признак «квалифицированного» клиента, которому разрешено кредитование заемными средствами с плечом 1:3. Возможные значения: «ПовышУрРиска» – квалифицированный, <пусто> – нет ПовышУрРиска 110 | LUACPP_TABLE_FIELD(is_futures, std::string) // Счет клиента на FORTS, в случае наличия объединенной позиции, иначе поле остается пустым Сроч. счет 111 | LUACPP_TABLE_FIELD(curr_tag, std::string) // Актуальные текущие параметры расчета для данной строки в формате «<Валюта>-<Тег расчётов>». Пример: «SUR-EQTV» Парам 112 | LUACPP_STATIC_TABLE_END() 113 | } 114 | } 115 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::portfolio_info_getPortfolioInfo) 116 | 117 | // portfolio_info_getPortfolioInfoEx (table returned from getPortfolioInfoEx) 118 | namespace qlua { 119 | namespace table { 120 | LUACPP_STATIC_TABLE_BEGIN(portfolio_info_getPortfolioInfoEx) 121 | LUACPP_TABLE_FIELD(is_leverage, std::string) /*Признак использования схемы кредитования с контролем текущей стоимости активов. Возможные значения: 122 | «МЛ» – используется схема ведения позиции «по плечу», «плечо» рассчитано по значению Входящего лимита, 123 | «МП» – используется схема ведения позиции «по плечу», «плечо» указано явным образом, 124 | «МОП» – используется схема ведения позиции «лимит на открытую позицию»; 125 | «МД» – используется схема ведения позиции «по дисконтам»; 126 | «C» – используется схема ведения позиций «срочный рынок». Для клиентов срочного рынка без единой денежной позиции; 127 | <пусто> – используется схема ведения позиции «по лимитам» 128 | Тип клиента */ 129 | LUACPP_TABLE_FIELD(in_assets, std::string) // Оценка собственных средств клиента до начала торгов Вход. активы 130 | LUACPP_TABLE_FIELD(leverage, std::string) // Плечо. Если не задано явно, то отношение Входящего лимита к Входящим активам Плечо 131 | LUACPP_TABLE_FIELD(open_limit, std::string) // Оценка максимальной величины заемных средств до начала торгов Вход. лимит 132 | LUACPP_TABLE_FIELD(val_short, std::string) // Оценка стоимости коротких позиций. Значение всегда отрицательное Шорты 133 | LUACPP_TABLE_FIELD(val_long, std::string) // Оценка стоимости длинных позиций Лонги 134 | LUACPP_TABLE_FIELD(val_long_margin, std::string) // Оценка стоимости длинных позиций по маржинальным бумагам, принимаемым в обеспечение Лонги МО 135 | LUACPP_TABLE_FIELD(val_long_asset, std::string) // Оценка стоимости длинных позиций по немаржинальным бумагам, принимаемым в обеспечение Лонги О 136 | LUACPP_TABLE_FIELD(assets, std::string) // Оценка собственных средств клиента по текущим позициям и ценам Тек. активы 137 | LUACPP_TABLE_FIELD(cur_leverage, std::string) // Текущее плечо Тек.плечо 138 | LUACPP_TABLE_FIELD(margin, std::string) // Уровень маржи, в процентах Ур. маржи 139 | LUACPP_TABLE_FIELD(lim_all, std::string) // Текущая оценка максимальной величины заемных средств Тек. лимит 140 | LUACPP_TABLE_FIELD(av_lim_all, std::string) // Оценка величины заемных средств, доступных для дальнейшего открытия позиций ДостТекЛимит 141 | LUACPP_TABLE_FIELD(locked_buy, std::string) // Оценка стоимости активов в заявках на покупку Блок. покупка 142 | LUACPP_TABLE_FIELD(locked_buy_margin, std::string) // Оценка стоимости активов в заявках на покупку маржинальных бумаг, принимаемых в обеспечение Блок. пок. маржин. 143 | LUACPP_TABLE_FIELD(locked_buy_asset, std::string) // Оценка стоимости активов в заявках на покупку немаржинальных бумаг, принимаемых в обеспечение Блок.пок. обесп. 144 | LUACPP_TABLE_FIELD(locked_sell, std::string) // Оценка стоимости активов в заявках на продажу маржинальных бумаг Блок. продажа 145 | LUACPP_TABLE_FIELD(locked_value_coef, std::string) // Оценка стоимости активов в заявках на покупку немаржинальных бумаг Блок. пок. немарж. 146 | LUACPP_TABLE_FIELD(in_all_assets, std::string) // Оценка стоимости всех позиций клиента в ценах закрытия предыдущей торговой сессии, включая позиции по немаржинальным бумагам ВходСредства 147 | LUACPP_TABLE_FIELD(all_assets, std::string) // Текущая оценка стоимости всех позиций клиента ТекСредства 148 | LUACPP_TABLE_FIELD(profit_loss, std::string) // Абсолютная величина изменения стоимости всех позиций клиента Прибыль/убытки 149 | LUACPP_TABLE_FIELD(rate_change, std::string) // Относительная величина изменения стоимости всех позиций клиента ПроцИзмен 150 | LUACPP_TABLE_FIELD(lim_buy, std::string) // Оценка денежных средств, доступных для покупки маржинальных бумаг На покупку 151 | LUACPP_TABLE_FIELD(lim_sell, std::string) // Оценка стоимости маржинальных бумаг, доступных для продажи На продажу 152 | LUACPP_TABLE_FIELD(lim_non_margin, std::string) // Оценка денежных средств, доступных для покупки немаржинальных бумаг НаПокупНеМаржин 153 | LUACPP_TABLE_FIELD(lim_buy_asset, std::string) // Оценка денежных средств, доступных для покупки бумаг, принимаемых в обеспечение НаПокупОбесп 154 | LUACPP_TABLE_FIELD(val_short_net, std::string) // Оценка стоимости коротких позиций. При расчете не используется коэффициент дисконтирования ** Шорты (нетто) 155 | LUACPP_TABLE_FIELD(val_long_net, std::string) // Оценка стоимости длинных позиций. При расчете не используется коэффициент дисконтирования ** Лонги (нетто) 156 | LUACPP_TABLE_FIELD(total_money_bal, std::string) // Сумма остатков по денежным средствам по всем лимитам, без учета средств, заблокированных под исполнение обязательств, выраженная в выбранной валюте расчета Сумма ден. остатков 157 | LUACPP_TABLE_FIELD(total_locked_money, std::string) // Cумма заблокированных средств со всех денежных лимитов клиента, пересчитанная в валюту расчетов через кросс-курсы на сервере Суммарно заблок. 158 | LUACPP_TABLE_FIELD(haircuts, std::string) // Сумма дисконтов стоимости длинных (только по бумагам обеспечения) и коротких бумажных позиций, дисконтов корреляции между инструментами, а также дисконтов на задолженности по валютам, не покрытые бумажным обеспечением в этих же валютах Сумма дисконтов 159 | LUACPP_TABLE_FIELD(assets_without_hc, std::string) // Суммарная величина денежных остатков, стоимости длинных позиций по бумагам обеспечения и стоимости коротких позиций, без учета дисконтирующих коэффициентов, без учета неттинга стоимости бумаг в рамках объединенной бумажной позиции и без учета корреляции между инструментами ТекАктБезДиск 160 | LUACPP_TABLE_FIELD(status_coef, std::string) // Отношение суммы дисконтов к текущим активам без учета дисконтов Статус счета 161 | LUACPP_TABLE_FIELD(varmargin, std::string) // Текущая вариационная маржа по позициям клиента, по всем инструментам Вариац. маржа 162 | LUACPP_TABLE_FIELD(go_for_positions, std::string) // Размер денежных средств, уплаченных под все открытые позиции на срочном рынке ГО поз. 163 | LUACPP_TABLE_FIELD(go_for_orders, std::string) // Оценка стоимости активов в заявках на срочном рынке ГО заяв. 164 | LUACPP_TABLE_FIELD(rate_futures, std::string) // Отношение ликвидационной стоимости портфеля к ГО по срочному рынку Активы/ГО 165 | LUACPP_TABLE_FIELD(is_qual_client, std::string) // Признак «квалифицированного» клиента, которому разрешено кредитование заемными средствами с плечом 1:3. Возможные значения: «ПовышУрРиска» – квалифицированный, <пусто> – нет ПовышУрРиска 166 | LUACPP_TABLE_FIELD(is_futures, std::string) // Счет клиента на FORTS, в случае наличия объединенной позиции, иначе поле остается пустым Сроч. счет 167 | LUACPP_TABLE_FIELD(curr_tag, std::string) // Актуальные текущие параметры расчета для данной строки в формате «<Валюта>-<Тег расчётов>». Пример: «SUR-EQTV» Парам 168 | 169 | LUACPP_TABLE_FIELD(init_margin, std::string) // Значение начальной маржи. Заполняется для клиентов типа «МД» Нач.маржа 170 | LUACPP_TABLE_FIELD(min_margin, std::string) // Значение минимальной маржи. Заполняется для клиентов типа «МД» Мин.маржа 171 | LUACPP_TABLE_FIELD(corrected_margin, std::string) // Значение скорректированной маржи. Заполняется для клиентов типа «МД» Скор.маржа 172 | LUACPP_TABLE_FIELD(client_type, std::string) // Тип клиента Тип клиента 173 | LUACPP_TABLE_FIELD(portfolio_value, std::string) // Стоимость портфеля. Для клиентов типа «МД» возвращается значение для строк с максимальным видом лимита limit_kind Стоимость портфеля 174 | LUACPP_TABLE_FIELD(start_limit_open_pos, std::string) // Лимит открытых позиций на начало дня ЛимОткрПозНачДня 175 | LUACPP_TABLE_FIELD(total_limit_open_pos, std::string) // Лимит открытых позиций ЛимОткрПоз 176 | LUACPP_TABLE_FIELD(limit_open_pos, std::string) // Планируемые чистые позиции ПланЧистПоз 177 | LUACPP_TABLE_FIELD(used_lim_open_pos, std::string) // Текущие чистые позиции ТекЧистПоз 178 | LUACPP_TABLE_FIELD(acc_var_margin, std::string) // Накопленная вариационная маржа НакопВарМаржа 179 | LUACPP_TABLE_FIELD(cl_var_margin, std::string) // Вариационная маржа по итогам промклиринга ВарМаржаПромклир. 180 | LUACPP_TABLE_FIELD(opt_liquid_cost, std::string) // Ликвидационная стоимость опционов ЛиквСтоимОпционов 181 | LUACPP_TABLE_FIELD(fut_asset, std::string) // Сумма оценки средств клиента на срочном рынке СумАктивовНаСрчРынке 182 | LUACPP_TABLE_FIELD(fut_total_asset, std::string) // Сумма оценки собственных средств клиента на фондовом и срочном рынках ПолнСтоимостьПортфеля 183 | LUACPP_TABLE_FIELD(fut_debt, std::string) // Текущая задолженность на срочном рынке ТекЗадолжНаСрчРынке 184 | LUACPP_TABLE_FIELD(fut_rate_asset, std::string) // Достаточность средств Дост. Средств 185 | LUACPP_TABLE_FIELD(fut_rate_asset_open, std::string) // Достаточность средств (под открытые позиции) Дост. Средств (ОткрПоз) 186 | LUACPP_TABLE_FIELD(fut_rate_go, std::string) // Коэффициент ликвидности ГО КоэффЛикв ГО 187 | LUACPP_TABLE_FIELD(planed_rate_go, std::string) // Ожидаемый коэффициент ликвидности ГО Ожид. КоэффЛикв ГО 188 | LUACPP_TABLE_FIELD(cash_leverage, std::string) // Cash Leverage Cash Leverage 189 | LUACPP_TABLE_FIELD(fut_position_type, std::string) /* Тип позиции на срочном рынке. Возможные значения 190 | «0» – нет позиции; 191 | «1» – фьючерсы; 192 | «2» – опционы; 193 | «3» – фьючерсы и опционы 194 | ТипПозНаСрчРынке */ 195 | LUACPP_TABLE_FIELD(fut_accured_int, std::string) // Накопленный доход с учётом премии по опционам и биржевым сборам НакопДоход 196 | LUACPP_TABLE_FIELD(rcv1, std::string) // Норматив покрытия риска 1. Рассчитывается как разница параметров «Стоимость портфеля» и «Начальная маржа». Для клиентов типа «МД» и «МД+» НПР1 197 | LUACPP_TABLE_FIELD(rcv2, std::string) // Норматив покрытия риска 2. Рассчитывается как разница параметров «Стоимость портфеля» и «Минимальная маржа». Для клиентов типа «МД» и «МД+» НПР2 198 | LUACPP_STATIC_TABLE_END() 199 | } 200 | } 201 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::portfolio_info_getPortfolioInfoEx) 202 | 203 | // buy_sell_info_getBuySellInfo (table returned from getBuySellInfo) 204 | namespace qlua { 205 | namespace table { 206 | LUACPP_STATIC_TABLE_BEGIN(buy_sell_info_getBuySellInfo) 207 | LUACPP_TABLE_FIELD(is_margin_sec, std::string) /* Признак маржинальности инструмента. Возможные значения: 208 | «0» – не маржинальная; 209 | «1» – маржинальная.*/ 210 | LUACPP_TABLE_FIELD(is_asset_sec, std::string) /* Принадлежность инструмента к списку бумаг, принимаемых в обеспечение. Возможные значения: 211 | «0» – не принимается в обеспечение; 212 | «1» – принимается в обеспечение. 213 | */ 214 | LUACPP_TABLE_FIELD(balance, std::string) // Текущая позиция по инструменту, в лотах 215 | LUACPP_TABLE_FIELD(can_buy, std::string) // Оценка количества лотов, доступных на покупку по указанной цене * 216 | LUACPP_TABLE_FIELD(can_sell, std::string) // Оценка количества лотов, доступных на продажу по указанной цене * 217 | LUACPP_TABLE_FIELD(position_valuation, std::string) // Денежная оценка позиции по инструменту по ценам спроса/предложения 218 | LUACPP_TABLE_FIELD(value, std::string) // Оценка стоимости позиции по цене последней сделки 219 | LUACPP_TABLE_FIELD(open_value, std::string) // Оценка стоимости позиции клиента, рассчитанная по цене закрытия предыдущей торговой сессии 220 | LUACPP_TABLE_FIELD(lim_long, std::string) // Предельный размер позиции по данному инструменту, принимаемый в обеспечение длинных позиций 221 | LUACPP_TABLE_FIELD(long_coef, std::string) // Коэффициент дисконтирования, применяемый для длинных позиций по данному инструменту 222 | LUACPP_TABLE_FIELD(lim_short, std::string) // Предельный размер короткой позиции по данному инструменту 223 | LUACPP_TABLE_FIELD(short_coef, std::string) // Коэффициент дисконтирования, применяемый для коротких позиций по данному инструменту 224 | LUACPP_TABLE_FIELD(value_coef, std::string) // Оценка стоимости позиции по цене последней сделки, с учетом дисконтирующих коэффициентов 225 | LUACPP_TABLE_FIELD(open_value_coef, std::string) // Оценка стоимости позиции клиента, рассчитанная по цене закрытия предыдущей торговой сессии с учетом дисконтирующих коэффициентов 226 | LUACPP_TABLE_FIELD(share, std::string) // Процентное отношение стоимости позиции по данному инструменту к стоимости всех активов клиента, рассчитанное по текущим ценам 227 | LUACPP_TABLE_FIELD(short_wa_price, std::string) // Средневзвешенная стоимость коротких позиций по инструментам 228 | LUACPP_TABLE_FIELD(long_wa_price, std::string) // Средневзвешенная стоимость длинных позиций по инструментам 229 | LUACPP_TABLE_FIELD(profit_loss, std::string) // Разница между средневзвешенной ценой приобретения бумаг и их рыночной оценки 230 | LUACPP_TABLE_FIELD(spread_hc, std::string) // Коэффициент корреляции между инструментами 231 | LUACPP_TABLE_FIELD(can_buy_own, std::string) // Максимально возможное количество бумаг в заявке на покупку этого инструмента на этом классе на собственные средства клиента, исходя из цены лучшего предложения 232 | LUACPP_TABLE_FIELD(can_sell_own, std::string) // Максимально возможное количество бумаг в заявке на продажу этого инструмента на этом классе из собственных активов клиента, исходя из цены лучшего спроса 233 | LUACPP_STATIC_TABLE_END(); 234 | } 235 | } 236 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::buy_sell_info_getBuySellInfo) 237 | 238 | // buy_sell_info_getBuySellInfoEx (table returned from getBuySellInfoEx) 239 | namespace qlua { 240 | namespace table { 241 | LUACPP_STATIC_TABLE_BEGIN(buy_sell_info_getBuySellInfoEx) 242 | LUACPP_TABLE_FIELD(is_margin_sec, std::string) /* Признак маржинальности инструмента. Возможные значения: 243 | «0» – не маржинальная; 244 | «1» – маржинальная.*/ 245 | LUACPP_TABLE_FIELD(is_asset_sec, std::string) /* Принадлежность инструмента к списку бумаг, принимаемых в обеспечение. Возможные значения: 246 | «0» – не принимается в обеспечение; 247 | «1» – принимается в обеспечение. 248 | */ 249 | LUACPP_TABLE_FIELD(balance, std::string) // Текущая позиция по инструменту, в лотах 250 | LUACPP_TABLE_FIELD(can_buy, std::string) // Оценка количества лотов, доступных на покупку по указанной цене * 251 | LUACPP_TABLE_FIELD(can_sell, std::string) // Оценка количества лотов, доступных на продажу по указанной цене * 252 | LUACPP_TABLE_FIELD(position_valuation, std::string) // Денежная оценка позиции по инструменту по ценам спроса/предложения 253 | LUACPP_TABLE_FIELD(value, std::string) // Оценка стоимости позиции по цене последней сделки 254 | LUACPP_TABLE_FIELD(open_value, std::string) // Оценка стоимости позиции клиента, рассчитанная по цене закрытия предыдущей торговой сессии 255 | LUACPP_TABLE_FIELD(lim_long, std::string) // Предельный размер позиции по данному инструменту, принимаемый в обеспечение длинных позиций 256 | LUACPP_TABLE_FIELD(long_coef, std::string) // Коэффициент дисконтирования, применяемый для длинных позиций по данному инструменту 257 | LUACPP_TABLE_FIELD(lim_short, std::string) // Предельный размер короткой позиции по данному инструменту 258 | LUACPP_TABLE_FIELD(short_coef, std::string) // Коэффициент дисконтирования, применяемый для коротких позиций по данному инструменту 259 | LUACPP_TABLE_FIELD(value_coef, std::string) // Оценка стоимости позиции по цене последней сделки, с учетом дисконтирующих коэффициентов 260 | LUACPP_TABLE_FIELD(open_value_coef, std::string) // Оценка стоимости позиции клиента, рассчитанная по цене закрытия предыдущей торговой сессии с учетом дисконтирующих коэффициентов 261 | LUACPP_TABLE_FIELD(share, std::string) // Процентное отношение стоимости позиции по данному инструменту к стоимости всех активов клиента, рассчитанное по текущим ценам 262 | LUACPP_TABLE_FIELD(short_wa_price, std::string) // Средневзвешенная стоимость коротких позиций по инструментам 263 | LUACPP_TABLE_FIELD(long_wa_price, std::string) // Средневзвешенная стоимость длинных позиций по инструментам 264 | LUACPP_TABLE_FIELD(profit_loss, std::string) // Разница между средневзвешенной ценой приобретения бумаг и их рыночной оценки 265 | LUACPP_TABLE_FIELD(spread_hc, std::string) // Коэффициент корреляции между инструментами 266 | LUACPP_TABLE_FIELD(can_buy_own, std::string) // Максимально возможное количество бумаг в заявке на покупку этого инструмента на этом классе на собственные средства клиента, исходя из цены лучшего предложения 267 | LUACPP_TABLE_FIELD(can_sell_own, std::string) // Максимально возможное количество бумаг в заявке на продажу этого инструмента на этом классе из собственных активов клиента, исходя из цены лучшего спроса 268 | 269 | LUACPP_TABLE_FIELD(limit_kind, int) // Вид лимита. Возможные значения: положительные целые числа, начиная с «0», соответствующие видам лимитов из таблицы «Лимиты по бумагам»: «0» – T0, «1» – T1, «2» – T2 и т.д. 270 | LUACPP_TABLE_FIELD(d_long, std::string) // Эффективный начальный дисконт для длинной позиции. Заполняется для клиентов типа «МД» 271 | LUACPP_TABLE_FIELD(d_min_long, std::string) // Эффективный минимальный дисконт для длинной позиции. Заполняется для клиентов типа «МД» 272 | LUACPP_TABLE_FIELD(d_short, std::string) // Эффективный начальный дисконт для короткой позиции. Заполняется для клиентов типа «МД» 273 | LUACPP_TABLE_FIELD(d_min_short, std::string) // Эффективный минимальный дисконт для короткой позиции. Заполняется для клиентов типа «МД» 274 | LUACPP_TABLE_FIELD(client_type, std::string) // Тип клиента 275 | LUACPP_TABLE_FIELD(is_long_allowed, std::string) /* Признак того, является ли бумага разрешенной для покупки на заемные средства. Возможные значения: 276 | «1» – разрешена, «0» – не разрешена. 277 | Заполняется для клиентов типа «МД» */ 278 | LUACPP_TABLE_FIELD(is_short_allowed, std::string) /* Признак того, является ли бумага разрешенной для продажи на заемные средства. Возможные значения: 279 | «1» – разрешена, «0» – не разрешена. 280 | Заполняется для клиентов типа «МД» */ 281 | 282 | LUACPP_STATIC_TABLE_END(); 283 | } 284 | } 285 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::buy_sell_info_getBuySellInfoEx) 286 | 287 | // candle_time (Returned by Функции O, H, L, C, V, T) 288 | namespace qlua { 289 | namespace table { 290 | LUACPP_STATIC_TABLE_BEGIN(candle_time) 291 | LUACPP_TABLE_FIELD(year, unsigned int) 292 | LUACPP_TABLE_FIELD(month, unsigned int) 293 | LUACPP_TABLE_FIELD(day, unsigned int) 294 | LUACPP_TABLE_FIELD(week_day, unsigned int) 295 | LUACPP_TABLE_FIELD(hour, unsigned int) 296 | LUACPP_TABLE_FIELD(min, unsigned int) 297 | LUACPP_TABLE_FIELD(sec, unsigned int) 298 | LUACPP_TABLE_FIELD(ms, unsigned int) 299 | LUACPP_TABLE_FIELD(count, unsigned int) // количество тиковых интервалов в секунду. Может принимать значения от «1» до «10000» включительно. 300 | LUACPP_STATIC_TABLE_END() 301 | } 302 | } 303 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::candle_time) 304 | 305 | // TODO: Make dynamic return value 306 | // current_trades_getParamEx (returned by getParamEx, getParamEx2) 307 | namespace qlua { 308 | namespace table { 309 | LUACPP_STATIC_TABLE_BEGIN(current_trades_getParamEx) 310 | LUACPP_TABLE_FIELD(param_type, unsigned int) /* Тип данных параметра, используемый в Таблице текущих торгов. Возможные значения: 311 | «1» - DOUBLE; 312 | «2» - LONG; 313 | «3» - CHAR; 314 | «4» - перечислимый тип; 315 | «5» - время; 316 | «6» - дата */ 317 | 318 | LUACPP_TABLE_FIELD(param_value, double) // Значение параметра. Для param_type = 3 значение параметра равно «0», в остальных случаях – числовое представление. Для перечислимых типов значение равно порядковому значению перечисления 319 | LUACPP_TABLE_FIELD(param_image, std::string) // Строковое значение параметра, аналогичное его представлению в таблице. В строковом представлении учитываются разделители разрядов, разделители целой и дробной части. Для перечислимых типов выводятся соответствующие им строковые значения 320 | LUACPP_TABLE_FIELD(result, unsigned int) /* Результат выполнения операции. Возможные значения: 321 | «0» - ошибка; 322 | «1» - параметр найден */ 323 | 324 | // Вызов param_value() с результатом STRING для тех случаев, когда в param_type Quik ошибочно возвращает DOUBLE/LONG 325 | 326 | struct param_value_as_string_type_policy : 327 | public ::lua::detail::table_field_policy_base { 328 | using base_type = ::lua::detail::table_field_policy_base; 329 | 330 | static inline read_type get_unsafe(::lua::state s, int idx) { 331 | return base_type::get_unsafe(s, idx, "param_value"); 332 | } 333 | 334 | static inline void apply_unsafe(::lua::state s, int idx, std::function f) { 335 | base_type::apply_unsafe(s, idx, f, "param_value"); 336 | } 337 | 338 | static inline void set(::lua::state s, int idx, const std::string& value) { 339 | base_type::set(s, idx, value, "param_value"); 340 | } 341 | }; 342 | ::lua::entity param_value_as_string{s_, idx_}; 343 | 344 | 345 | LUACPP_STATIC_TABLE_END() 346 | } 347 | } 348 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::current_trades_getParamEx) 349 | 350 | // class_info (Returned by getClassInfo) 351 | namespace qlua { 352 | namespace table { 353 | LUACPP_STATIC_TABLE_BEGIN(class_info_getClassInfo) 354 | LUACPP_TABLE_FIELD(firmid, const char*) // Код фирмы 355 | LUACPP_TABLE_FIELD(name, const char*) // Наименование класса 356 | LUACPP_TABLE_FIELD(code, const char*) // Код класса 357 | LUACPP_TABLE_FIELD(npars, unsigned int) // Количество параметров в классе 358 | LUACPP_TABLE_FIELD(nsecs, unsigned int) // Количество бумаг в классе 359 | LUACPP_STATIC_TABLE_END() 360 | } 361 | } 362 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::class_info_getClassInfo) 363 | 364 | // chart_time (Returned by ds:T) 365 | namespace qlua { 366 | namespace table { 367 | LUACPP_STATIC_TABLE_BEGIN(chart_time) 368 | LUACPP_TABLE_FIELD(year, unsigned int) 369 | LUACPP_TABLE_FIELD(month, unsigned int) 370 | LUACPP_TABLE_FIELD(day, unsigned int) 371 | LUACPP_TABLE_FIELD(week_day, unsigned int) 372 | LUACPP_TABLE_FIELD(hour, unsigned int) 373 | LUACPP_TABLE_FIELD(min, unsigned int) 374 | LUACPP_TABLE_FIELD(sec, unsigned int) 375 | LUACPP_TABLE_FIELD(ms, unsigned int) 376 | LUACPP_TABLE_FIELD(count, unsigned int) 377 | LUACPP_STATIC_TABLE_END() 378 | } 379 | } 380 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::chart_time) 381 | -------------------------------------------------------------------------------- /src/qlua/structs/level2_quotes.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // level2_quotes_record 4 | namespace qlua { 5 | namespace table { 6 | LUACPP_STATIC_TABLE_BEGIN(level2_quotes_lua_record) 7 | LUACPP_TABLE_FIELD(price, std::string) 8 | LUACPP_TABLE_FIELD(quantity, std::string) 9 | LUACPP_STATIC_TABLE_END() 10 | } 11 | } 12 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::level2_quotes_lua_record) 13 | 14 | namespace qlua { 15 | namespace table { 16 | struct level2_quotes_record { 17 | const std::string price; 18 | const std::string quantity; 19 | }; 20 | 21 | struct level2_quotes { 22 | level2_quotes(const lua::state& l, const size_t idx) : 23 | l_(l), idx_(int(idx)) { 24 | if (!l_.istable(idx_)) { 25 | throw std::runtime_error("level2_quotes: can't create, not a table"); 26 | } 27 | } 28 | 29 | const std::string bid_count() const { 30 | l_.push("bid_count"); 31 | l_.rawget(idx_ - 1); 32 | auto rslt = ::lua::entity<::lua::type_policy>(l_, -1).get(); 33 | l_.pop(1); 34 | return rslt; 35 | } 36 | 37 | const std::string offer_count() const { 38 | l_.push("offer_count"); 39 | l_.rawget(idx_ - 1); 40 | auto rslt = ::lua::entity<::lua::type_policy>(l_, -1).get(); 41 | l_.pop(1); 42 | return rslt; 43 | } 44 | 45 | const std::vector offer() const { 46 | return get_table("offer"); 47 | } 48 | 49 | const std::vector bid() const { 50 | return get_table("bid"); 51 | } 52 | 53 | private: 54 | const lua::state& l_; 55 | const int idx_; 56 | 57 | const std::vector get_table(const char* name) const { 58 | std::vector rslt; 59 | l_.push(name); 60 | l_.rawget(idx_ - 1); 61 | if (l_.istable(-1)) { 62 | auto sz = l_.objlen(-1); 63 | for (int i = 0; i < sz; ++i) { 64 | l_.rawgeti(-1, i + 1); 65 | auto rec = ::lua::entity<::lua::type_policy<::qlua::table::level2_quotes_lua_record>>(l_, -1)(); 66 | rslt.push_back({rec.price(), rec.quantity()}); 67 | l_.pop(1); 68 | } 69 | } else { 70 | throw std::runtime_error("level2_quote get record table failed: not a table"); 71 | } 72 | l_.pop(1); 73 | return rslt; 74 | } 75 | }; 76 | } 77 | } 78 | -------------------------------------------------------------------------------- /src/qlua/structs/standalone.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /* 4 | QLUA tables structures 5 | Список по "Таблицы, используемые в функциях «getItem», «getNumberOf» и «SearchItems»"; по таблицам, возвращаемым коллбеками 6 | */ 7 | #include 8 | 9 | #include 10 | 11 | #include "datetime.hpp" 12 | 13 | // Regex: *\(.*?\) +\(.*?\) +\(.*\)$LUACPP_TABLE_FIELD(\1, \2) // \3 14 | 15 | // firms "Фирмы" 16 | // Object names in qlua.chm: firm 17 | namespace qlua { 18 | namespace table { 19 | LUACPP_STATIC_TABLE_BEGIN(firms) 20 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 21 | LUACPP_TABLE_FIELD(firm_name, std::string) // Название класса 22 | LUACPP_TABLE_FIELD(status, unsigned int) // Статус 23 | LUACPP_TABLE_FIELD(exchange, std::string) // Торговая площадка 24 | LUACPP_STATIC_TABLE_END() 25 | } 26 | } 27 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::firms) 28 | 29 | // classes "Классы" 30 | namespace qlua { 31 | namespace table { 32 | LUACPP_STATIC_TABLE_BEGIN(classes) 33 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 34 | LUACPP_TABLE_FIELD(name, std::string) // Название класса 35 | LUACPP_TABLE_FIELD(code, std::string) // Код класса 36 | LUACPP_TABLE_FIELD(npars, unsigned int) // Количество параметров в классе 37 | LUACPP_TABLE_FIELD(nsecs, unsigned int) // Количество бумаг в классе 38 | LUACPP_STATIC_TABLE_END() 39 | } 40 | } 41 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::classes) 42 | 43 | // securities "Инструменты" (ценные бумаги) 44 | namespace qlua { 45 | namespace table { 46 | LUACPP_STATIC_TABLE_BEGIN(securities) 47 | LUACPP_TABLE_FIELD(code, std::string) // Код инструмента 48 | LUACPP_TABLE_FIELD(name, std::string) // Наименование инструмента 49 | LUACPP_TABLE_FIELD(short_name, std::string) // Короткое наименование инструмента 50 | LUACPP_TABLE_FIELD(class_code, std::string) // Код класса инструментов 51 | LUACPP_TABLE_FIELD(class_name, std::string) // Наименование класса инструментов 52 | LUACPP_TABLE_FIELD(face_value, double) // Номинал 53 | LUACPP_TABLE_FIELD(face_unit, std::string) // Валюта номинала 54 | LUACPP_TABLE_FIELD(scale, unsigned int) // Точность (количество значащих цифр после запятой) 55 | LUACPP_TABLE_FIELD(mat_date, unsigned int) // Дата погашения 56 | LUACPP_TABLE_FIELD(lot_size, double) // Размер лота 57 | LUACPP_TABLE_FIELD(isin_code, std::string) // ISIN 58 | LUACPP_TABLE_FIELD(min_price_step, double) // Минимальный шаг цены 59 | LUACPP_TABLE_FIELD(bsid, std::string) // Bloomberg ID 60 | LUACPP_TABLE_FIELD(cusip_code, std::string) // CUSIP 61 | LUACPP_TABLE_FIELD(stock_code, std::string) // StockCode 62 | LUACPP_TABLE_FIELD(couponvalue, double) // Размер купона 63 | LUACPP_TABLE_FIELD(sell_leg_classcode, std::string) // Код класса инструмента ноги на продажу 64 | LUACPP_TABLE_FIELD(sell_leg_seccode, std::string) // Код инструмента ноги на продажу 65 | LUACPP_TABLE_FIELD(first_currcode, std::string) // Код котируемой валюты в паре 66 | LUACPP_TABLE_FIELD(second_currcode, std::string) // Код базовой валюты в паре 67 | LUACPP_TABLE_FIELD(buy_leg_classcode, std::string) // Код класса инструмента ноги на покупку 68 | LUACPP_TABLE_FIELD(buy_leg_seccode, std::string) // Код инструмента ноги на покупку 69 | LUACPP_TABLE_FIELD(base_active_classcode, std::string) // Код класса базового актива 70 | LUACPP_TABLE_FIELD(base_active_seccode, std::string) // Базовый актив 71 | LUACPP_TABLE_FIELD(buy_mat_date, int) // Дата расчетов сделки на покупку 72 | LUACPP_TABLE_FIELD(sell_mat_date, int) // Дата расчетов сделки на продажу 73 | LUACPP_TABLE_FIELD(option_strike, double) // Страйк опциона 74 | LUACPP_TABLE_FIELD(qty_multiplier, unsigned int) // Кратность при вводе количества 75 | LUACPP_TABLE_FIELD(step_price_currency, std::string) // Валюта шага цены 76 | LUACPP_TABLE_FIELD(sedol_code, std::string) // SEDOL 77 | LUACPP_TABLE_FIELD(cfi_code, std::string) // CFI 78 | LUACPP_TABLE_FIELD(ric_code, std::string) // RIC 79 | LUACPP_TABLE_FIELD(buybackdate, int) // Дата оферты 80 | LUACPP_TABLE_FIELD(buybackprice, int) // Цена оферты 81 | LUACPP_TABLE_FIELD(list_level, int) // Уровень листинга 82 | LUACPP_TABLE_FIELD(qty_scale, double) // Точность количества 83 | LUACPP_TABLE_FIELD(yieldatprevwaprice, double) // Доходность по предыдущей оценке 84 | LUACPP_TABLE_FIELD(regnumber, std::string) // Регистрационный номер 85 | LUACPP_TABLE_FIELD(trade_currency, std::string) // Валюта торгов 86 | LUACPP_TABLE_FIELD(second_curr_qty_scale, double) // Точность количества котируемой валюты 87 | LUACPP_TABLE_FIELD(first_curr_qty_scale, double) // Точность количества базовой валюты 88 | LUACPP_TABLE_FIELD(accruedint, double) // Накопленный купонный доход 89 | LUACPP_TABLE_FIELD(stock_name, std::string) // Код деривативного контракта в формате QUIK 90 | LUACPP_TABLE_FIELD(nextcoupon, int) // Дата выплаты купона 91 | LUACPP_TABLE_FIELD(couponperiod, int) // Длительность купона 92 | LUACPP_STATIC_TABLE_END() 93 | } 94 | } 95 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::securities) 96 | 97 | // trade_accounts "Торговые счета" 98 | namespace qlua { 99 | namespace table { 100 | LUACPP_STATIC_TABLE_BEGIN(trade_accounts) 101 | LUACPP_TABLE_FIELD(class_codes, std::string) // Список кодов классов, разделенных символом «|» 102 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 103 | LUACPP_TABLE_FIELD(trdaccid, std::string) // Код торгового счета 104 | LUACPP_TABLE_FIELD(description, std::string) // Описание 105 | LUACPP_TABLE_FIELD(fullcoveredsell, unsigned int) /* Запрет необеспеченных продаж. Возможные значения: 106 | «0» – Нет; 107 | «1» – Да */ 108 | LUACPP_TABLE_FIELD(main_trdaccid, std::string) // Номер основного торгового счета 109 | LUACPP_TABLE_FIELD(bankid_t0, std::string) // Расчетная организация по «Т0» 110 | LUACPP_TABLE_FIELD(bankid_tplus, std::string) // Расчетная организация по «Т+» 111 | LUACPP_TABLE_FIELD(trdacc_type, unsigned int) // Тип торгового счета 112 | LUACPP_TABLE_FIELD(depunitid, std::string) // Раздел счета Депо 113 | LUACPP_TABLE_FIELD(status, unsigned int) /* Статус торгового счета. Возможные значения: 114 | «0» – операции разрешены; 115 | «1» – операции запрещены 116 | */ 117 | LUACPP_TABLE_FIELD(firmuse, unsigned int) /* Тип раздела. Возможные значения: 118 | «0» – раздел обеспечения; 119 | иначе – для торговых разделов */ 120 | LUACPP_TABLE_FIELD(depaccid, std::string) // Номер счета депо в депозитарии 121 | LUACPP_TABLE_FIELD(bank_acc_id, std::string) // Код дополнительной позиции по денежным средствам 122 | // Quik 8.1: Exists in qlua.chm help file, doesn't really exist in terminal 123 | //LUACPP_TABLE_FIELD(exec_market, std::string) // Идентификатор биржевой площадки 124 | LUACPP_STATIC_TABLE_END() 125 | } 126 | } 127 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::trade_accounts) 128 | 129 | // client_codes "Коды клиентов" 130 | // (Not really a table, an array of strings) 131 | namespace qlua { 132 | namespace table { 133 | using client_codes = std::string; 134 | } 135 | } 136 | 137 | // account_positions "Денежные позиции" 138 | // Object names in qlua.chm: acc_pos 139 | namespace qlua { 140 | namespace table { 141 | LUACPP_STATIC_TABLE_BEGIN(account_positions) 142 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 143 | LUACPP_TABLE_FIELD(currcode, std::string) // Код валюты 144 | LUACPP_TABLE_FIELD(tag, std::string) // Тег расчетов 145 | LUACPP_TABLE_FIELD(description, std::string) // Описание 146 | LUACPP_TABLE_FIELD(openbal, double) // Входящий остаток 147 | LUACPP_TABLE_FIELD(currentpos, double) // Текущий остаток 148 | LUACPP_TABLE_FIELD(plannedpos, double) // Плановый остаток 149 | LUACPP_TABLE_FIELD(limit1, double) // Внешнее ограничение по деньгам 150 | LUACPP_TABLE_FIELD(limit2, double) // Внутреннее (собственное) ограничение по деньгам 151 | LUACPP_TABLE_FIELD(orderbuy, double) // В заявках на продажу 152 | LUACPP_TABLE_FIELD(ordersell, double) // В заявках на покупку 153 | LUACPP_TABLE_FIELD(netto, double) // Нетто-позиция 154 | LUACPP_TABLE_FIELD(plannedbal, double) // Плановая позиция 155 | LUACPP_TABLE_FIELD(debit, double) // Дебет 156 | LUACPP_TABLE_FIELD(credit, double) // Кредит 157 | LUACPP_TABLE_FIELD(bank_acc_id, std::string) // Идентификатор счета 158 | LUACPP_TABLE_FIELD(margincall, double) // Маржинальное требование на начало торгов 159 | LUACPP_TABLE_FIELD(settlebal, double) // Плановая позиция после проведения расчетов 160 | LUACPP_STATIC_TABLE_END() 161 | } 162 | } 163 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::account_positions) 164 | 165 | // orders "Заявки" 166 | // Object names in qlua.chm: order "Таблица с параметрами заявки" 167 | namespace qlua { 168 | namespace table { 169 | LUACPP_STATIC_TABLE_BEGIN(orders) 170 | LUACPP_TABLE_FIELD(order_num, std::string) // Номер заявки в торговой системе 171 | LUACPP_TABLE_FIELD(flags, unsigned int) // Набор битовых флагов 172 | LUACPP_TABLE_FIELD(brokerref, std::string) // Комментарий, обычно: <код клиента>/<номер поручения> 173 | LUACPP_TABLE_FIELD(userid, std::string) // Идентификатор трейдера 174 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 175 | LUACPP_TABLE_FIELD(account, std::string) // Торговый счет 176 | LUACPP_TABLE_FIELD(price, double) // Цена 177 | LUACPP_TABLE_FIELD(qty, unsigned int) // Количество в лотах 178 | LUACPP_TABLE_FIELD(balance, unsigned int) // Остаток 179 | LUACPP_TABLE_FIELD(value, double) // Объем в денежных средствах 180 | LUACPP_TABLE_FIELD(accruedint, double) // Накопленный купонный доход 181 | LUACPP_TABLE_FIELD(yield, double) // Доходность 182 | LUACPP_TABLE_FIELD(trans_id, unsigned int) // Идентификатор транзакции 183 | LUACPP_TABLE_FIELD(client_code, std::string) // Код клиента 184 | LUACPP_TABLE_FIELD(price2, double) // Цена выкупа 185 | LUACPP_TABLE_FIELD(settlecode, std::string) // Код расчетов 186 | LUACPP_TABLE_FIELD(uid, unsigned int) // Идентификатор пользователя 187 | LUACPP_TABLE_FIELD(canceled_uid, unsigned int) // Идентификатор пользователя, снявшего заявку 188 | LUACPP_TABLE_FIELD(exchange_code, std::string) // Код биржи в торговой системе 189 | LUACPP_TABLE_FIELD(activation_time, int) // Время активации 190 | LUACPP_TABLE_FIELD(linkedorder, unsigned int) // Номер заявки в торговой системе 191 | LUACPP_TABLE_FIELD(expiry, int) // Дата окончания срока действия заявки 192 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код бумаги заявки 193 | LUACPP_TABLE_FIELD(class_code, std::string) // Код класса заявки 194 | QLUACPP_DATETIME_TABLE_FIELD(datetime) // Дата и время 195 | QLUACPP_DATETIME_TABLE_FIELD(withdraw_datetime) // Дата и время снятия заявки 196 | LUACPP_TABLE_FIELD(bank_acc_id, std::string) // Идентификатор расчетного счета/кода в клиринговой организации 197 | LUACPP_TABLE_FIELD(value_entry_type, unsigned int) /* Способ указания объема заявки. Возможные значения: 198 | 199 | «0» – по количеству, 200 | «1» – по объему */ 201 | LUACPP_TABLE_FIELD(repoterm, double) // Срок РЕПО, в календарных днях 202 | LUACPP_TABLE_FIELD(repovalue, double) // Сумма РЕПО на текущую дату. Отображается с точностью 2 знака 203 | LUACPP_TABLE_FIELD(repo2value, double) // Объём сделки выкупа РЕПО. Отображается с точностью 2 знака 204 | LUACPP_TABLE_FIELD(repo_value_balance, double) // Остаток суммы РЕПО за вычетом суммы привлеченных или предоставленных по сделке РЕПО денежных средств в неисполненной части заявки, по состоянию на текущую дату. Отображается с точностью 2 знака 205 | LUACPP_TABLE_FIELD(start_discount, double) // Начальный дисконт, в % 206 | LUACPP_TABLE_FIELD(reject_reason, std::string) // Причина отклонения заявки брокером 207 | LUACPP_TABLE_FIELD(ext_order_flags, unsigned int) // Битовое поле для получения специфических параметров с западных площадок 208 | LUACPP_TABLE_FIELD(min_qty, unsigned int) // Минимально допустимое количество, которое можно указать в заявке по данному инструменту. Если имеет значение «0», значит ограничение по количеству не задано 209 | LUACPP_TABLE_FIELD(exec_type, unsigned int) // Тип исполнения заявки. Если имеет значение «0», значит значение не задано 210 | LUACPP_TABLE_FIELD(side_qualifier, unsigned int) // Поле для получения параметров по западным площадкам. Если имеет значение «0», значит значение не задано 211 | LUACPP_TABLE_FIELD(acnt_type, unsigned int) // Поле для получения параметров по западным площадкам. Если имеет значение «0», значит значение не задано 212 | LUACPP_TABLE_FIELD(capacity, double) // Поле для получения параметров по западным площадкам. Если имеет значение «0», значит значение не задано 213 | LUACPP_TABLE_FIELD(passive_only_order, unsigned int) // Поле для получения параметров по западным площадкам. Если имеет значение «0», значит значение не задано 214 | LUACPP_TABLE_FIELD(visible, unsigned int) // Видимое количество. Параметр айсберг-заявок, для обычных заявок выводится значение: «0» 215 | 216 | LUACPP_TABLE_FIELD(awg_price, double) // Средняя цена приобретения. Актуально, когда заявка выполнилась частями 217 | LUACPP_TABLE_FIELD(expiry_time, int) // Время окончания срока действия заявки в формате <ЧЧММСС DESIGNTIMESP=19552>. Для GTT-заявок, используется вместе со сроком истечения заявки (Expiry) 218 | LUACPP_TABLE_FIELD(revision_number, unsigned int) // Номер ревизии заявки. Используется, если заявка была заменена с сохранением номера 219 | LUACPP_TABLE_FIELD(price_currency, std::string) // Валюта цены заявки 220 | LUACPP_TABLE_FIELD(ext_order_status, unsigned int) /* Расширенный статус заявки. Возможные значения: 221 | «0» (по умолчанию) – не определено; 222 | «1» – заявка активна; 223 | «2» – заявка частично исполнена; 224 | «3» – заявка исполнена; 225 | «4» – заявка отменена; 226 | «5» – заявка заменена; 227 | «6» – заявка в состоянии отмены; 228 | «7» – заявка отвергнута; 229 | «8» – приостановлено исполнение заявки; 230 | «9» – заявка в состоянии регистрации; 231 | «10» – заявка снята по времени действия; 232 | «11» – заявка в состоянии замены 233 | */ 234 | 235 | LUACPP_TABLE_FIELD(accepted_uid, unsigned int) // UID пользователя-менеджера, подтвердившего заявку при работе в режиме с подтверждениями 236 | LUACPP_TABLE_FIELD(filled_value, double) // Исполненный объем заявки в валюте цены для частично или полностью исполненных заявок 237 | LUACPP_TABLE_FIELD(extref, std::string) // Внешняя ссылка, используется для обратной связи с внешними системами 238 | LUACPP_TABLE_FIELD(settle_currency, std::string) // Валюта расчетов по заявке 239 | LUACPP_TABLE_FIELD(on_behalf_of_uid, unsigned int) // UID пользователя, от имени которого выставлена заявка 240 | LUACPP_TABLE_FIELD(client_qualifier, unsigned int) /* Квалификатор клиента, от имени которого выставлена заявка. Возможные значения: 241 | «0» – не определено; 242 | «1» – Natural Person; 243 | «3» – Legal Entity 244 | */ 245 | 246 | LUACPP_TABLE_FIELD(client_short_code, unsigned int) // Краткий идентификатор клиента, от имени которого выставлена заявка 247 | LUACPP_TABLE_FIELD(investment_decision_maker_qualifier, unsigned int) /* Квалификатор принявшего решение о выставлении заявки. Возможные значения: 248 | «0» – не определено; 249 | «1» – Natural Person; 250 | «2» – Algorithm 251 | */ 252 | 253 | LUACPP_TABLE_FIELD(investment_decision_maker_short_code, unsigned int) // Краткий идентификатор принявшего решение о выставлении заявки 254 | LUACPP_TABLE_FIELD(executing_trader_qualifier, unsigned int) /* Квалификатор трейдера, исполнившего заявку. Возможные значения: 255 | «0» – не определено; 256 | «1» – Natural Person; 257 | «2» – Algorithm 258 | */ 259 | 260 | LUACPP_TABLE_FIELD(executing_trader_short_code, unsigned int) // Краткий идентификатор трейдера, исполнившего заявку 261 | 262 | LUACPP_STATIC_TABLE_END() 263 | } 264 | } 265 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::orders) 266 | 267 | // futures_client_holding "Позиции по клиентским счетам (фьючерсы)" 268 | // Object names in qlua.chm: fut_pos "Таблица с описанием позиции по срочному рынку" 269 | namespace qlua { 270 | namespace table { 271 | LUACPP_STATIC_TABLE_BEGIN(futures_client_holding) 272 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 273 | LUACPP_TABLE_FIELD(trdaccid, std::string) // Торговый счет 274 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код фьючерсного контракта 275 | LUACPP_TABLE_FIELD(type, double) /* Тип лимита. Возможные значения: 276 | «0» – не определён; 277 | «1» – основной счет; 278 | «2» – клиентские и дополнительные счета; 279 | «4» – все счета торг. членов */ 280 | LUACPP_TABLE_FIELD(startbuy, double) // Входящие длинные позиции 281 | LUACPP_TABLE_FIELD(startsell, double) // Входящие короткие позиции 282 | LUACPP_TABLE_FIELD(startnet, double) // Входящие чистые позиции 283 | LUACPP_TABLE_FIELD(todaybuy, double) // Текущие длинные позиции 284 | LUACPP_TABLE_FIELD(todaysell, double) // Текущие короткие позиции 285 | LUACPP_TABLE_FIELD(totalnet, double) // Текущие чистые позиции 286 | LUACPP_TABLE_FIELD(openbuys, double) // Активные на покупку 287 | LUACPP_TABLE_FIELD(opensells, double) // Активные на продажу 288 | LUACPP_TABLE_FIELD(cbplused, double) // Оценка текущих чистых позиций 289 | LUACPP_TABLE_FIELD(cbplplanned, double) // Плановые чистые позиции 290 | LUACPP_TABLE_FIELD(varmargin, double) // Вариационная маржа 291 | LUACPP_TABLE_FIELD(avrposnprice, double) // Эффективная цена позиций 292 | LUACPP_TABLE_FIELD(positionvalue, double) // Стоимость позиций 293 | LUACPP_TABLE_FIELD(real_varmargin, double) // Реально начисленная в ходе клиринга вариационная маржа. Отображается с точностью до 2 двух знаков. При этом, в поле «varmargin» транслируется вариационная маржа, рассчитанная с учетом установленных границ изменения цены 294 | LUACPP_TABLE_FIELD(total_varmargin, double) // Суммарная вариационная маржа по итогам основного клиринга начисленная по всем позициям. Отображается с точностью до 2 двух знаков 295 | LUACPP_TABLE_FIELD(session_status, unsigned int) /* Актуальный статус торговой сессии. Возможные значения: 296 | «0» – не определено; 297 | «1» – основная сессия; 298 | «2» – начался промклиринг; 299 | «3» – завершился промклиринг; 300 | «4» – начался основной клиринг; 301 | «5» – основной клиринг: новая сессия назначена; 302 | «6» – завершился основной клиринг; 303 | «7» – завершилась вечерняя сессия */ 304 | LUACPP_STATIC_TABLE_END() 305 | } 306 | } 307 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::futures_client_holding) 308 | 309 | // futures_client_limits "Лимиты по фьючерсам" 310 | // Object name in qlua.chm: fut_limit "Таблица с текущими значениями лимита по срочному рынку" 311 | namespace qlua { 312 | namespace table { 313 | LUACPP_STATIC_TABLE_BEGIN(futures_client_limits) 314 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 315 | LUACPP_TABLE_FIELD(trdaccid, std::string) // Торговый счет 316 | LUACPP_TABLE_FIELD(limit_type, unsigned int) /* Тип лимита. Возможные значения: 317 | «0» – «Денежные средства»; 318 | «1» – «Залоговые денежные средства»; 319 | «2» – «По совокупным средствам»; 320 | «3» – «Клиринговые денежные средства»; 321 | «4» – «Клиринговые залоговые денежные средства»; 322 | «5» – «Лимит открытых позиций на спот-рынке»; 323 | «6» – «Суммарные залоговые средства в иностранной валюте (в рублях)»; 324 | «7» – «Залоговые средства в иностранной валюте» */ 325 | 326 | LUACPP_TABLE_FIELD(liquidity_coef, double) // Коэффициент ликвидности 327 | LUACPP_TABLE_FIELD(cbp_prev_limit, double) // Предыдущий лимит открытых позиций на спот-рынке» 328 | LUACPP_TABLE_FIELD(cbplimit, double) // Лимит открытых позиций 329 | LUACPP_TABLE_FIELD(cbplused, double) // Текущие чистые позиции 330 | LUACPP_TABLE_FIELD(cbplplanned, double) // Плановые чистые позиции 331 | LUACPP_TABLE_FIELD(varmargin, double) // Вариационная маржа 332 | LUACPP_TABLE_FIELD(accruedint, double) // Накопленный доход 333 | LUACPP_TABLE_FIELD(cbplused_for_orders, double) // Текущие чистые позиции (под заявки) 334 | LUACPP_TABLE_FIELD(cbplused_for_positions, double) // Текущие чистые позиции (под открытые позиции) 335 | LUACPP_TABLE_FIELD(options_premium, double) // Премия по опционам 336 | LUACPP_TABLE_FIELD(ts_comission, double) // Биржевые сборы 337 | LUACPP_TABLE_FIELD(kgo, double) // Коэффициент клиентского гарантийного обеспечения 338 | LUACPP_TABLE_FIELD(currcode, std::string) // Валюта, в которой транслируется ограничение 339 | LUACPP_TABLE_FIELD(real_varmargin, double) // Реально начисленная в ходе клиринга вариационная маржа. Отображается с точностью до 2 двух знаков. При этом в поле «varmargin» транслируется вариационная маржа, рассчитанная с учетом установленных границ изменения цены 340 | LUACPP_STATIC_TABLE_END() 341 | } 342 | } 343 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::futures_client_limits) 344 | 345 | // all_trades "Обезличенные сделки" 346 | // Object names in qlua.chm: alltrade 347 | namespace qlua { 348 | namespace table { 349 | LUACPP_STATIC_TABLE_BEGIN(all_trades) 350 | 351 | LUACPP_TABLE_FIELD(trade_num, std::string) // Номер сделки в торговой системе 352 | LUACPP_TABLE_FIELD(flags, unsigned int) // Набор битовых флагов 353 | LUACPP_TABLE_FIELD(price, double) // Цена 354 | LUACPP_TABLE_FIELD(qty, unsigned int) // Количество бумаг в последней сделке в лотах 355 | LUACPP_TABLE_FIELD(value, double) // Объем в денежных средствах 356 | LUACPP_TABLE_FIELD(accruedint, double) // Накопленный купонный доход 357 | LUACPP_TABLE_FIELD(yield, double) // Доходность 358 | LUACPP_TABLE_FIELD(settlecode, std::string) // Код расчетов 359 | LUACPP_TABLE_FIELD(reporate, double) // Ставка РЕПО (%) 360 | LUACPP_TABLE_FIELD(repovalue, double) // Сумма РЕПО 361 | LUACPP_TABLE_FIELD(repo2value, double) // Объем выкупа РЕПО 362 | LUACPP_TABLE_FIELD(repoterm, double) // Срок РЕПО в днях 363 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код бумаги заявки 364 | LUACPP_TABLE_FIELD(class_code, std::string) // Код класса 365 | QLUACPP_DATETIME_TABLE_FIELD(datetime) // Дата и время 366 | LUACPP_TABLE_FIELD(period, unsigned int) /* Период торговой сессии. Возможные значения: 367 | 368 | «0» – Открытие; 369 | «1» – Нормальный; 370 | «2» – Закрытие 371 | */ 372 | LUACPP_TABLE_FIELD(open_interest, double) // Открытый интерес 373 | LUACPP_TABLE_FIELD(exchange_code, std::string) // Код биржи в торговой системе 374 | LUACPP_TABLE_FIELD(exec_market, std::string) // Площадка исполнения 375 | LUACPP_STATIC_TABLE_END() 376 | } 377 | } 378 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::all_trades) 379 | 380 | 381 | // futures_limit_delete "Таблица с параметрами удаляемого лимита по срочному рынку" (callback) 382 | // Object names in qlua.chm: lim_del 383 | namespace qlua { 384 | namespace table { 385 | LUACPP_STATIC_TABLE_BEGIN(futures_limit_delete) 386 | LUACPP_TABLE_FIELD(trdaccid, std::string) // Код торгового счета 387 | LUACPP_TABLE_FIELD(limit_type, unsigned int) /* Тип лимита. Возможные значения: 388 | «0» – «Денежные средства», 389 | «1» – «Залоговые денежные средства», 390 | «2» – «По совокупным средствам»; 391 | «3» – «Клиринговые денежные средства»; 392 | «4» – «Клиринговые залоговые денежные средства»; 393 | «5» – «Лимит открытых позиций на спот-рынке»; 394 | «6» – «Суммарные залоговые средства в иностранной валюте (в рублях)»; 395 | «7» – «Залоговые средства в иностранной валюте» */ 396 | LUACPP_STATIC_TABLE_END() 397 | } 398 | } 399 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::futures_limit_delete) 400 | 401 | // money_limits "Позиции по деньгам" 402 | // Old: 403 | // "Лимиты по денежным средствам" 404 | // Object names in qlua.chm: mlimit 405 | // "Таблица «Позиции по деньгам»" 406 | // Old: 407 | // "Таблица с текущими значениями денежного лимита" 408 | namespace qlua { 409 | namespace table { 410 | LUACPP_STATIC_TABLE_BEGIN(money_limits) 411 | LUACPP_TABLE_FIELD(currcode, std::string) // Код валюты 412 | LUACPP_TABLE_FIELD(tag, std::string) // Код позиции 413 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 414 | LUACPP_TABLE_FIELD(client_code, std::string) // Код клиента 415 | LUACPP_TABLE_FIELD(openbal, double) // Входящий остаток 416 | LUACPP_TABLE_FIELD(openlimit, double) // Входящий лимит 417 | LUACPP_TABLE_FIELD(currentbal, double) // Текущий остаток 418 | LUACPP_TABLE_FIELD(currentlimit, double) // Текущий лимит 419 | LUACPP_TABLE_FIELD(locked, double) // Заблокировано. Сумма средств, заблокированных под исполнение заявок клиента 420 | LUACPP_TABLE_FIELD(locked_value_coef, double) // Стоимость активов в заявках на покупку немаржинальных инструментов 421 | LUACPP_TABLE_FIELD(locked_margin_value, double) // Стоимость активов в заявках на покупку маржинальных инструментов 422 | LUACPP_TABLE_FIELD(leverage, double) // Плечо 423 | LUACPP_TABLE_FIELD(limit_kind, int) /* Срок расчётов. Возможные значения: 424 | положительные целые числа, начиная с «0», соответствующие срокам расчётов из таблицы «Позиции по деньгам»: «0» – T0, «1» – T1, «2» – T2 и т.д.; 425 | отрицательные целые числа – технологические лимиты (используются для внутренней работы системы QUIK) */ 426 | 427 | LUACPP_TABLE_FIELD(wa_position_price, double) // Средневзвешенная цена приобретения позиции 428 | LUACPP_TABLE_FIELD(orders_collateral, double) // Гарантийное обеспечение заявок 429 | LUACPP_TABLE_FIELD(positions_collateral, double) // Гарантийное обеспечение позиций 430 | LUACPP_STATIC_TABLE_END() 431 | } 432 | } 433 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::money_limits) 434 | 435 | // money_limit_delete "Таблица с параметрами удаляемого денежного лимита" (callback) 436 | // Object names in qlua.chm: mlimit_del 437 | namespace qlua { 438 | namespace table { 439 | LUACPP_STATIC_TABLE_BEGIN(money_limit_delete) 440 | LUACPP_TABLE_FIELD(currcode, std::string) // Код валюты 441 | LUACPP_TABLE_FIELD(tag, std::string) // Тег расчетов 442 | LUACPP_TABLE_FIELD(client_code, std::string) // Код клиента 443 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 444 | LUACPP_TABLE_FIELD(limit_kind, int) /* Вид лимита. Возможные значения: 445 | положительные целые числа, начиная с «0», соответствующие видам лимитов из таблицы «Лимиты по денежным средствам»: «0» – T0, «1» – T1, «2» – T2 и т.д.; 446 | отрицательные целые числа – технологические лимиты (используются для внутренней работы системы QUIK) */ 447 | LUACPP_STATIC_TABLE_END() 448 | } 449 | } 450 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::money_limit_delete) 451 | 452 | // depo_limits "Лимиты по бумагам" 453 | // Object names in qlua.chm: dlimit 454 | namespace qlua { 455 | namespace table { 456 | LUACPP_STATIC_TABLE_BEGIN(depo_limits) 457 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код бумаги 458 | LUACPP_TABLE_FIELD(trdaccid, std::string) // Счет депо 459 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 460 | LUACPP_TABLE_FIELD(client_code, std::string) // Код клиента 461 | LUACPP_TABLE_FIELD(openbal, double) // Входящий остаток по бумагам 462 | LUACPP_TABLE_FIELD(openlimit, double) // Входящий лимит по бумагам 463 | LUACPP_TABLE_FIELD(currentbal, double) // Текущий остаток по бумагам 464 | LUACPP_TABLE_FIELD(currentlimit, double) // Текущий лимит по бумагам 465 | LUACPP_TABLE_FIELD(locked_sell, double) // Заблокировано на продажу количества лотов 466 | LUACPP_TABLE_FIELD(locked_buy, double) // Заблокировано на покупку количества лотов 467 | LUACPP_TABLE_FIELD(locked_buy_value, double) // Стоимость ценных бумаг, заблокированных под покупку 468 | LUACPP_TABLE_FIELD(locked_sell_value, double) // Стоимость ценных бумаг, заблокированных под продажу 469 | LUACPP_TABLE_FIELD(wa_position_price, double) // Цена приобретения 470 | LUACPP_TABLE_FIELD(limit_kind, int) /* Вид лимита. Возможные значения: 471 | числа, начиная с «0», соответствующие видам лимитов из таблицы «Лимиты по бумагам»: «0» – T0, «1» – T1, «2» – T2 и т.д.; 472 | числа – технологические лимиты (используются для внутренней работы системы QUIK)*/ 473 | LUACPP_STATIC_TABLE_END() 474 | } 475 | } 476 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::depo_limits) 477 | 478 | // depo_limit_delete "Таблица с параметрами удаляемого лимита по бумагам" (callback) 479 | // Object names in qlua.chm: dlimit_del 480 | namespace qlua { 481 | namespace table { 482 | LUACPP_STATIC_TABLE_BEGIN(depo_limit_delete) 483 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код инструмента 484 | LUACPP_TABLE_FIELD(trdaccid, std::string) // Код торгового счета 485 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 486 | LUACPP_TABLE_FIELD(client_code, std::string) // Код клиента 487 | LUACPP_TABLE_FIELD(limit_kind, int) /* Вид лимита. Возможные значения: 488 | положительные целые числа, начиная с «0», соответствующие видам лимитов из таблицы «Лимиты по бумагам»: «0» – T0, «1» – T1, «2» – T2 и т.д.; 489 | отрицательные целые числа – технологические лимиты (используются для внутренней работы системы QUIK) */ 490 | LUACPP_STATIC_TABLE_END() 491 | } 492 | } 493 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::depo_limit_delete) 494 | 495 | // trades "Сделки" 496 | // Object names in qlua.chm: trade "Таблица с параметрами сделки" 497 | namespace qlua { 498 | namespace table { 499 | LUACPP_STATIC_TABLE_BEGIN(trades) 500 | LUACPP_TABLE_FIELD(trade_num, std::string) // Номер сделки в торговой системе 501 | LUACPP_TABLE_FIELD(order_num, std::string) // Номер заявки в торговой системе 502 | LUACPP_TABLE_FIELD(brokerref, std::string) // Комментарий, обычно: <код клиента>/<номер поручения> 503 | LUACPP_TABLE_FIELD(userid, std::string) // Идентификатор трейдера 504 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор дилера 505 | LUACPP_TABLE_FIELD(canceled_uid, unsigned int) // Идентификатор пользователя, отказавшегося от сделки 506 | LUACPP_TABLE_FIELD(account, std::string) // Торговый счет 507 | LUACPP_TABLE_FIELD(price, double) // Цена 508 | LUACPP_TABLE_FIELD(qty, unsigned int) // Количество бумаг в последней сделке в лотах 509 | LUACPP_TABLE_FIELD(value, double) // Объем в денежных средствах 510 | LUACPP_TABLE_FIELD(accruedint, double) // Накопленный купонный доход 511 | LUACPP_TABLE_FIELD(yield, double) // Доходность 512 | LUACPP_TABLE_FIELD(settlecode, std::string) // Код расчетов 513 | LUACPP_TABLE_FIELD(cpfirmid, std::string) // Код фирмы партнера 514 | LUACPP_TABLE_FIELD(flags, unsigned int) // Набор битовых флагов 515 | LUACPP_TABLE_FIELD(price2, double) // Цена выкупа 516 | LUACPP_TABLE_FIELD(reporate, double) // Ставка РЕПО (%) 517 | LUACPP_TABLE_FIELD(client_code, std::string) // Код клиента 518 | LUACPP_TABLE_FIELD(accrued2, double) // Доход (%) на дату выкупа 519 | LUACPP_TABLE_FIELD(repoterm, double) // Срок РЕПО, в календарных днях 520 | LUACPP_TABLE_FIELD(repovalue, double) // Сумма РЕПО 521 | LUACPP_TABLE_FIELD(repo2value, double) // Объем выкупа РЕПО 522 | LUACPP_TABLE_FIELD(start_discount, double) // Начальный дисконт (%) 523 | LUACPP_TABLE_FIELD(lower_discount, double) // Нижний дисконт (%) 524 | LUACPP_TABLE_FIELD(upper_discount, double) // Верхний дисконт (%) 525 | LUACPP_TABLE_FIELD(block_securities, unsigned int) // Блокировка обеспечения («Да»/«Нет») 526 | LUACPP_TABLE_FIELD(clearing_comission, double) // Клиринговая комиссия (ММВБ) 527 | LUACPP_TABLE_FIELD(exchange_comission, double) // Комиссия Фондовой биржи (ММВБ) 528 | LUACPP_TABLE_FIELD(tech_center_comission, double) // Комиссия Технического центра (ММВБ) 529 | LUACPP_TABLE_FIELD(settle_date, int) // Дата расчетов 530 | LUACPP_TABLE_FIELD(settle_currency, std::string) // Валюта расчетов 531 | LUACPP_TABLE_FIELD(trade_currency, std::string) // Валюта 532 | LUACPP_TABLE_FIELD(exchange_code, std::string) // Код биржи в торговой системе 533 | LUACPP_TABLE_FIELD(station_id, std::string) // Идентификатор рабочей станции 534 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код бумаги заявки 535 | LUACPP_TABLE_FIELD(class_code, std::string) // Код класса 536 | QLUACPP_DATETIME_TABLE_FIELD(datetime) // Дата и время 537 | LUACPP_TABLE_FIELD(bank_acc_id, std::string) // Идентификатор расчетного счета/кода в клиринговой организации 538 | LUACPP_TABLE_FIELD(broker_comission, double) // Комиссия брокера. Отображается с точностью до 2 двух знаков. Поле зарезервировано для будущего использования. 539 | LUACPP_TABLE_FIELD(linked_trade, unsigned int) // Номер витринной сделки в Торговой Системе для сделок РЕПО с ЦК и SWAP 540 | LUACPP_TABLE_FIELD(period, unsigned int) /* Период торговой сессии. Возможные значения: 541 | «0» – Открытие; 542 | «1» – Нормальный; 543 | «2» – Закрытие */ 544 | 545 | LUACPP_TABLE_FIELD(trans_id, unsigned int) // Идентификатор транзакции 546 | LUACPP_TABLE_FIELD(kind, unsigned int) /* Тип сделки. Возможные значения: 547 | «1» – Обычная; 548 | «2» – Адресная; 549 | «3» – Первичное размещение; 550 | «4» – Перевод денег/бумаг; 551 | «5» – Адресная сделка первой части РЕПО; 552 | «6» – Расчетная по операции своп; 553 | «7» – Расчетная по внебиржевой операции своп; 554 | «8» – Расчетная сделка бивалютной корзины; 555 | «9» – Расчетная внебиржевая сделка бивалютной корзины; 556 | «10» – Сделка по операции РЕПО с ЦК; 557 | «11» – Первая часть сделки по операции РЕПО с ЦК; 558 | «12» – Вторая часть сделки по операции РЕПО с ЦК; 559 | «13» – Адресная сделка по операции РЕПО с ЦК; 560 | «14» – Первая часть адресной сделки по операции РЕПО с ЦК; 561 | «15» – Вторая часть адресной сделки по операции РЕПО с ЦК; 562 | «16» – Техническая сделка по возврату активов РЕПО с ЦК; 563 | «17» – Сделка по спреду между фьючерсами разных сроков на один актив; 564 | «18» – Техническая сделка первой части от спреда между фьючерсами; 565 | «19» – Техническая сделка второй части от спреда между фьючерсами; 566 | «20» – Адресная сделка первой части РЕПО с корзиной; 567 | «21» – Адресная сделка второй части РЕПО с корзиной; 568 | «22» – Перенос позиций срочного рынка */ 569 | LUACPP_TABLE_FIELD(clearing_bank_accid, std::string) // Идентификатор счета в НКЦ (расчетный код) 570 | QLUACPP_DATETIME_TABLE_FIELD(canceled_datetime) // Дата и время снятия сделки 571 | LUACPP_TABLE_FIELD(clearing_firmid, std::string) // Идентификатор фирмы - участника клиринга 572 | LUACPP_TABLE_FIELD(system_ref, std::string) // Дополнительная информация по сделке, передаваемая торговой системой 573 | LUACPP_TABLE_FIELD(uid, unsigned int) // Идентификатор пользователя на сервере QUIK 574 | 575 | LUACPP_TABLE_FIELD(lseccode, std::string) // Приоритетное обеспечение 576 | LUACPP_TABLE_FIELD(order_revision_number, unsigned int) // Номер ревизии заявки, по которой была совершена сделка 577 | LUACPP_TABLE_FIELD(order_qty, unsigned int) // Количество в заявке на момент совершения сделки, в лотах 578 | LUACPP_TABLE_FIELD(order_price, double) // Цена в заявке на момент совершения сделки 579 | LUACPP_TABLE_FIELD(order_exchange_code, std::string) // Биржевой номер заявки 580 | LUACPP_TABLE_FIELD(exec_market, std::string) // Площадка исполнения 581 | LUACPP_TABLE_FIELD(liquidity_indicator, unsigned int) /* Индикатор ликвидности. Возможные значения: 582 | «0» – не определено; 583 | «1» – по заявке мейкера; 584 | «2» – по заявке тейкера; 585 | «3» – вывод ликвидности; 586 | «4» – по заявке в период аукциона 587 | */ 588 | 589 | LUACPP_TABLE_FIELD(extref, std::string) // Внешняя ссылка, используется для обратной связи с внешними системами 590 | LUACPP_TABLE_FIELD(ext_trade_flags, unsigned int) // Расширенные флаги, полученные от шлюза напрямую, без вмешательства сервера QUIK. Поле не заполняется 591 | LUACPP_TABLE_FIELD(on_behalf_of_uid, unsigned int) // UID пользователя, от имени которого совершена сделка 592 | LUACPP_TABLE_FIELD(client_qualifier, unsigned int) /* Квалификатор клиента, от имени которого совершена сделка. Возможные значения: 593 | «0» – не определено; 594 | «1» – Natural Person; 595 | «3» – Legal Entity 596 | */ 597 | 598 | LUACPP_TABLE_FIELD(client_short_code, unsigned int) // Краткий идентификатор клиента, от имени которого совершена сделка 599 | LUACPP_TABLE_FIELD(investment_decision_maker_qualifier, unsigned int) /* Квалификатор принявшего решение о совершении сделки. Возможные значения: 600 | «0» – не определено; 601 | «1» – Natural Person; 602 | «3» – Algorithm 603 | */ 604 | 605 | LUACPP_TABLE_FIELD(investment_decision_maker_short_code, unsigned int) // Краткий идентификатор принявшего решение о совершении сделки 606 | LUACPP_TABLE_FIELD(executing_trader_qualifier, unsigned int) /* Квалификатор трейдера, исполнившего заявку, по которой совершена сделка.Возможные значения: 607 | «0» – не определено; 608 | «1» – Natural Person; 609 | «3» – Algorithm 610 | */ 611 | 612 | LUACPP_TABLE_FIELD(executing_trader_short_code, unsigned int) // Краткий идентификатор трейдера, исполнившего заявку, по которой совершена сделка 613 | LUACPP_TABLE_FIELD(waiver_flag, unsigned int) /* Признак того, что транзакция совершена по правилам пре-трейда. Возможные значения битовых флагов: 614 | бит 0 (0x1) – RFPT; 615 | бит 1 (0x2) – NLIQ; 616 | бит 2 (0x4) – OILQ; 617 | бит 3 (0x8) – PRC; 618 | бит 4 (0x10)– SIZE; 619 | бит 5 (0x20) – ILQD 620 | */ 621 | 622 | LUACPP_TABLE_FIELD(mleg_base_sid, unsigned int) // Идентификатор базового инструмента на сервере для multileg-инструментов 623 | LUACPP_TABLE_FIELD(side_qualifier, unsigned int) /* Квалификатор операции. Возможные значения: 624 | «0» – не определено; 625 | «1» – Buy; 626 | «2» – Sell; 627 | «3» – Sell short; 628 | «4» – Sell short exempt; 629 | «5» – Sell undiclosed 630 | */ 631 | 632 | LUACPP_TABLE_FIELD(otc_post_trade_indicator, unsigned int) /* OTC post-trade индикатор. Возможные значения битовых флагов: 633 | бит 0 (0x1) – Benchmark; 634 | бит 1 (0x2) – Agency cross; 635 | бит 2 (0x4) – Large in scale; 636 | бит 3 (0x8) – Illiquid instrument; 637 | бит 4 (0x10) – Above specified size; 638 | бит 5 (0x20) – Cancellations; 639 | бит 6 (0x40) – Amendments; 640 | бит 7 (0x80) – Special dividend; 641 | бит 8 (0x100) – Price improvement; 642 | бит 9 (0x200) – Duplicative; 643 | бит 10 (0x400) – Not contributing to the price discovery process; 644 | бит 11 (0x800) – Package; 645 | бит 12 (0x1000) – Exchange for Physical 646 | */ 647 | 648 | LUACPP_TABLE_FIELD(capacity, unsigned int) /* Роль в исполнении заявки. Возможные значения: 649 | «0» – не определено; 650 | «1» – Agent; 651 | «2» – Principal; 652 | «3» – Riskless principal; 653 | «4» – CFG give up; 654 | «5» – Cross as agent; 655 | «6» – Matched principal; 656 | «7» – Proprietary; 657 | «8» – Individual; 658 | «9» – Agent for other member; 659 | «10» – Mixed; 660 | «11» – Market maker 661 | */ 662 | 663 | LUACPP_TABLE_FIELD(cross_rate, double) // Кросс-курс валюты цены сделки к валюте расчетов по сделке 664 | 665 | LUACPP_STATIC_TABLE_END() 666 | } 667 | } 668 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::trades) 669 | 670 | // stop_orders "Стоп-заявки" 671 | // Object name in qlua.chm: stop_order "Таблица с параметрами стоп-заявки" 672 | // 673 | namespace qlua { 674 | namespace table { 675 | LUACPP_STATIC_TABLE_BEGIN(stop_orders) 676 | 677 | LUACPP_TABLE_FIELD(order_num, std::string) // Регистрационный номер стоп-заявки на сервере QUIK 678 | LUACPP_TABLE_FIELD(ordertime, unsigned int) // Время выставления 679 | LUACPP_TABLE_FIELD(flags, unsigned int) // Набор битовых флагов 680 | LUACPP_TABLE_FIELD(brokerref, std::string) // Комментарий, обычно: <код клиента>/<номер поручения> 681 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор дилера 682 | LUACPP_TABLE_FIELD(account, std::string) // Торговый счет 683 | LUACPP_TABLE_FIELD(condition, unsigned int) /* Направленность стоп-цены. Возможные значения: 684 | «4» – «<=», 685 | «5» – «>=» 686 | */ 687 | 688 | LUACPP_TABLE_FIELD(condition_price, double) // Стоп-цена 689 | LUACPP_TABLE_FIELD(price, double) // Цена 690 | LUACPP_TABLE_FIELD(qty, unsigned int) // Количество в лотах 691 | LUACPP_TABLE_FIELD(linkedorder, unsigned int) // Номер заявки в торговой системе, зарегистрированной по наступлению условия стоп-цены 692 | LUACPP_TABLE_FIELD(expiry, int) // Дата окончания срока действия заявки 693 | LUACPP_TABLE_FIELD(trans_id, unsigned int) // Идентификатор транзакции 694 | LUACPP_TABLE_FIELD(client_code, std::string) // Код клиента 695 | LUACPP_TABLE_FIELD(co_order_num, std::string) // Связанная заявка 696 | LUACPP_TABLE_FIELD(co_order_price, double) // Цена связанной заявки 697 | LUACPP_TABLE_FIELD(stop_order_type, unsigned int) /* Вид стоп заявки. Возможные значения: 698 | «1» – стоп-лимит; 699 | «2» – условие по другому инструменту; 700 | «3» – со связанной заявкой; 701 | «6» – тейк-профит; 702 | «7» – стоп-лимит по исполнению активной заявки; 703 | «8» – тейк-профит по исполнению активной заявки; 704 | «9» - тейк-профит и стоп-лимит 705 | */ 706 | 707 | LUACPP_TABLE_FIELD(orderdate, int) // Дата выставления 708 | LUACPP_TABLE_FIELD(alltrade_num, std::string) // Сделка условия 709 | LUACPP_TABLE_FIELD(stopflags, unsigned int) // Набор битовых флагов 710 | LUACPP_TABLE_FIELD(offset, double) // Отступ от min/max 711 | LUACPP_TABLE_FIELD(spread, double) // Защитный спред 712 | LUACPP_TABLE_FIELD(balance, unsigned int) // Активное количество 713 | LUACPP_TABLE_FIELD(uid, unsigned int) // Идентификатор пользователя 714 | LUACPP_TABLE_FIELD(filled_qty, unsigned int) // Исполненное количество 715 | LUACPP_TABLE_FIELD(withdraw_time, int) // Время снятия заявки 716 | LUACPP_TABLE_FIELD(condition_price2, double) // Стоп-лимит цена (для заявок типа «Тэйк-профит и стоп-лимит») 717 | LUACPP_TABLE_FIELD(active_from_time, int) // Время начала периода действия заявки типа «Тэйк-профит и стоп-лимит» 718 | LUACPP_TABLE_FIELD(active_to_time, int) // Время окончания периода действия заявки типа «Тэйк-профит и стоп-лимит» 719 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код инструмента заявки 720 | LUACPP_TABLE_FIELD(class_code, std::string) // Код класса заявки 721 | LUACPP_TABLE_FIELD(condition_sec_code, std::string) // Код инструмента стоп-цены 722 | LUACPP_TABLE_FIELD(condition_class_code, std::string) // Код класса стоп-цены 723 | LUACPP_TABLE_FIELD(canceled_uid, unsigned int) // Идентификатор пользователя, снявшего стоп-заявку 724 | QLUACPP_DATETIME_TABLE_FIELD(order_date_time) // Время выставления стоп-заявки 725 | QLUACPP_DATETIME_TABLE_FIELD(withdraw_datetime) // Время снятия стоп-заявки 726 | QLUACPP_DATETIME_TABLE_FIELD(activation_date_time) // Дата и время активации стоп-заявки 727 | LUACPP_STATIC_TABLE_END() 728 | } 729 | } 730 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::stop_orders) 731 | 732 | // neg_deals "Заявки на внебиржевые сделки" 733 | // Object names in qlua.chm: "Таблица с параметрами заявки на внебиржевые сделки" 734 | namespace qlua { 735 | namespace table { 736 | LUACPP_STATIC_TABLE_BEGIN(neg_deals) 737 | 738 | LUACPP_TABLE_FIELD(neg_deal_num, unsigned int) // Номер 739 | LUACPP_TABLE_FIELD(neg_deal_time, int) // Время выставления заявки 740 | LUACPP_TABLE_FIELD(flags, unsigned int) // Набор битовых флагов 741 | LUACPP_TABLE_FIELD(brokerref, std::string) // Комментарий, обычно: <код клиента>/<номер поручения> 742 | LUACPP_TABLE_FIELD(userid, std::string) // Трейдер 743 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор дилера 744 | LUACPP_TABLE_FIELD(cpuserid, std::string) // Трейдер партнера 745 | LUACPP_TABLE_FIELD(cpfirmid, std::string) // Код фирмы партнера 746 | LUACPP_TABLE_FIELD(account, std::string) // Счет 747 | LUACPP_TABLE_FIELD(price, double) // Цена 748 | LUACPP_TABLE_FIELD(qty, unsigned int) // Количество 749 | LUACPP_TABLE_FIELD(matchref, std::string) // Ссылка 750 | LUACPP_TABLE_FIELD(settlecode, std::string) // Код расчетов 751 | LUACPP_TABLE_FIELD(yield, double) // Доходность 752 | LUACPP_TABLE_FIELD(accruedint, double) // Купонный процент 753 | LUACPP_TABLE_FIELD(value, double) // Объем 754 | LUACPP_TABLE_FIELD(price2, double) // Цена выкупа 755 | LUACPP_TABLE_FIELD(reporate, double) // Ставка РЕПО (%) 756 | LUACPP_TABLE_FIELD(refundrate, double) // Ставка возмещения (%) 757 | LUACPP_TABLE_FIELD(trans_id, unsigned int) // ID транзакции 758 | LUACPP_TABLE_FIELD(client_code, std::string) // Код клиента 759 | LUACPP_TABLE_FIELD(repoentry, unsigned int) /* Тип ввода заявки РЕПО. Возможные значения: 760 | «0» – «Не определен»; 761 | «1» – «Цена1+Ставка»; 762 | «2» – «Ставка+ Цена2»; 763 | «3» – «Цена1+Цена2»; 764 | «4» – «Сумма РЕПО + Количество»; 765 | «5» – «Сумма РЕПО + Дисконт»; 766 | «6» – «Количество + Дисконт»; 767 | «7» – «Сумма РЕПО»; 768 | «8» – «Количество» 769 | */ 770 | 771 | LUACPP_TABLE_FIELD(repovalue, double) // Сумма РЕПО 772 | LUACPP_TABLE_FIELD(repo2value, double) // Объем выкупа РЕПО 773 | LUACPP_TABLE_FIELD(repoterm, double) // Срок РЕПО 774 | LUACPP_TABLE_FIELD(start_discount, double) // Начальный дисконт (%) 775 | LUACPP_TABLE_FIELD(lower_discount, double) // Нижний дисконт (%) 776 | LUACPP_TABLE_FIELD(upper_discount, double) // Верхний дисконт (%) 777 | LUACPP_TABLE_FIELD(block_securities, unsigned int) // Блокировка обеспечения («Да»/«Нет») 778 | LUACPP_TABLE_FIELD(uid, unsigned int) // Идентификатор пользователя 779 | LUACPP_TABLE_FIELD(withdraw_time, int) // Время снятия заявки 780 | LUACPP_TABLE_FIELD(neg_deal_date, int) // Дата выставления заявки 781 | LUACPP_TABLE_FIELD(balance, double) // Остаток 782 | LUACPP_TABLE_FIELD(origin_repovalue, double) // Сумма РЕПО первоначальная 783 | LUACPP_TABLE_FIELD(origin_qty, unsigned int) // Количество первоначальное 784 | LUACPP_TABLE_FIELD(origin_discount, double) // Процент дисконта первоначальный 785 | LUACPP_TABLE_FIELD(neg_deal_activation_date, int) // Дата активации заявки 786 | LUACPP_TABLE_FIELD(neg_deal_activation_time, int) // Время активации заявки 787 | LUACPP_TABLE_FIELD(quoteno, unsigned int) // Встречная безадресная заявка 788 | LUACPP_TABLE_FIELD(settle_currency, std::string) // Валюта расчетов 789 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код инструмента 790 | LUACPP_TABLE_FIELD(class_code, std::string) // Код класса 791 | LUACPP_TABLE_FIELD(bank_acc_id, std::string) // Идентификатор расчетного счета/кода в клиринговой организации 792 | LUACPP_TABLE_FIELD(withdraw_date, int) // Дата снятия адресной заявки в формате «ГГГГММДД» 793 | LUACPP_TABLE_FIELD(linkedorder, unsigned int) // Номер предыдущей заявки. Отображается с точностью «0» 794 | QLUACPP_DATETIME_TABLE_FIELD(activation_date_time) // Дата и время активации заявки 795 | QLUACPP_DATETIME_TABLE_FIELD(withdraw_date_time) // Дата и время снятия заявки 796 | QLUACPP_DATETIME_TABLE_FIELD(date_time) // Дата и время заявки 797 | LUACPP_TABLE_FIELD(lseccode, std::string) // Приоритетное обеспечение 798 | LUACPP_TABLE_FIELD(canceled_uid, unsigned int) // UID снявшего заявку 799 | LUACPP_TABLE_FIELD(system_ref, std::string) // Системная ссылка 800 | LUACPP_TABLE_FIELD(price_currency, std::string) // Валюта, в которой указана цена заявки 801 | LUACPP_TABLE_FIELD(order_exchange_code, std::string) // Биржевой номер заявки 802 | LUACPP_TABLE_FIELD(extref, std::string) // Внешняя ссылка, используется для обратной связи с внешними системами 803 | LUACPP_TABLE_FIELD(period, unsigned int) // Период торговой сессии, в которую была подана заявка 804 | LUACPP_TABLE_FIELD(client_qualifier, unsigned int) /* Квалификатор клиента, от имени которого выставлена заявка. Возможные значения: 805 | «0» – не определено; 806 | «1» – Natural Person; 807 | «3» – Legal Entity 808 | */ 809 | 810 | LUACPP_TABLE_FIELD(client_short_code, unsigned int) // Краткий идентификатор клиента, от имени которого выставлена заявка 811 | LUACPP_TABLE_FIELD(investment_decision_maker_qualifier, unsigned int) /* Квалификатор принявшего решение о выставлении заявки. Возможные значения: 812 | «0» – не определено; 813 | «1» – Natural Person; 814 | «3» – Algorithm 815 | */ 816 | LUACPP_TABLE_FIELD(investment_decision_maker_short_code, unsigned int) // Краткий идентификатор принявшего решение о выставлении заявки 817 | LUACPP_TABLE_FIELD(executing_trader_qualifier, unsigned int) /* Квалификатор трейдера, исполнившего заявку. Возможные значения: 818 | «0» – не определено; 819 | «1» – Natural Person; 820 | «3» – Algorithm 821 | */ 822 | LUACPP_TABLE_FIELD(executing_trader_short_code, unsigned int) // Краткий идентификатор трейдера, исполнившего заявку 823 | LUACPP_STATIC_TABLE_END() 824 | } 825 | } 826 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::neg_deals) 827 | 828 | // neg_trades "Сделки для исполнения" 829 | // Object names in qlua.chm "Таблица с параметрами сделки для исполнения" 830 | namespace qlua { 831 | namespace table { 832 | LUACPP_STATIC_TABLE_BEGIN(neg_trades) 833 | LUACPP_TABLE_FIELD(trade_num, std::string) // Номер сделки 834 | LUACPP_TABLE_FIELD(trade_date, int) // Дата торгов 835 | LUACPP_TABLE_FIELD(settle_date, int) // Дата расчетов 836 | LUACPP_TABLE_FIELD(flags, unsigned int) // Набор битовых флагов 837 | LUACPP_TABLE_FIELD(brokerref, std::string) // Комментарий, обычно: <код клиента>/<номер поручения> 838 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор дилера 839 | LUACPP_TABLE_FIELD(account, std::string) // Счет депо 840 | LUACPP_TABLE_FIELD(cpfirmid, std::string) // Код фирмы партнера 841 | LUACPP_TABLE_FIELD(cpaccount, std::string) // Счет депо партнера 842 | LUACPP_TABLE_FIELD(price, double) // Цена 843 | LUACPP_TABLE_FIELD(qty, unsigned int) // Количество 844 | LUACPP_TABLE_FIELD(value, double) // Объем 845 | LUACPP_TABLE_FIELD(settlecode, std::string) // Код расчетов 846 | LUACPP_TABLE_FIELD(report_num, unsigned int) // Отчет 847 | LUACPP_TABLE_FIELD(cpreport_num, unsigned int) // Отчет партнера 848 | LUACPP_TABLE_FIELD(accruedint, double) // Купонный процент 849 | LUACPP_TABLE_FIELD(repotradeno, double) // Номер сделки 1-ой части РЕПО 850 | LUACPP_TABLE_FIELD(price1, double) // Цена 1-ой части РЕПО 851 | LUACPP_TABLE_FIELD(reporate, double) // Ставка РЕПО (%) 852 | LUACPP_TABLE_FIELD(price2, double) // Цена выкупа 853 | LUACPP_TABLE_FIELD(client_code, std::string) // Код клиента 854 | LUACPP_TABLE_FIELD(ts_comission, double) // Комиссия торговой системы 855 | LUACPP_TABLE_FIELD(balance, double) // Остаток 856 | LUACPP_TABLE_FIELD(settle_time, int) // Время исполнения 857 | LUACPP_TABLE_FIELD(amount, double) // Сумма обязательства 858 | LUACPP_TABLE_FIELD(repovalue, double) // Сумма РЕПО 859 | LUACPP_TABLE_FIELD(repoterm, double) // Срок РЕПО 860 | LUACPP_TABLE_FIELD(repo2value, double) // Объем выкупа РЕПО 861 | LUACPP_TABLE_FIELD(return_value, double) // Сумма возврата РЕПО 862 | LUACPP_TABLE_FIELD(discount, double) // Дисконт (%) 863 | LUACPP_TABLE_FIELD(lower_discount, double) // Нижний дисконт (%) 864 | LUACPP_TABLE_FIELD(upper_discount, double) // Верхний дисконт (%) 865 | LUACPP_TABLE_FIELD(block_securities, unsigned int) // Блокировать обеспечение («Да»/«Нет») 866 | LUACPP_TABLE_FIELD(urgency_flag, unsigned int) // Исполнить («Да»/«Нет») 867 | LUACPP_TABLE_FIELD(type, unsigned int) /* Тип. Возможные значения: 868 | «0» – «Внесистемная сделка», 869 | «1» – «Первая часть сделки РЕПО», 870 | «2» – «Вторая часть сделки РЕПО», 871 | «3» – «Компенсационный взнос», 872 | «4» – «Дефолтер: отложенные обязательства и требования», 873 | «5» – «Пострадавший: отложенные обязательства и требования». 874 | */ 875 | 876 | LUACPP_TABLE_FIELD(operation_type, unsigned int) /* Направленность. Возможные значения: 877 | «1» – «Зачислить», 878 | «2» – «Списать». 879 | */ 880 | 881 | LUACPP_TABLE_FIELD(expected_discount, double) // Дисконт после взноса (%) 882 | LUACPP_TABLE_FIELD(expected_quantity, unsigned int) // Количество после взноса 883 | LUACPP_TABLE_FIELD(expected_repovalue, double) // Сумма РЕПО после взноса 884 | LUACPP_TABLE_FIELD(expected_repo2value, double) // Стоимость выкупа после взноса 885 | LUACPP_TABLE_FIELD(expected_return_value, double) // Сумма возврата после взноса 886 | LUACPP_TABLE_FIELD(order_num, std::string) // Номер заявки 887 | LUACPP_TABLE_FIELD(report_trade_date, int) // Дата заключения 888 | LUACPP_TABLE_FIELD(settled, unsigned int) /* Состояние расчетов по сделке. Возможные значения: 889 | «1» – «Processed», 890 | «2» – «Not processed», 891 | «3» – «Is processing». 892 | */ 893 | 894 | LUACPP_TABLE_FIELD(clearing_type, unsigned int) /* Тип клиринга. Возможные значения: 895 | «1» – «Not set», 896 | «2» – «Simple», 897 | «3» – «Multilateral». 898 | */ 899 | 900 | LUACPP_TABLE_FIELD(report_comission, double) // Комиссия за отчет 901 | LUACPP_TABLE_FIELD(coupon_payment, double) // Купонная выплата 902 | LUACPP_TABLE_FIELD(principal_payment, double) // Выплата по основному долгу 903 | LUACPP_TABLE_FIELD(principal_payment_date, int) // Дата выплаты по основному долгу 904 | LUACPP_TABLE_FIELD(nextdaysettle, int) // Дата следующего дня расчетов 905 | LUACPP_TABLE_FIELD(settle_currency, std::string) // Валюта расчетов 906 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код инструмента 907 | LUACPP_TABLE_FIELD(class_code, std::string) // Код класса 908 | LUACPP_TABLE_FIELD(compval, double) // Сумма отступного в валюте сделки 909 | LUACPP_TABLE_FIELD(parenttradeno, unsigned int) // Идентификационный номер витринной сделки 910 | LUACPP_TABLE_FIELD(bankid, std::string) // Расчетная организация 911 | LUACPP_TABLE_FIELD(bankaccid, std::string) // Код позиции 912 | LUACPP_TABLE_FIELD(precisebalance, unsigned int) // Количество инструментов к исполнению (в лотах) 913 | LUACPP_TABLE_FIELD(confirmtime, int) // Время подтверждения в формате «ЧЧММСС» 914 | LUACPP_TABLE_FIELD(ex_flags, unsigned int) /* Расширенные флаги сделки для исполнения. Возможные значения: 915 | «1» – «Подтверждена контрагентом»; 916 | «2» – «Подтверждена» 917 | */ 918 | LUACPP_TABLE_FIELD(confirmreport, unsigned int) // Номер поручения 919 | LUACPP_TABLE_FIELD(extref, std::string) // Внешняя ссылка, используется для обратной связи с внешними системами 920 | LUACPP_STATIC_TABLE_END() 921 | } 922 | } 923 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::neg_trades) 924 | 925 | // neg_deal_reports "Отчеты по сделкам для исполнения" 926 | namespace qlua { 927 | namespace table { 928 | LUACPP_STATIC_TABLE_BEGIN(neg_deal_reports) 929 | LUACPP_TABLE_FIELD(report_num, unsigned int) // Отчет 930 | LUACPP_TABLE_FIELD(report_date, int) // Дата отчета 931 | LUACPP_TABLE_FIELD(flags, unsigned int) // Набор битовых флагов 932 | LUACPP_TABLE_FIELD(userid, std::string) // Идентификатор пользователя 933 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 934 | LUACPP_TABLE_FIELD(account, std::string) // Счет депо 935 | LUACPP_TABLE_FIELD(cpfirmid, std::string) // Код фирмы партнера 936 | LUACPP_TABLE_FIELD(cpaccount, std::string) // Код торгового счета партнера 937 | LUACPP_TABLE_FIELD(qty, unsigned int) // Количество бумаг, в лотах 938 | LUACPP_TABLE_FIELD(value, double) // Объем сделки, выраженный в рублях 939 | LUACPP_TABLE_FIELD(withdraw_time, int) // Время снятия заявки 940 | LUACPP_TABLE_FIELD(report_type, unsigned int) // Тип отчета 941 | LUACPP_TABLE_FIELD(report_kind, unsigned int) // Вид отчета 942 | LUACPP_TABLE_FIELD(commission, double) // Объем комиссии по сделке, выраженный в руб 943 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код бумаги 944 | LUACPP_TABLE_FIELD(class_code, std::string) // Код класса 945 | LUACPP_TABLE_FIELD(report_time, int) // Время отчета 946 | QLUACPP_DATETIME_TABLE_FIELD(report_date_time) // Дата и время отчета 947 | LUACPP_STATIC_TABLE_END() 948 | } 949 | } 950 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::neg_deal_reports) 951 | 952 | // firm_holding "Текущие позиции по бумагам" 953 | namespace qlua { 954 | namespace table { 955 | LUACPP_STATIC_TABLE_BEGIN(firm_holding) 956 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 957 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код бумаги 958 | LUACPP_TABLE_FIELD(openbal, double) // Входящий остаток 959 | LUACPP_TABLE_FIELD(currentpos, double) // Текущий остаток 960 | LUACPP_TABLE_FIELD(plannedposbuy, double) // Объем активных заявок на покупку, в ценных бумагах 961 | LUACPP_TABLE_FIELD(plannedpossell, double) // Объем активных заявок на продажу, в ценных бумагах 962 | LUACPP_TABLE_FIELD(usqtyb, double) // Куплено 963 | LUACPP_TABLE_FIELD(usqtys, double) // Продано 964 | LUACPP_STATIC_TABLE_END() 965 | } 966 | } 967 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::firm_holding) 968 | 969 | // account_balance "Текущиее позиции по клиентским счетам" 970 | // Объект фигурирует в qlua.chm как acc_bal 971 | namespace qlua { 972 | namespace table { 973 | LUACPP_STATIC_TABLE_BEGIN(account_balance) 974 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 975 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код бумаги 976 | LUACPP_TABLE_FIELD(trdaccid, std::string) // Торговый счет 977 | LUACPP_TABLE_FIELD(depaccid, std::string) // Счет депо 978 | LUACPP_TABLE_FIELD(openbal, double) // Входящий остаток 979 | LUACPP_TABLE_FIELD(currentpos, double) // Текущий остаток 980 | LUACPP_TABLE_FIELD(plannedpossell, double) // Плановая продажа 981 | LUACPP_TABLE_FIELD(plannedposbuy, double) // Плановая покупка 982 | LUACPP_TABLE_FIELD(planbal, double) // Контрольный остаток простого клиринга, равен входящему остатку минус плановая позиция на продажу, включенная в простой клиринг 983 | LUACPP_TABLE_FIELD(usqtyb, unsigned int) // Куплено 984 | LUACPP_TABLE_FIELD(usqtys, unsigned int) // Продано 985 | LUACPP_TABLE_FIELD(planned, double) // Плановый остаток, равен текущему остатку минус плановая позиция на продажу 986 | LUACPP_TABLE_FIELD(settlebal, double) // Плановая позиция после проведения расчетов 987 | LUACPP_TABLE_FIELD(bank_acc_id, std::string) // Идентификатор расчетного счета/кода в клиринговой организации 988 | LUACPP_TABLE_FIELD(firmuse, unsigned int) /* Признак счета обеспечения. Возможные значения: 989 | «0» – для обычных счетов, 990 | «1» – для счета обеспечения. */ 991 | LUACPP_STATIC_TABLE_END() 992 | } 993 | } 994 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::account_balance) 995 | 996 | // ccp_holdings "Обязательства и требования по активам" 997 | namespace qlua { 998 | namespace table { 999 | LUACPP_STATIC_TABLE_BEGIN(ccp_holdings) 1000 | LUACPP_TABLE_FIELD(firmid, std::string) // Идентификатор фирмы 1001 | LUACPP_TABLE_FIELD(depo_account, std::string) // Номер счета депо в Депозитарии (НДЦ) 1002 | LUACPP_TABLE_FIELD(account, std::string) // Торговый счет 1003 | LUACPP_TABLE_FIELD(bank_acc_id, std::string) // Идентификатор расчетного счета/кода в клиринговой организации 1004 | LUACPP_TABLE_FIELD(settle_date, int) // Дата расчетов 1005 | LUACPP_TABLE_FIELD(qty, unsigned int) // Количество ценных бумаг в сделках 1006 | LUACPP_TABLE_FIELD(qty_buy, unsigned int) // Количество ценных бумаг в заявках на покупку 1007 | LUACPP_TABLE_FIELD(qty_sell, unsigned int) // Количество ценных бумаг в заявках на продажу 1008 | LUACPP_TABLE_FIELD(netto, double) // Нетто-позиция 1009 | LUACPP_TABLE_FIELD(debit, double) // Дебет 1010 | LUACPP_TABLE_FIELD(credit, double) // Кредит 1011 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код бумаги заявки 1012 | LUACPP_TABLE_FIELD(class_code, std::string) // Код класса заявки 1013 | LUACPP_TABLE_FIELD(planned_covered, double) // Плановая позиция Т+ 1014 | LUACPP_TABLE_FIELD(firm_use, double) /* Тип раздела. Возможные значения: 1015 | «0» – торговый раздел; 1016 | «1» – раздел обеспечения */ 1017 | LUACPP_STATIC_TABLE_END() 1018 | } 1019 | } 1020 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::ccp_holdings) 1021 | 1022 | // rm_holdings "Валюта: обящательства и требования по активам" 1023 | namespace qlua { 1024 | namespace table { 1025 | LUACPP_STATIC_TABLE_BEGIN(rm_holdings) 1026 | LUACPP_TABLE_FIELD(sec_code, std::string) // Код бумаги 1027 | LUACPP_TABLE_FIELD(class_code, std::string) // Код класса 1028 | LUACPP_TABLE_FIELD(firmId, std::string) // Идентификатор фирмы 1029 | LUACPP_TABLE_FIELD(account, std::string) // Торговый счет 1030 | LUACPP_TABLE_FIELD(bank_acc_id, std::string) // Идентификатор расчетного счета в НКЦ 1031 | LUACPP_TABLE_FIELD(date, int) // Дата расчётов 1032 | LUACPP_TABLE_FIELD(debit, double) // Размер денежных обязательств 1033 | LUACPP_TABLE_FIELD(credit, double) // Размер денежных требований 1034 | LUACPP_TABLE_FIELD(value_buy, double) // Сумма денежных средств в заявках на покупку 1035 | LUACPP_TABLE_FIELD(value_sell, double) // Сумма денежных средств в заявках на продажу 1036 | LUACPP_TABLE_FIELD(margin_call, double) // Сумма возврата компенсационного перевода 1037 | LUACPP_TABLE_FIELD(planned_covered, double) // Плановая позиция Т+ 1038 | LUACPP_TABLE_FIELD(debit_balance, double) // Размер денежных обязательств на начало дня, с точностью до 2 знака после десятичного разделителя 1039 | LUACPP_TABLE_FIELD(credit_balance, double) // Размер денежных требований на начало дня, с точностью до 2 знака после десятичного разделителя 1040 | LUACPP_STATIC_TABLE_END() 1041 | } 1042 | } 1043 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::rm_holdings) 1044 | 1045 | // trans_reply "Таблица с описанием транзакций" (callback) 1046 | // Object names in qlua.chm: trans_reply 1047 | namespace qlua { 1048 | namespace table { 1049 | LUACPP_STATIC_TABLE_BEGIN(trans_reply) 1050 | LUACPP_TABLE_FIELD(trans_id, unsigned int) // Пользовательский идентификатор транзакции 1051 | LUACPP_TABLE_FIELD(status, unsigned int) /* Статус транзакции. Возможные значения: 1052 | «0» – транзакция отправлена серверу; 1053 | «1» – транзакция получена на сервер QUIK от клиента; 1054 | «2» – ошибка при передаче транзакции в торговую систему. Так как отсутствует подключение шлюза Московской Биржи, повторно транзакция не отправляется; 1055 | «3» – транзакция выполнена; 1056 | «4» – транзакция не выполнена торговой системой. Более подробное описание ошибки отражается в поле «Сообщение»; 1057 | «5» – транзакция не прошла проверку сервера QUIK по каким-либо критериям. Например, проверку на наличие прав у пользователя на отправку транзакции данного типа; 1058 | «6» – транзакция не прошла проверку лимитов сервера QUIK; 1059 | «10» – транзакция не поддерживается торговой системой; 1060 | «11» – транзакция не прошла проверку правильности электронной цифровой подписи; 1061 | «12» – не удалось дождаться ответа на транзакцию, т.к. истек таймаут ожидания. Может возникнуть при подаче транзакций из QPILE; 1062 | «13» – транзакция отвергнута, так как ее выполнение могло привести к кросс-сделке (т.е. сделке с тем же самым клиентским счетом); 1063 | «14» – транзакция не прошла контроль дополнительных ограничений; 1064 | «15» – транзакция принята после нарушения дополнительных ограничений; 1065 | «16» – транзакция отменена пользователем в ходе проверки дополнительных ограничений */ 1066 | 1067 | LUACPP_TABLE_FIELD(result_msg, std::string) // Сообщение 1068 | QLUACPP_DATETIME_TABLE_FIELD(date_time) // Дата и время 1069 | LUACPP_TABLE_FIELD(uid, unsigned int) // Идентификатор 1070 | LUACPP_TABLE_FIELD(flags, unsigned int) // Флаги транзакции (временно не используется) 1071 | LUACPP_TABLE_FIELD(server_trans_id, unsigned int) // Идентификатор транзакции на сервере 1072 | LUACPP_TABLE_FIELD(order_num, std::optional) // Номер заявки * 1073 | LUACPP_TABLE_FIELD(price, std::optional) // Цена * 1074 | LUACPP_TABLE_FIELD(quantity, std::optional) // Количество * 1075 | LUACPP_TABLE_FIELD(balance, std::optional) // Остаток * 1076 | LUACPP_TABLE_FIELD(firm_id, std::optional) // Идентификатор фирмы * 1077 | LUACPP_TABLE_FIELD(account, std::optional) // Торговый счет * 1078 | LUACPP_TABLE_FIELD(client_code, std::optional) // Код клиента * 1079 | LUACPP_TABLE_FIELD(brokerref, std::optional) // Поручение * 1080 | LUACPP_TABLE_FIELD(class_code, std::optional) // Код класса * 1081 | LUACPP_TABLE_FIELD(sec_code, std::optional) // Код бумаги * 1082 | LUACPP_TABLE_FIELD(exchange_code, std::optional) /* Биржевой номер заявки * 1083 | * - параметр может иметь значение nil 1084 | */ 1085 | LUACPP_TABLE_FIELD(error_code, int) // Числовой код ошибки. Значение равно «0», если транзакция выполнена успешно 1086 | LUACPP_TABLE_FIELD(error_source, unsigned int) /* Источник сообщения. Возможные значения: 1087 | «1» – Торговая система; 1088 | «2» – Сервер QUIK; 1089 | «3» – Библиотека расчёта лимитов; 1090 | «4» – Шлюз торговой системы */ 1091 | 1092 | LUACPP_TABLE_FIELD(first_ordernum, double) // Номер первой заявки, которая выставлялась при автоматической замене кода клиента. Используется, если на сервере QUIK настроена замена кода клиента для кросс-сделки 1093 | QLUACPP_DATETIME_TABLE_FIELD(gate_reply_time) // Дата и время получения шлюзом ответа на транзакцию 1094 | LUACPP_STATIC_TABLE_END() 1095 | } 1096 | } 1097 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::trans_reply) 1098 | 1099 | namespace qlua { 1100 | namespace table { 1101 | LUACPP_STATIC_TABLE_BEGIN(candle) 1102 | LUACPP_TABLE_FIELD(open, double) // Цена открытия 1103 | LUACPP_TABLE_FIELD(close, double) // Цена закрытия 1104 | LUACPP_TABLE_FIELD(high, double) // Максимальная цена сделки 1105 | LUACPP_TABLE_FIELD(low, double) // Минимальная цена сделки 1106 | LUACPP_TABLE_FIELD(volume, double) // Объем последней сделки 1107 | QLUACPP_DATETIME_TABLE_FIELD(datetime) // Формат даты и времени 1108 | LUACPP_TABLE_FIELD(doesExist, unsigned int) /* Признак расчета индикатора при наличии свечки. Возможные значения: 1109 | «0» – индикатор не рассчитан, 1110 | «1» – индикатор рассчитан */ 1111 | LUACPP_STATIC_TABLE_END() 1112 | } 1113 | } 1114 | LUACPP_STATIC_TABLE_TYPE_POLICY(::qlua::table::candle) 1115 | 1116 | #define QLUACPP_DETAIL_TABLE_NAME(NAME) \ 1117 | template <> \ 1118 | struct name_for_type<::qlua::table::NAME> { \ 1119 | static const char* value() { return ""#NAME; } \ 1120 | }; \ 1121 | 1122 | namespace qlua { 1123 | namespace table { 1124 | namespace detail { 1125 | template 1126 | struct name_for_type; 1127 | 1128 | 1129 | QLUACPP_DETAIL_TABLE_NAME(firms); 1130 | QLUACPP_DETAIL_TABLE_NAME(classes); 1131 | QLUACPP_DETAIL_TABLE_NAME(securities); 1132 | QLUACPP_DETAIL_TABLE_NAME(trade_accounts); 1133 | QLUACPP_DETAIL_TABLE_NAME(client_codes); 1134 | QLUACPP_DETAIL_TABLE_NAME(account_positions); 1135 | QLUACPP_DETAIL_TABLE_NAME(orders); 1136 | QLUACPP_DETAIL_TABLE_NAME(futures_client_holding); 1137 | QLUACPP_DETAIL_TABLE_NAME(futures_client_limits); 1138 | QLUACPP_DETAIL_TABLE_NAME(all_trades); 1139 | QLUACPP_DETAIL_TABLE_NAME(money_limits); 1140 | QLUACPP_DETAIL_TABLE_NAME(depo_limits); 1141 | QLUACPP_DETAIL_TABLE_NAME(trades); 1142 | QLUACPP_DETAIL_TABLE_NAME(stop_orders); 1143 | QLUACPP_DETAIL_TABLE_NAME(neg_deals); 1144 | QLUACPP_DETAIL_TABLE_NAME(neg_trades); 1145 | QLUACPP_DETAIL_TABLE_NAME(neg_deal_reports); 1146 | QLUACPP_DETAIL_TABLE_NAME(firm_holding); 1147 | QLUACPP_DETAIL_TABLE_NAME(account_balance); 1148 | QLUACPP_DETAIL_TABLE_NAME(ccp_holdings); 1149 | QLUACPP_DETAIL_TABLE_NAME(rm_holdings); 1150 | } 1151 | } 1152 | } 1153 | 1154 | #undef QLUACPP_DETAIL_TABLE_NAME 1155 | -------------------------------------------------------------------------------- /test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.4.0) 2 | project(qluacpp_test) 3 | 4 | get_filename_component(TOP_DIR "${CMAKE_CURRENT_SOURCE_DIR}" PATH) 5 | set(CATCH "${TOP_DIR}/contrib/Catch") 6 | set(SRC "${TOP_DIR}/src") 7 | 8 | message("Catch dir ${CATCH}") 9 | 10 | if (NOT LUACPP_LUA_LIBRARIES) 11 | find_package(Lua51) 12 | if (NOT LUA_LIBRARIES) 13 | message( FATAL_ERROR "Please set LUACPP_LUA_LIBRARIES variable to your Lua library file. For example:\n cmake -DLUACPP_LUA_LIBRARIES=c:\\lua\\lua5.1.lib ...") 14 | endif() 15 | set(LUACPP_LUA_LIBRARIES ${LUA_LIBRARIES}) 16 | endif() 17 | message ("Lua library: ${LUACPP_LUA_LIBRARIES}") 18 | 19 | if (NOT LUACPP_LUA_INCLUDE_DIR) 20 | find_package(Lua51) 21 | if (NOT LUA_INCLUDE_DIR) 22 | message( FATAL_ERROR "Please set LUACPP_LUA_INCLUDE_DIR variable to the path to your lua.h file. For example:\n cmake -DLUACPP_LUA_INCLUDE_DIR=c:\\lua\\include ...") 23 | endif() 24 | set(LUACPP_LUA_INCLUDE_DIR ${LUA_INCLUDE_DIR}) 25 | endif() 26 | message ("Lua include dir: ${LUACPP_LUA_INCLUDE_DIR}") 27 | 28 | include_directories( 29 | ${TOP_DIR}/contrib/luacpp/include 30 | ${TOP_DIR}/include 31 | ${CATCH}/include 32 | ${LUACPP_LUA_INCLUDE_DIR} 33 | ) 34 | 35 | set(TEST_SOURCES 36 | qluacpp_test.cpp) 37 | 38 | add_executable(qluacpp_test 39 | ${TEST_SOURCES}) 40 | 41 | target_compile_definitions(qluacpp_test PUBLIC "CATCH_CONFIG_MAIN" "CATCH_CONFIG_COLOUR_NONE") 42 | target_link_libraries(qluacpp_test ${LUACPP_LUA_LIBRARIES}) 43 | add_test(CommonTests qluacpp_test) 44 | -------------------------------------------------------------------------------- /test/qluacpp_test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | SCENARIO("Static compilation test - instantiate service functions") { 6 | lua::state s; 7 | qlua::api q(s); 8 | q.message("test"); 9 | } 10 | --------------------------------------------------------------------------------