TGB (Все сообщения пользователя)

   if ( lua_getglobal (<Основной State в котором запускается колбек>, <Имя колбека>) == LUA_TFUNCTION)     // запись и проверка переменной колбека скрипта в стек
   { 
       if ( lua_pcall(<Основной State в котором запускается колбек>, <Количество параметров колбека>, <Список параметров колбека>)  ~= 0 )   // запуск колбека 
      {
          <Обработка ошибки при запуске колбека>
      }
    }
   else    //  в переменной колбека не функция
   {
        <Обработка ошибки пользователя, задавшего в качестве колбека не функцию>
   }

  --- Функции работы с очередями (написаны на "чистом" Lua без обращения к C-функциям)  ---
    local new  =   function  ()
        return  {first  =   1 , last  =   0 }
     end 
    ---
    local push  =   function  (self, v)
        local  last  =  self.last  +  1 
        self[last]  =  v
        self.last  =  last
        return  last
     end 
    ---
    local pop  =   function  (self)
       local  first  =  self.first
       if  first  >  self.last  then   return   nil   end 
       local  v  =  self [first]
       self.first  =  first + 1 
       self[first]  =   nil 
       return  v, first
     end 
    ---
    local size  =   function  (self)
        return  self.last  -  self.first  + 1 
     end 
-----
--------- Создание очереди------
local  Queue_QUIK = new()
---------------------------------------

---  Основной поток обработки колбеков "обходит", запушенные на выполнение скрипты, с тем чтобы по событиям запускать их колбеки.
--  При этом должна быть обеспечена корректная синхронизация выполнения байт-кода колбека таким образом, что он не может выполняеться 
--  параллельно с байт-кодом потока main.
----------------------
local for_OnParam = 2 -- Множитель количества записей в очередь ----
local N_OnParam = 0
--- OnParam написана на "чистом" Lua без обращения к C-функциям  ---
function OnParam(p1, p2)
    for i = 1, for_OnParam do 
      N_OnParam = N_OnParam + 1
      -- Зпаись события  ---
      push (Queue_QUIK, {'OnParam', N_OnParam, {p1, p2}})   --  1. здесь создаются таблицы и может быть запущена автоматическая сборка мусора, 
                                                                                            --     которая работает для всей инсталяции Lua и не является потокобезопасной ---                                                                              
   end 
end
   
 ----   Обработка событий QUIK  (написана на "чистом" Lua без обращения к C-функциям) ----      
local function handle_events()   
      ----- ####  Для отладки ---
   local OnParam_begin = N_OnParam   
   local size_Queue_QUIK = size(Queue_QUIK)
   ---------------------------------
   ---  Чтение очереди событий -----
   local ms, first_q = pop (Queue_QUIK) 
      
    while ( ms  )   do        --- Есть события --- 
       -------------------------------
        ---  Чтение очереди событий -----      
        ms, first_q = pop (Queue_QUIK)  --Queue_QUIK: pop()         
   end
    ---   
    for i = 1, 1000 do      end  ---- нагрузка   ####  Отладка ---
   
    if N_OnParam ~= OnParam_begin then   --  Счетчик N_OnParam может иpмениться только в OnParam  
                                                              --  А это означает, что одновременно (параллельно) работают поток main и основной 
                         --  поток обработки колбеков, что недопустимо.
   --- это C-функция, но она вызывается только если  N_OnParam ~= OnParam_begin 
         message ( ' Параллельное выполнение колбека и потока main:  N_OnParam - OnParam_begin = ' .. tostring(N_OnParam - OnParam_begin)
                        .. '    size_Queue_QUIK = ' .. tostring(size_Queue_QUIK) )
    end      
    ----
end      
--------------------------------------------------------------------------------------------------------------------
--------
IsRun = true
function main()
    -------------------
    while IsRun do 
        handle_events()  ----   функция чтения событий OnParam ---
        sleep(2)  
    end
  ------------------
end   
   
function OnStop()
     IsRun = false
    return 10000   
end

