.. _program_listing_file_include_input_IPC_transmission_MainProcess.hpp:

Program Listing for File MainProcess.hpp
========================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_input_IPC_transmission_MainProcess.hpp>` (``include/input/IPC/transmission/MainProcess.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   #include "PDJE_LOG_SETTER.hpp"
   #include "ipc_shared_memory.hpp"
   #include "PDJE_Buffer.hpp"
   #include "PDJE_Input_DataLine.hpp"
   #include <filesystem>
   #include <functional>
   #include <httplib.h>
   #include <nlohmann/json.hpp>
   #include <optional>
   #include <unordered_map>
   
   
   #ifdef WIN32
   
   #elif defined(__linux__)
   #include <sys/socket.h>
   #include "pack_ipc.hpp"
   #endif
   
   namespace PDJE_IPC {
   using nj = nlohmann::json;
   
   struct Importants {
   #ifdef WIN32
       STARTUPINFOW        start_up_info{};
       PROCESS_INFORMATION process_info{};
   #elif defined(__linux__)
       int         socket_fd = -1;
       int         child_fd  = -1;
       pid_t       child_pid = -1;
       std::string socket_path =
           "/tmp/pdje_input_module_libevdev_socket_path.sock";
   #endif
   };
   
   class MainProcess {
     private:
       std::optional<httplib::Client> cli;
   
       Importants imp;
   
     public:
       template <typename T, int MEM_PROT_FLAG>
       bool
       SendIPCSharedMemory(const SharedMem<T, MEM_PROT_FLAG> &mem,
                           const std::string                 &mem_path,
                           const std::string                 &dataType);
       template <typename T>
                           bool
       SendBufferArena(const PDJE_Buffer_Arena<T> &mem);
       
       std::vector<DeviceData> 
       GetDevices(){
         auto res = cli->Get("/lsdev");
         std::vector<DeviceData> ddvector;
         if(res->status == 200){
           nj jj = nj::parse(res->body);
           for(const auto& i : jj["body"]){
             DeviceData dd;
             dd.device_specific_id = i.at("id").get<std::string>();
             dd.Name = i.at("name").get<std::string>();
             std::string tp = i.at("type").get<std::string>();
             if(tp == "KEYBOARD"){
                 dd.Type = PDJE_Dev_Type::KEYBOARD;
             }
             else if(tp == "MOUSE"){
                 dd.Type = PDJE_Dev_Type::MOUSE;
             }
             else if(tp == "MIDI"){
                 dd.Type = PDJE_Dev_Type::MIDI;
             }
             else if(tp == "HID"){
                 dd.Type = PDJE_Dev_Type::HID;
             }
             else{
                 continue;
             }
             ddvector.push_back(dd);
           }
           return ddvector;
         }else{
           critlog("failed to get device. status code: ");
           critlog(res->status);
           return {};
         }
         
       }
   
       bool
       QueryConfig(const std::string& dumped_json){
         auto res = cli->Post("/config", dumped_json, "application/json");
         if(res->status == 200){
           return true;
         }
         else{
           critlog(res->body);
           return false;
         }
       }
   
       bool
       EndTransmission();
   
       bool
       Kill(){
         auto res = cli->Get("/kill");
         if(res->status == 200){
           return true;
         }
         else{
           critlog(res->body);
           return false;
         }
       }
   
       MainProcess(const int port);
       ~MainProcess();
   };
   
   }; // namespace PDJE_IPC
   
   #ifdef WIN32
   #include "ipc_Send_Windows.tpp"
   #elif defined(__linux__)
   #include "ipc_Send_Linux.tpp"
   #endif