--[[     TGB      ----   Модуль реализации обработки событий QUIK с использованием очередей событий  фондового рынка и событий таблиц QUIK ---

                                                                               Краткая спецификация модуля.
1. Реализуется схема взаимодействия main с колбеками через две потокобезопасные эффективные очереди, одна из которых обслуживает колбеки 
фондового рынка, а вторая, колбеки событий таблиц QUIK, созданных скриптером;
2. При работе обработке колбеков есть две функции: <функция подписки на события фондового рынка>
 и <функция подписки на события пользовательских таблиц >; в этих функциях скриптер может, в виде списка (в таблице) подписаться на события 
 в соответствии с существующими именами колбеков; реализация подписки сведена к автоматическому созданию (скрытых) от пользователя  
 функций колбеков, записывающих свои параметры с добавлением «от кого параметры» в соответствующие очереди;
3. Для работы с очередями по новой схеме есть две функции чтения соответственно очередям;
 при чтении очередей в считываемой таблице передаются: <имя события>, <время записи в очередь>, <параметры в том виде, как они описаны, в существующих колбеках>.
                При работе по этой схеме, QLua для скриптера становится однопоточным и снимаются многие сложные проблемы. 
----
                              !!  Колбеки OnInit и OnStop обрабатываются как обычно.
-------------------------
--]]
----   Функции работы с очередями (выложенные на форуме Старателем) ------
--- При использовании между потоком колбеков и потоком main  потокобезопасные 
local Queue  =  {
     new  =   function  (self)
        return  setmetatable({first  =   1 , last  =   0 }, {__index  =  self})
     end ,
     push  =   function  (self, v)
        local  last  =  self.last  +  1 
        self[last]  =  v
        self.last  =  last
        return  last
     end ,
     pop  =   function  (self)
        local  first  =  self.first
        if  first  >  self.last  then   return   nil   end 
        local  v  =  self[first]
       self.first  =  first + 1 
       self[first]  =   nil 
        return  v
     end ,
     size  =   function  (self)
        return  self.last  -  self.first  + 1 
     end 
}
--------- Создание очередей-----------
local  Queue_QUIK = Queue:new()
local  Queue_QUIK_tbl = Queue:new()
   ----- Функции чтения очередей -------
local function Queue_evn_QUIK()  return Queue_QUIK: pop()  end 
local function Queue_evn_QUIK_tbl()  return Queue_QUIK_tbl: pop()  end 
----- Функции запроса текущих размеров  очередей -------
local function sizeQueue_evn_QUIK()  return Queue_QUIK: size()  end 
local function sizeQueue_evn_QUIK_tbl()  return Queue_QUIK_tbl: size()  end 
--  Конец Функции работы с очередями  ---------------------------------------

              local function f_nil ()  end 
            ---     Переменные  событий фондового рынка -------
             OnAccountBala nce = f_nil        --- изменение позиции по счету
             OnAccountPosit ion = f_nil          --- изменение позиции по счету
             OnAllTr ade = f_nil                       --- новая обезличенная сделка
             OnClea nUp = f_nil                       --- смена торговой сессии
             OnCl ose = f_nil                            --- закрытие терминала QUIK или выгрузка файла qlua.dll
             OnConnec ted = f_nil                    --- установление связи с сервером QUIK
             OnDepoLi mit = f_nil                    --- изменение бумажного лимита
             OnDepoLimitDel ete = f_nil         --- удаление бумажного лимита
             OnDisconnec ted = f_nil               --- отключение от сервера QUIK
             OnF irm = f_nil                             --- получение описания новой фирмы
             OnFuturesClientHold ing = f_nil        --- изменение позиции по срочному рынку
             OnFuturesLimitCha nge = f_nil         --- изменение ограничений по срочному рынку
             OnFuturesLimitDel ete = f_nil            --- удаление лимита по срочному рынку
--             OnI nit = f_nil                                 --- инициализация функции main
             OnMoneyLi mit = f_nil                  --- изменение денежного лимита
             OnMoneyLimitDel ete = f_nil       --- удаление денежного лимита
             OnNegD eal = f_nil                       --- новая заявка на внебиржевую сделку или изменение параметров существующей заявки на внебиржевую сделку
             OnNegTr ade = f_nil                     --- новая сделка для исполнения или изменение существующей сделки для исполнения
             OnOr der = f_nil                             --- новая заявка или изменение параметров существующей заявки
             OnPa ram = f_nil                           --- изменение текущих параметров 
             OnQu ote = f_nil                            --- изменение стакана котировок
--             OnS top = f_nil                              --- остановка скрипта из диалога управления
             OnStopOr der = f_nil                    --- новая стоп-заявка или изменение параметров существующей стоп-заявки
             OnTr ade = f_nil                            --- новая сделка или изменение параметров существующей сделки
             OnTransRe ply = f_nil                   --- ответ на транзакцию
------                     
            local  unsubscribe_tbl =    ---- Функции отписки  ----
          {
               ['OnAccountBalance'] = function ()   OnAccountBala nce = f_nil   end
             , ['OnAccountPosition'] = function ()   OnAccountPosit ion = f_nil   end
             , ['OnAllTrade'] = function ()   OnAllTr ade = f_nil   end
             , ['OnCleanUp'] = function ()   OnClea nUp = f_nil  end
             , ['OnClose'] = function ()   OnCl ose = f_nil  end
             , ['OnConnected'] = function ()   OnConnec ted = f_nil  end
             , ['OnDepoLimit'] = function ()   OnDepoLi mit = f_nil  end
             , ['OnDepoLimitDelete'] = function ()   OnDepoLimitDel ete = f_nil  end
             , ['OnDisconnected'] = function ()   OnDisconnec ted = f_nil  end
             , ['OnFirm'] = function ()   OnF irm = f_nil  end
             , ['OnFuturesClientHolding'] = function ()   OnFuturesClientHold ing = f_nil  end
             , ['OnFuturesLimitChange'] = function ()   OnFuturesLimitCha nge = f_nil  end
             , ['OnFuturesLimitDelete'] = function ()   OnFuturesLimitDel ete = f_nil  end
--             , ['OnInit'] = function ()   OnI nit = f_nil  end
             , ['OnMoneyLimit'] = function ()   OnMoneyLi mit = f_nil  end
             , ['OnMoneyLimitDelete'] = function ()   OnMoneyLimitDel ete = f_nil  end
             , ['OnNegDeal'] = function ()   OnNegD eal = f_nil  end
             , ['OnNegTrade'] = function ()   OnNegTr ade = f_nil  end
             , ['OnOrder'] = function ()   OnOr der = f_nil  end
             , ['OnParam'] = function ()   OnPa ram = f_nil  end
             , ['OnQuote'] = function ()   OnQu ote = f_nil  end
--             , ['OnStop'] = function ()   OnS top = f_nil  end
             , ['OnStopOrder'] = function ()   OnStopOr der = f_nil  end
             , ['OnTrade'] = function ()   OnTr ade = f_nil end
             , ['OnTransReply'] = function ()   OnTransRe ply = f_nil  end
          }
         -----
            local  subscribe_tbl =    ---- Функции подписки  ----
          {
               ['OnAccountBalance'] = function ()   OnAccountBala nce = function (...)  Queue_QUIK: push ({'OnAccountBalance', os.time (), {...}} ) end   end
             , ['OnAccountPosition'] = function ()   OnAccountPosit ion = function (...)  Queue_QUIK: push ({'OnAccountPosition', os.time (), {...}} ) end    end
             , ['OnAllTrade'] = function ()   OnAllTr ade = function (...)  Queue_QUIK: push ({'OnAllTrade', os.time (), {...}} ) end     end
             , ['OnCleanUp'] = function ()   OnClea nUp = function (...)  Queue_QUIK: push ({'OnCleanUp', os.time (), {...}} ) end  end
             , ['OnClose'] = function ()   OnCl ose = function (...)  Queue_QUIK: push ({'OnClose', os.time (), {...}} ) end  end
             , ['OnConnected'] = function ()   OnConnec ted = function (...)  Queue_QUIK: push ({'OnConnected', os.time (), {...}} ) end  end
             , ['OnDepoLimit'] = function ()   OnDepoLi mit = function (...)  Queue_QUIK: push ({'OnDepoLimit', os.time (), {...}} ) end  end
             , ['OnDepoLimitDelete'] = function ()   OnDepoLimitDel ete = function (...)  Queue_QUIK: push ({'OnDepoLimitDelete', os.time (), {...}} ) end  end
             , ['OnDisconnected'] = function ()   OnDisconnec ted = function (...)  Queue_QUIK: push ({'OnDisconnected', os.time (), {...}} ) end  end
             , ['OnFirm'] = function ()   OnF irm = function (...)  Queue_QUIK: push ({'OnFirm', os.time (), {...}} ) end  end
             , ['OnFuturesClientHolding'] = function ()   OnFuturesClientHold ing = function (...)  Queue_QUIK: push ({'OnFuturesClientHolding', os.time (), {...}} ) end  end
             , ['OnFuturesLimitChange'] = function ()   OnFuturesLimitCha nge = function (...)  Queue_QUIK: push ({'OnFuturesLimitChange', os.time (), {...}} ) end  end
             , ['OnFuturesLimitDelete'] = function ()   OnFuturesLimitDel ete = function (...)  Queue_QUIK: push ({'OnFuturesLimitDelete', os.time (), {...}} ) end  end
--             , ['OnInit'] = function ()   OnI nit = function (...)  Queue_QUIK: push ({'OnInit', os.time (), {...}} ) end  end
             , ['OnMoneyLimit'] = function ()   OnMoneyLi mit = function (...)  Queue_QUIK: push ({'OnMoneyLimit', os.time (), {...}} ) end  end
             , ['OnMoneyLimitDelete'] = function ()   OnMoneyLimitDel ete = function (...)  Queue_QUIK: push ({'OnMoneyLimitDelete', os.time (), {...}} ) end  end
             , ['OnNegDeal'] = function ()   OnNegD eal = function (...)  Queue_QUIK: push ({'OnNegDeal', os.time (), {...}} ) end  end
             , ['OnNegTrade'] = function ()   OnNegTr ade = function (...)  Queue_QUIK: push ({'OnNegTrade', os.time (), {...}} ) end  end
             , ['OnOrder'] = function ()   OnOr der = function (...)  Queue_QUIK: push ({'OnAccountBalance', os.time (), {...}} ) end  end
             , ['OnParam'] = function ()   OnPa ram = function (...)  Queue_QUIK: push ({'OnParam', os.time (), {...}} ) end  end
             , ['OnQuote'] = function ()   OnQu ote = function (...)  Queue_QUIK: push ({'OnQuote', os.time (), {...}} ) end  end
--             , ['OnStop'] = function ()   OnS top = function (...)  Queue_QUIK: push ({'OnStop', os.time (), {...}} ) end  end
             , ['OnStopOrder'] = function ()   OnStopOr der = function (...)  Queue_QUIK: push ({'OnStopOrder', os.time (), {...}} ) end  end
             , ['OnTrade'] = function ()   OnTr ade = function (...)  Queue_QUIK: push ({'OnTrade', os.time (), {...}} ) end  end
             , ['OnTransReply'] = function ()   OnTransRe ply = function (...)  Queue_QUIK: push ({'OnTransReply', os.time (), {...}} ) end  end
          }
         -----   
        -- Подписаться на события фондового рынка --         
        ---  Ключи таблицы - имена событий ----
        local function  subscribe (tbl)
         local err ={},  f
            for k, v in next, tbl do
             f = subscribe_tbl [k]
                if f then f() else  err[#err +1] = k  end
            end   
            return err          
        end
      
      -- Отписаться от событий фондового рынка --
        ---  Ключи таблицы - имена событий ----
        local function  unsubscribe (tbl)
         local err ={},  f
            for k, v in next, tbl do
             f = unsubscribe_tbl [k]
                if f then f() else  err[#err +1] = k  end
            end   
            return err       
        end
      
      --- Вывод данных о состоянии подписки на события фондового рынка  ---
       local function  condition_subscribe ()
             local tbl= {}
            ---
              tbl['OnAccountBalance'] = OnAccountBalance ~= f_nil or nil
              tbl['OnAccountPosition'] = OnAccountPosition ~= f_nil or nil
              tbl['OnAllTrade'] = OnAllTrade ~= f_nil or nil 
              tbl['OnCleanUp'] = OnCleanUp  ~= f_nil or nil
              tbl['OnClose'] = OnClose ~= f_nil or nil 
              tbl['OnConnected'] = OnConnected ~= f_nil or nil 
              tbl['OnDepoLimit'] = OnDepoLimit ~= f_nil or nil 
              tbl['OnDepoLimitDelete'] = OnDepoLimitDelete ~= f_nil or nil
              tbl['OnDisconnected'] = OnDisconnected ~= f_nil or nil 
              tbl['OnFirm'] = OnFirm ~= f_nil or nil
              tbl['OnFuturesClientHolding'] = OnFuturesClientHolding ~= f_nil or nil
              tbl['OnFuturesLimitChange'] =  OnFuturesLimitChange ~= f_nil or nil
              tbl['OnFuturesLimitDelete'] =OnFuturesLimitDelete ~= f_nil or nil
--              tbl['OnInit'] = OnInit ~= f_nil or nil 
              tbl['OnMoneyLimit'] = OnMoneyLimit ~= f_nil or nil
              tbl['OnMoneyLimitDelete'] = OnMoneyLimitDelete ~= f_nil or nil
              tbl['OnNegDeal'] = OnNegDeal ~= f_nil or nil
              tbl['OnNegTrade'] = OnNegTrade ~= f_nil or nil
              tbl['OnOrder'] = OnOrder ~= f_nil or nil
              tbl['OnParam'] = OnParam ~= f_nil or nil
              tbl['OnQuote'] = OnQuote ~= f_nil or nil
--              tbl['OnStop'] = OnStop ~= f_nil or nil
              tbl['OnStopOrder'] = OnStopOrder ~= f_nil or nil
              tbl['OnTrade'] = OnTrade ~= f_nil or nil
              tbl['OnTransReply'] = OnTransReply ~= f_nil or nil
            
          return  tbl   
        end
      
        ----------------------------------------------------------------      
            
 ----   Обработка событий QUIK  ----      
 ----   
local tbl_QUIK_fun  --- Для хранения функции обработки событий таблиц QUIK ---
local tbl_fun            --- Для хранения таблицы функции обработки событий фондового рынка ---
local period = 100    -- период счетчика для выдачи сообшений ---
local event_counter  = 0  -- текущее значение циклов "разгребания" очередей событий ---
local event_counter_mess  = 0  -- счетчик для выдачи сообщений --
local event_counter_mess  = 0  -- счетчик для выдачи сообщений --
local read_latency_max  = 0   -- максимальная задержка чтения очередей событий (сек.)--
------------------------------------------------------------------
         
      local tbl_QUIK = {} ---- Общая таблица состояния обработки таблиц QUIK ---
      ---- Функция обаботки колбеков таблиц QUIK ----
      local function callback_tbl_QUIK(...)  --- (NUMBER t_id, NUMBER msg, NUMBER par1, NUMBER par2
          local par ={...}
         par = par[1]
          if tbl_QUIK[par] then  -- Запись в очередь событий таблиц QUIK.  os.time () - дата_время записи ---
              Queue_QUIK_tbl: push ({par, os.time (), {...}} )
          end
      end 
      
      -- Подписка на события таблицы QUIK  ---
      local function  subscribe_tbl_QUIK (t_id, f_t)
            if    tbl_QUIK[t_id]  then return nil end   
          tbl_QUIK_fun = tbl_QUIK_fun or f_t 
          if SetTableNotificationCallback ( t_id,  callback_tbl_QUIK) == 1 then
             tbl_QUIK[t_id] = 1
            return nil 
         else
            message('!!! Ошибка задания колбека для таблицы: ' ..  t_id)
            error('!!! Ошибка задания колбека для таблицы: ' ..  t_id)
            return nil 
         end
        end
         --   Отписка от событий таблицы QUIK ----
        local function  unsubscribe_tbl_QUIK (t_id) -- Отписка от событий таблицы QUIK  ---
          if tbl_QUIK [t_id]   then tbl_QUIK [t_id] = nil  end
         if  next (tbl_QUIK) == nil then  tbl_QUIK_fun = nil  end
        end
      --  Состояние подписки на события таблицы QUIK ----
      local function condition_subscribe_tbl_QUIK ()  --- Состояние подписки на события таблиц QUIK ---
         return tbl_QUIK
      end
      -----------------------------------------------
---  Установить функции обработки событий  ----
local function install_event_handling_functions(tbl_f)
   tbl_fun = tbl_f
   event_counter  = 0  
   event_counter_mess  = 0 
   event_counter_max  = 0 
   read_latency_max  = 0
   --- Подписка на события фондового рынка ---
   --- ! Ключи таблицы - имена событий ---- 
   unsubscribe (unsubscribe_tbl)  ---- Отписаться от всех событий
   subscribe (tbl_f)   ---  Подписка на события всей таблицы tbl_fun (для записей с функциями обработки событий)
end
 
---- Функция обработки всех событий QUIK:  function handle_events(lim)   -----
--  Параметр lim (по умолчанию равен 1000000)  определяет максимальное количестко событий, обрабатаваемых за один вызов функции --
--- Если очереди событий пусты, то функция завершается.
-- Результат (их три):  1) количество обработанных событий; 2) максимальное количество событий за один вызов функции; 
-- 3) максимальная задержка (в сек.) между записью и чтением событий
local function handle_events(lim)   
   lim = lim or 1000000
   local f_ms
   ---  Чтение очередей событий -----
    local ms_tbl = Queue_QUIK_tbl: pop()   -- ms_tbl = {t_id,  os.time (), {NUMBER t_id, NUMBER msg, NUMBER par1, NUMBER par2}}
   local ms = Queue_QUIK: pop()             -- ms_tbl = {<Имя события>, os.time (), {<Параметры события>}}
   local os_time, os_time_d
   ---
    while (ms_tbl or ms  )   do        -- Есть события --- 
       -------------------------------
      os_time = os.time ()
       event_counter  = event_counter  + 1
      event_counter_mess = event_counter_mess + 1
      if event_counter_mess >= period then
         event_counter_mess = 0
         message ( '!! Длительный цикл обработки событий: ' .. event_counter )
      end
       --- Обработка событий таблиц QUIK ---
       if ms_tbl then   
--  message ( tostring(ms_tbl[1]))
          os_time_d = os_time - ms_tbl [2]
          if read_latency_max < os_time_d then read_latency_max = os_time_d  end
          if tbl_QUIK_fun then  tbl_QUIK_fun (unpack (ms_tbl[3]))  end       -- Запуск функции обработки событий таблиц QUIK ---
       end   
     ----------- События  фондового рынка ---
       if type (tbl_fun) == 'table' then 
           if ms then  
            os_time_d = os_time - ms [2] 
               if read_latency_max < os_time_d  then read_latency_max = os_time_d end      
              f_ms = tbl_fun[ms[1]]
               -- message ( tostring(ms[3][2]))
               if f_ms then f_ms (unpack (ms[3])) end  -- Запуск функции обработки событий фондового рынка ---
           end
      end
      if event_counter >= lim then break  end  
        ---  Чтение очередей событий -----      
         ms_tbl = Queue_QUIK_tbl: pop()   -- ms_tbl = {t_id,  os.time (), {NUMBER t_id, NUMBER msg, NUMBER par1, NUMBER par2}}
        ms = Queue_QUIK: pop()       
   end
   
    ---  Ведение счетчиков циклов обработки событий ----
   if event_counter_max < event_counter then
      event_counter_max = event_counter
   end
   event_counter_rt = event_counter
    event_counter  = 0
    event_counter_mess  = 0
   read_latency_max  = 0
   return event_counter_rt, event_counter_max, read_latency_max
end
      
-----------------------------------------------
 return { 
--   Queue = Queue                                                 --- Функции работы с очередями ----
-- , Queue_evn_QUIK = Queue_evn_QUIK                -- Чтение параметров событий рынка ---
-- , Queue_evn_QUIK_tbl = Queue_evn_QUIK_tbl      -- Чтение параметров событий таблиц QUIK  ---
   sizeQueue_evn_QUIK = sizeQueue_evn_QUIK    -- Текущий размер очереди событий рынка ---
 , sizeQueue_evn_QUIK_tbl = sizeQueue_evn_QUIK_tbl   -- Текущий размер очереди событий таблиц QUIK   ---
 , subscribe = subscribe                                       -- Подписаться на события фондового рынка --
 , unsubscribe = unsubscribe                                -- Отписаться от событий фондового рынка --
 , condition_subscribe = condition_subscribe         -- Сотояние подписки на события фондового рынка --
 , subscribe_tbl_QUIK = subscribe_tbl_QUIK          -- Подписаться на события таблиц QUIK --
 , unsubscribe_tbl_QUIK = unsubscribe_tbl_QUIK   -- Отписаться от событий таблиц QUIK --
 , condition_subscribe_tbl_QUIK = condition_subscribe_tbl_QUIK  -- Сотояние подписки на таблицы QUIK  --
 , install_event_handling_functions = install_event_handling_functions  --  Установить функции обработки событий  ----
 , handle_events = handle_events    -- Функция обработки всех событий QUIK  -----
 }  ---
--------------------------------------

local even_handling_module = require('even_handling_module')  -- Подключение модуля обработки событий QUIK  ---
---
local subscribe = even_handling_module.subscribe
local unsubscribe = even_handling_module.unsubscribe
local condition_subscribe = even_handling_module.condition_subscribe
local subscribe_tbl_QUIK = even_handling_module.subscribe_tbl_QUIK
local unsubscribe_tbl_QUIK = even_handling_module.unsubscribe_tbl_QUIK
local condition_subscribe_tbl_QUIK = even_handling_module.condition_subscribe_tbl_QUIK
local sizeQueue_evn_QUIK = even_handling_module.sizeQueue_evn_QUIK   
local sizeQueue_evn_QUIK_tbl = even_handling_module.sizeQueue_evn_QUIK_tbl
local install_event_handling_functions = even_handling_module.install_event_handling_functions
local handle_events = even_handling_module.handle_events

IsRun = true

function main()
      
      --- Работа с событиями таблиц QUIK -----
      ----- Функция обработки событий таблиц QUIK  -----
      --  FUNCTION (NUMBER t_id, NUMBER msg, NUMBER par1, NUMBER par2)  ---
      --  t_id – идентификатор таблицы;  msg – код сообщения;  par1 и par2 – значения параметров определяются типом сообщения msg  ----
        local function tbl_QUIK_fun (t_id, msg, par1, par2) 
              message ( 'tbl_QUIK_fun (t_id: ' .. t_id)
       end       
      -----
    TableQUIK=AllocTable()  -- Создание таблицы QUIK --
        AddColumn(TableQUIK, 1, "Легенда", true, QTABLE_STRING_TYPE, 6)
        AddColumn(TableQUIK, 2, "Год", true, QTABLE_STRING_TYPE, 6)
        AddColumn(TableQUIK, 3, "Месяц", true, QTABLE_STRING_TYPE, 6)
        AddColumn(TableQUIK, 4, "День", true, QTABLE_STRING_TYPE, 6)
        CreateWindow(TableQUIK)
        for i=1,10 do -- Цикл заполняет ячейки
                 InsertRow(TableQUIK,-1)
                 for j=1,4 do
                          SetCell(TableQUIK, i, j, tostring(i).."-"..tostring(j))
                 end
        end
      
    TableQUIK1=AllocTable()  -- Создание таблицы QUIK --
        AddColumn(TableQUIK1, 1, "Легенда", true, QTABLE_STRING_TYPE, 6)
        AddColumn(TableQUIK1, 2, "Год", true, QTABLE_STRING_TYPE, 6)
        AddColumn(TableQUIK1, 3, "Месяц", true, QTABLE_STRING_TYPE, 6)
        AddColumn(TableQUIK1, 4, "День", true, QTABLE_STRING_TYPE, 6)
        CreateWindow(TableQUIK1)
        for i=1,10 do -- Цикл заполняет ячейки
                 InsertRow(TableQUIK1,-1)
                 for j=1,4 do
                          SetCell(TableQUIK1, i, j, tostring(i).."-"..tostring(j))
                 end
        end
      ---
        subscribe_tbl_QUIK (TableQUIK, tbl_QUIK_fun)  --- Подписка на события TableQUIK
       subscribe_tbl_QUIK (TableQUIK1, tbl_QUIK_fun)   --- Подписка на события TableQUIK1
  --   unsubscribe_tbl_QUIK (TableQUIK)    --- Отдписка от событий TableQUIK1
   --- Конец  Работа с событиями таблиц QUIK  -----
   
   
   ---  Работа с событиями фондового рынка ----
    ---    Функции обработки событий фондового рынка ---
    local function F_OnParam(p1, p2)
 --      message ( 'Тикер: ' .. tostring(p2))
    end
   --  
    local function F_OnAllTrade(t)
       message ( 'F_OnAllTrade: ' )
    end   
   
   local function F_OnConnected(t)
       message ( 'F_OnConnected: ' )
    end   
   
   ---- и т.д  ----
   -------------------------------------------------------------------
    ------  !!!  Для перехода на обработку событий в очередях, в скрипте достаточно к именам функций колбеков добавить префикс 'F_'
   ---  Таблица функций обработки событий фондового рынка  (параметры как в соответствующих колбеках) -----
    local tbl_fun =  
          {    
               ['OnAccountBalance'] = F_OnAccountBalance   --- Имя функции обработки события OnAccountBalance  --
             , ['OnAccountPosition'] = F_OnAccountPosition   -- и т.д.  ---
             , ['OnAllTrade'] = F_OnAllTrade
             , ['OnCleanUp'] = F_OnCleanUp
             , ['OnClose'] = F_OnClose
             , ['OnConnected'] = F_OnConnected
             , ['OnDepoLimit'] = F_OnDepoLimit
             , ['OnDepoLimitDelete'] = F_OnDepoLimitDelete
             , ['OnDisconnected'] = F_OnDisconnected
             , ['OnFirm'] = F_OnFirm
             , ['OnFuturesClientHolding'] = F_OnFuturesClientHolding
             , ['OnFuturesLimitChange'] = F_OnFuturesLimitChange
             , ['OnFuturesLimitDelete'] = F_OnFuturesLimitDelete
--             , ['OnInit'] = F_OnInit
             , ['OnMoneyLimit'] = F_OnMoneyLimit
             , ['OnMoneyLimitDelete'] = F_OnMoneyLimitDelete
             , ['OnNegDeal'] = F_OnNegDeal
             , ['OnNegTrade'] = F_OnNegTrade
             , ['OnOrder'] = F_OnOrder
             , ['OnParam'] = F_OnParam
             , ['OnQuote'] = F_OnQuote
--             , ['OnStop'] = F_OnStop
             , ['OnStopOrder'] = F_OnStopOrder
             , ['OnTrade'] = F_OnTrade
             , ['OnTransReply'] = F_OnTransReply
          }
         
    install_event_handling_functions (tbl_fun)   -- Установка таблицы функций обработки событий фондового рынка --- 
    ----
    for i, v in next, condition_subscribe() do
        message( 'Скрипт подписан на событие фондового рынка ' .. i )
    end
     ---  Работа с событиями фондового рынка ----
    -------------------
    while IsRun do 
        ---- Функция обработки всех событий QUIK:  function handle_events(lim)   -----
        --  Параметр lim (по умолчанию равен 1000000)  определяет максимальное количестко событий, обрабатаваемых за один вызов функции --
        --- Если очереди событий пусты, то функция завершается.
        --  Результат (их три):  1) количество обработанных событий в вызове функции; 2) максимальное количество обработанных событий за один вызов функции; 
        -- 3) максимальная задержка (в сек.) между записью и чтением событий (в вызове функции).
        local event_counter, event_counter_max, read_latency_max = handle_events()  ----   Обработка всех событий QUIK  ----
      if event_counter > 0 then  -- В очередях были события ----
            message ( 'event_counter: ' .. event_counter ..  ';  read_latency_max: ' .. read_latency_max  )
      end   
       ----  Обработка в main остального -----
   
   
       ----  Конец Обработка в main остального -----
        sleep(2)  
  end
  ------------------
end   
   
function OnStop()
     IsRun = false
    DestroyTable(TableQUIK)
     DestroyTable(TableQUIK1)
    return 10000   --  !!  По истечении этого интервала времени (в млсек.), данного скрипту на завершение работы, функция main() завершается принудительно. 
                                -- При этом возможна потеря системных ресурсов.   ! Если функция не выдает значение, то по умолчанию оно 5000 (5 сек.)
end

---- Реализация циклических потокобезопасных очередей без синхронизации для случая, когда один поток в нее пишет, а другой читает  (!не допустимы чтения или записи в нескольких потоках)------
local Queue_safe = {
  ---  size_Queue - размер очереди  ----
  new = function (self, size_Queue)
    local  Queue = {}
    local  cycl = {}      -- таблица-массив хранения элементов очереди
    for i =1, size_Queue do 
        cycl[i] = 0 
   end
   Queue.cycl = cycl
    Queue.QueueLength = size_Queue  --- размер очереди    ---
    Queue.RecordPointer = 1   ---  указатель записи  (изменяется только "писателем")     ---
    Queue.ReadingPointer = 1 ---  указатель чтения  (изменяется только "читателем")     ---
   Queue.written_down = 0   --- количество записанных элементов ---
   Queue.read = 0  --- количество считанных элементов ---
    return setmetatable(Queue, {__index = self})     --- для переключения на Queue_safe при обращение в созданной таблице к push, pop, size  ----
  end,
  
  --- Записываемое в очередь значение не может быть nil  --
  --  Результат: 0 - запись выполнена;  1 -  запись не выполнена (нет места) 
  push = function (self, v)  
        if v == nil then  error(' !!! В очередь нельзя записывать  nil ')  end
      if  self.written_down - self.read >= self.QueueLength then      ----- некуда писать  ----
              return (1)   
        end
        local  cycl = self.cycl
        local pwt=  self.RecordPointer
      cycl [pwt] = v
      local pwf =  pwt +1
        if  pwf  > self.QueueLength then
             pwf=1
        end
        self.RecordPointer = pwf  --- следующая позиция для записи (возможно занятая) --   
      self.written_down = self.written_down + 1
        return (0)
  end,
 
  ---  Два результата: 1) элемент или nil;     2) признак: 0 - очередь после чтения пуста;  > 0 - количество непрочитанных элементов;   -1 - очередь пуста в момент чтения;
  pop = function (self)
      local n = self.written_down - self.read 
      if  n == 0 then
           return nil, -1  --- нет данных
      end
     local  cycl = self.cycl 
     local prt=  self.ReadingPointer
     local v = cycl [prt]
     cycl [prt] = 0      ---  чтобы не было "висячих" ссылок на ссылочные объекты  ----
      prt =  prt +1
      if  prt  > self.QueueLength then
            prt = 1
      end
     self.ReadingPointer = prt
     self.read = self.read + 1
     return  v,  n - 1 
  end,

  size = function (self)
    return self.written_down - self.read
  end
}
----------------------------------------------------------------------
                                                                                            ------  Тесты  -----
local T 
local v
--[[
 --  1.  Этот фрагмент (использование потокобезопасных функций QLua)   (100 000 записей и чтений)  выполняется за ~3560 милисекунд ---
T = {}
for j = 1, 100  do 
  for i = 1, 1000 do  --- запись в очередь
     table.sinsert (T, 'sd')   
  end

  for i = 1, 1000 do  --- чтение из очереди
     v = T[1]
    table.sremove (T, 1)
  end
end
do return end      ------
 -----------------------------------------------------------------
--]]

 --  2. Этот фрагмент (использование Queue_safe)   (100 000 записей и чтений)  выполняется за ~55 милисекунд ---
T = Queue_safe:new(1200) 
  
 for j = 1, 100  do 
  for i = 1, 1000 do  --- запись в очередь
     T: push('sd')
  end

  for i = 1, 1000 do  --- чтение из очереди
     v = T: pop()
  end
end
--------------------------------------------------------------

----  Скрипт -тест  ----
 --  Этот фрагмент выполняется  ~500 милисекунд ---
local T = {}
local v
for j = 1, 10  do 
  for i = 1, 1000 do  --- запись в очередь
     table.sinsert  (T, {'sdfdfmffmf', 57})
--     v = T[1]
--    table.sremove(T, 1)
  end

  for i = 1, 1000 do  --- чтение из очереди
 --    table.sinsert  (T, {'sdfdfmffmf', 57})
     v = T[1]
    table.sremove(T, 1)
  end
end