24939412195

Committed 25 Apr 2026 07:59PM UTC coverage: 25.624% (-0.04%) from 25.659%

Build # 24939412195

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #224 from traintastic/diagnostic-report

Add diagnostic report feature

Coverage Stats

1 of 46 new or added lines in 4 files covered. (2.17%)

2 existing lines in 2 files now uncovered.

8426 of 32883 relevant lines covered (25.62%)

177.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/server/src/network/session.cpp

/**
 * This file is part of Traintastic,
 * see <https://github.com/traintastic/traintastic>.
 *
 * Copyright (C) 2019-2026 Reinder Feenstra
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

#include "session.hpp"
#include <boost/algorithm/string.hpp>
#include <boost/uuid/random_generator.hpp>
#include "../traintastic/traintastic.hpp"
#include "clientconnection.hpp"
#include <traintastic/enum/interfaceitemtype.hpp>
#include <traintastic/enum/attributetype.hpp>
#include "../compat/stdformat.hpp"
#ifndef NDEBUG
  #include "../core/eventloop.hpp" // for: isEventLoopThread()
#endif
#include "../core/abstractobjectlist.hpp"
#include "../core/abstractunitproperty.hpp"
#include "../core/objectproperty.tpp"
#include "../core/tablemodel.hpp"
#include "../log/log.hpp"
#include "../log/logmessageexception.hpp"
#include "../log/memorylogger.hpp"
#include "../board/board.hpp"
#include "../board/tile/tiles.hpp"
#include "../hardware/input/monitor/inputmonitor.hpp"
#include "../hardware/output/keyboard/outputkeyboard.hpp"
#include "../throttle/clientthrottle.hpp"

#ifdef GetObject
  #undef GetObject // GetObject is defined by a winapi header
#endif

namespace {

std::pair<std::string_view, std::string_view> splitOnLastDot(std::string_view sv)
{
  if(const auto pos = sv.rfind('.'); pos != std::string_view::npos)
  {
    return {sv.substr(0, pos), sv.substr(pos + 1)};
  }
  return {{}, sv};
}

}

Session::Session(const std::shared_ptr<ClientConnection>& connection) :
  m_connection{connection},
  m_uuid{boost::uuids::random_generator()()}
{
  assert(isEventLoopThread());
}

Session::~Session()
{
  assert(isEventLoopThread());

  m_objectSignals.clear(); // disconnect all, we don't want m_handles modified during the loop
  for(const auto& it : m_handles)
  {
    if(it.second && isSessionObject(it.second))
    {
      it.second->destroy();
    }
  }
}

bool Session::processMessage(const Message& message)
{
  switch(message.command())
  {
    case Message::Command::GetObject:
    {
      std::string id;
      message.read(id);

      std::vector<std::string> ids;
      boost::split(ids, id, [](char c){ return c == '.'; });
      auto it = ids.cbegin();

      ObjectPtr obj;
      if(*it == Traintastic::classId)
        obj = Traintastic::instance;
      else if(Traintastic::instance->world)
        obj = Traintastic::instance->world->getObjectById(*it);

      while(obj && ++it != ids.cend())
      {
        if(AbstractProperty* property = obj->getProperty(*it); property && property->type() == ValueType::Object)
          obj = property->toObject();
        else if(AbstractVectorProperty* vectorProperty = obj->getVectorProperty(*it); vectorProperty && vectorProperty->type() == ValueType::Object)
        {
          obj = nullptr;
          const size_t size = vectorProperty->size();
          for(size_t i = 0; i < size; i++)
          {
            ObjectPtr v = vectorProperty->getObject(i);
            if(id == v->getObjectId())
            {
              obj = v;
              it++;
              break;
            }
          }
        }
        else
          obj = nullptr;
      }

      if(obj)
      {
        auto response = Message::newResponse(message.command(), message.requestId());
        writeObject(*response, obj);
        m_connection->sendMessage(std::move(response));
      }
      else
      {
        m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1015_UNKNOWN_OBJECT));
      }
      return true;
    }
    case Message::Command::ReleaseObject:
    {
      // client counter value must match server counter value,
      // to make sure no handles are "on the wire"
      //
      const auto handle = message.read<Handle>();
      const auto counter = message.read<uint32_t>();
      if(counter == m_handles.getCounter(handle))
      {
        if(auto object = m_handles.getItem(handle); object && isSessionObject(object))
        {
          object->destroy();
        }

        m_handles.removeHandle(handle);

        auto it = m_objectSignals.find(handle);
        while(it != m_objectSignals.end())
        {
          it->second.disconnect();
          m_objectSignals.erase(it);
          it = m_objectSignals.find(handle);
        }

        auto event = Message::newEvent(message.command(), sizeof(Handle));
        event->write(handle);
        m_connection->sendMessage(std::move(event));
      }
      break;
    }
    case Message::Command::ObjectSetProperty:
    {
      if(message.isRequest() || message.isEvent())
      {
        if(ObjectPtr object = m_handles.getItem(message.read<Handle>()))
        {
          if(AbstractProperty* property = object->getProperty(message.read<std::string>()); property && !property->isInternal())
          {
            try
            {
              switch(message.read<ValueType>())
              {
                case ValueType::Boolean:
                  property->fromBool(message.read<bool>());
                  break;

                case ValueType::Integer:
                  property->fromInt64(message.read<int64_t>());
                  break;

                case ValueType::Float:
                  property->fromDouble(message.read<double>());
                  break;

                case ValueType::String:
                  property->fromString(message.read<std::string>());
                  break;

                default:
                  throw std::runtime_error("invalid value type");
              }
            }
            catch(const std::exception& e) // set property failed
            {
              if(message.isRequest()) // send error response
              {
                m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1018_EXCEPTION_X, e.what()));
              }
              else // send changed event with current value:
                objectPropertyChanged(*property);
            }

            if(message.isRequest()) // send success response
              m_connection->sendMessage(Message::newResponse(message.command(), message.requestId()));
          }
          else if(message.isRequest()) // send error response
          {
            m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1016_UNKNOWN_PROPERTY));
          }
        }
        else if(message.isRequest()) // send error response
        {
          m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1015_UNKNOWN_OBJECT));
        }
      }
      return true;
    }
    case Message::Command::ObjectSetVectorProperty:
    {
      if(message.isRequest() || message.isEvent())
      {
        if(ObjectPtr object = m_handles.getItem(message.read<Handle>()))
        {
          if(AbstractVectorProperty* property = object->getVectorProperty(message.read<std::string>()); property && !property->isInternal())
          {
            try
            {
              const size_t index = message.read<uint32_t>();

              switch(message.read<ValueType>())
              {
                case ValueType::Boolean:
                  property->setBool(index, message.read<bool>());
                  break;

                case ValueType::Integer:
                  property->setInt64(index, message.read<int64_t>());
                  break;

                case ValueType::Float:
                  property->setDouble(index, message.read<double>());
                  break;

                case ValueType::String:
                  property->setString(index, message.read<std::string>());
                  break;

                default:
                  throw std::runtime_error("invalid value type");
              }
            }
            catch(const std::exception& e) // set property failed
            {
              if(message.isRequest()) // send error response
              {
                m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1018_EXCEPTION_X, e.what()));
              }
              else // send changed event with current value:
                objectPropertyChanged(*property);
            }

            if(message.isRequest()) // send success response
              m_connection->sendMessage(Message::newResponse(message.command(), message.requestId()));
          }
          else if(message.isRequest()) // send error response
          {
            m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1016_UNKNOWN_PROPERTY));
          }
        }
        else if(message.isRequest()) // send error response
        {
          m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1015_UNKNOWN_OBJECT));
        }
      }
      return true;
    }
    case Message::Command::ObjectSetUnitPropertyUnit:
    {
      if(ObjectPtr object = m_handles.getItem(message.read<Handle>()))
      {
        if(AbstractUnitProperty* property = dynamic_cast<AbstractUnitProperty*>(object->getProperty(message.read<std::string>())); property && !property->isInternal())
        {
          try
          {
            property->setUnitValue(message.read<int64_t>());
          }
          catch(const std::exception&)
          {
            // set unit property unit failed, send changed event with current value:
            objectPropertyChanged(*property);
          }
        }
      }
      break;
    }
    case Message::Command::ObjectGetObjectPropertyObject:
      if(message.isRequest())
      {
        if(ObjectPtr object = m_handles.getItem(message.read<Handle>()))
        {
          if(auto* property = object->getObjectProperty(message.read<std::string>()); property && !property->isInternal())
          {
            if(auto obj = property->toObject())
            {
              auto response = Message::newResponse(message.command(), message.requestId());
              writeObject(*response, obj);
              m_connection->sendMessage(std::move(response));
            }
            else
              m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1015_UNKNOWN_OBJECT));
          }
          else // send error response
            m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1016_UNKNOWN_PROPERTY));
        }
        else // send error response
          m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1015_UNKNOWN_OBJECT));

        return true;
      }
      break;

    case Message::Command::ObjectGetObjectVectorPropertyObject:
      if(message.isRequest())
      {
        if(ObjectPtr object = m_handles.getItem(message.read<Handle>()))
        {
          if(auto* property = object->getVectorProperty(message.read<std::string>()); property && !property->isInternal())
          {
            const size_t startIndex = message.read<uint32_t>();
            const size_t endIndex = message.read<uint32_t>();

            if(endIndex >= startIndex && endIndex < property->size())
            {
              auto response = Message::newResponse(message.command(), message.requestId());
              for(size_t i = startIndex; i <= endIndex; i++)
                writeObject(*response, property->getObject(i));
              m_connection->sendMessage(std::move(response));
            }
            else // send error response
              m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1017_INVALID_INDICES));
          }
          else // send error response
            m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1016_UNKNOWN_PROPERTY));
        }
        else // send error response
          m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1015_UNKNOWN_OBJECT));

        return true;
      }
      break;

    case Message::Command::ObjectSetObjectPropertyById:
    {
      if(ObjectPtr object = m_handles.getItem(message.read<Handle>()))
      {
        if(AbstractObjectProperty* property = dynamic_cast<AbstractObjectProperty*>(object->getProperty(message.read<std::string>())); property && !property->isInternal())
        {
          try
          {
            const auto id = message.read<std::string>();
            if(!id.empty())
            {
              if(ObjectPtr obj = Traintastic::instance->world->getObjectByPath(id))
                property->fromObject(obj);
              else
                throw std::runtime_error("");
            }
            else
              property->fromObject(nullptr);
          }
          catch(const std::exception&)
          {
            // set object property failed, send changed event with current value:
            objectPropertyChanged(*property);
          }
        }
      }
      break;
    }
    case Message::Command::ObjectCallMethod:
    {
      if(ObjectPtr object = m_handles.getItem(message.read<Handle>()))
      {
        if(AbstractMethod* method = object->getMethod(message.read<std::string>()); method && !method->isInternal())
        {
          if(callMethod(message, *method))
          {
            return true;
          }
        }
      }
      break;
    }
    case Message::Command::CallMethod:
    {
      const auto path = message.read<std::string_view>();
      const auto [objectPath, methodName] = splitOnLastDot(path);

      if(const auto& world = Traintastic::instance->world.value())
      {
        if(ObjectPtr object = world->getObjectByPath(objectPath))
        {
          if(AbstractMethod* method = object->getMethod(methodName); method && !method->isInternal())
          {
            if(callMethod(message, *method))
            {
              return true;
            }
          }
        }
      }
      break;
    }
    case Message::Command::GetTableModel:
    {
      if(ObjectPtr object = m_handles.getItem(message.read<Handle>()))
      {
        if(auto* table = dynamic_cast<Table*>(object.get()))
        {
          TableModelPtr model = table->getModel();
          assert(model);
          auto response = Message::newResponse(message.command(), message.requestId());
          writeTableModel(*response, model);
          m_connection->sendMessage(std::move(response));

          model->columnHeadersChanged = [this](const TableModelPtr& tableModel)
            {
              auto event = Message::newEvent(Message::Command::TableModelColumnHeadersChanged);
              event->write(m_handles.getHandle(std::dynamic_pointer_cast<Object>(tableModel)));
              event->write(tableModel->columnCount());
              for(const auto& text : tableModel->columnHeaders())
                event->write(text);
              m_connection->sendMessage(std::move(event));
            };

          model->rowCountChanged = [this](const TableModelPtr& tableModel)
            {
              auto event = Message::newEvent(Message::Command::TableModelRowCountChanged);
              event->write(m_handles.getHandle(std::dynamic_pointer_cast<Object>(tableModel)));
              event->write(tableModel->rowCount());
              m_connection->sendMessage(std::move(event));
            };

          model->updateRegion = [this](const TableModelPtr& tableModel, const TableModel::Region& region)
            {
              auto event = Message::newEvent(Message::Command::TableModelUpdateRegion);
              event->write(m_handles.getHandle(std::dynamic_pointer_cast<Object>(tableModel)));
              event->write(region.columnMin);
              event->write(region.columnMax);
              event->write(region.rowMin);
              event->write(region.rowMax);

              for(uint32_t row = region.rowMin; row <= region.rowMax; row++)
                for(uint32_t column = region.columnMin; column <= region.columnMax; column++)
                  event->write(tableModel->getText(column, row));

              m_connection->sendMessage(std::move(event));
            };

          return true;
        }
      }
      m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1019_OBJECT_NOT_A_TABLE));
      return true;
    }
    case Message::Command::ReleaseTableModel:
      m_handles.removeHandle(message.read<Handle>());
      break;

    case Message::Command::TableModelSetRegion:
    {
      TableModelPtr model = std::dynamic_pointer_cast<TableModel>(m_handles.getItem(message.read<Handle>()));
      if(model)
      {
        TableModel::Region region;
        message.read(region.columnMin);
        message.read(region.columnMax);
        message.read(region.rowMin);
        message.read(region.rowMax);
        model->setRegion(region);
      }
      break;
    }
    case Message::Command::InputMonitorGetInputInfo:
    {
      auto inputMonitor = std::dynamic_pointer_cast<InputMonitor>(m_handles.getItem(message.read<Handle>()));
      if(inputMonitor)
      {
        auto inputInfo = inputMonitor->getInputInfo();
        auto response = Message::newResponse(message.command(), message.requestId());
        response->write<uint32_t>(inputInfo.size());
        for(auto& info : inputInfo)
        {
          response->write(info.address);
          response->write(info.used);
          response->write(info.value);
        }
        m_connection->sendMessage(std::move(response));
        return true;
      }
      break;
    }
    case Message::Command::OutputKeyboardGetOutputInfo:
    {
      auto outputKeyboard = std::dynamic_pointer_cast<OutputKeyboard>(m_handles.getItem(message.read<Handle>()));
      if(outputKeyboard)
      {
        const auto outputType = outputKeyboard->outputType.value();
        auto outputInfo = outputKeyboard->getOutputInfo();
        auto response = Message::newResponse(message.command(), message.requestId());
        response->write<uint32_t>(outputInfo.size());
        for(auto& info : outputInfo)
        {
          response->write(info.address);
          response->write(info.used);
          switch(outputType)
          {
            case OutputType::Single:
              response->write(std::get<TriState>(info.value));
              break;

            case OutputType::Pair:
              response->write(std::get<OutputPairValue>(info.value));
              break;

            case OutputType::Aspect: /*[[unlikely]]*/
            case OutputType::ECoSState: /*[[unlikely]]*/
              assert(false);
              break;
          }
        }
        m_connection->sendMessage(std::move(response));
        return true;
      }
      break;
    }
    case Message::Command::BoardGetTileData:
    {
      auto board = std::dynamic_pointer_cast<Board>(m_handles.getItem(message.read<Handle>()));
      if(board)
      {
        auto response = Message::newResponse(message.command(), message.requestId());
        for(const auto& it : board->tileMap())
        {
          const Tile& tile = *(it.second);
          if(it.first != tile.location()) // only tiles at origin
            continue;
          response->write(tile.location());
          response->write(tile.data());
          assert(tile.data().isActive() == isActive(tile.data().id()));
          if(tile.data().isActive())
            writeObject(*response, it.second);
        }
        m_connection->sendMessage(std::move(response));
        return true;
      }
      break;
    }
    case Message::Command::BoardGetTileInfo:
    {
      auto response = Message::newResponse(message.command(), message.requestId());
      const auto& info = Tiles::getInfo();
      response->write<uint32_t>(info.size());
      for(const auto& item : info)
      {
        response->writeBlock();
        response->write(item.classId);
        response->write(item.tileId);
        response->write(item.rotates);
        response->write(item.menu);
        response->writeBlockEnd();
      }
      m_connection->sendMessage(std::move(response));
      return true;
    }
    case Message::Command::ServerLog:
      if(message.read<bool>())
      {
        if(auto* logger = Log::getMemoryLogger())
        {
          m_memoryLoggerChanged = logger->changed.connect(std::bind(&Session::memoryLoggerChanged, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
          memoryLoggerChanged(*logger, logger->size(), 0);
        }
      }
      else // disable
        m_memoryLoggerChanged.disconnect();
      break;

    case Message::Command::ImportWorld:
      if(message.isRequest())
      {
        try
        {
          std::vector<std::byte> worldData;
          message.read(worldData);
          Traintastic::instance->importWorld(worldData);
          m_connection->sendMessage(Message::newResponse(message.command(), message.requestId()));
        }
        catch(const LogMessageException& e)
        {
          m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), e.message(), e.args()));
        }
      }
      break;

    case Message::Command::ExportWorld:
      if(message.isRequest())
      {
        if(Traintastic::instance->world)
        {
          try
          {
            std::vector<std::byte> worldData;
            Traintastic::instance->world->export_(worldData);
            auto response = Message::newResponse(message.command(), message.requestId());
            response->write(worldData);
            m_connection->sendMessage(std::move(response));
          }
          catch(const LogMessageException& e)
          {
            m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), e.message(), e.args()));
          }
        }
        else
        {
          m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1010_EXPORTING_WORLD_FAILED_X, "nullptr"));
        }
        return true;
      }
      break;

    case Message::Command::CreateObject:
      if(message.isRequest())
      {
        if(Traintastic::instance->world)
        {
          const auto classId = message.read<std::string_view>();
          if(classId == ClientThrottle::classId)
          {
            auto throttle = ClientThrottle::create(*Traintastic::instance->world);
            auto response = message.response();
            writeObject(*response, throttle);
            m_connection->sendMessage(std::move(response));
          }
          else
          {
            m_connection->sendMessage(message.errorResponse(LogMessage::C1015_UNKNOWN_OBJECT)); // FIXME change error
          }
        }
        else
        {
          m_connection->sendMessage(message.errorResponse(LogMessage::C1015_UNKNOWN_OBJECT)); // FIXME change error
        }
        return true;
      }
      break;

    case Message::Command::ObjectListGetObjects:
      if(message.isRequest())
      {
        if(ObjectPtr object = m_handles.getItem(message.read<Handle>()))
        {
          if(auto* list = dynamic_cast<AbstractObjectList*>(object.get()))
          {
            const uint32_t startIndex = message.read<uint32_t>();
            const uint32_t endIndex = message.read<uint32_t>();

            if(endIndex >= startIndex && endIndex < list->length.value())
            {
              auto response = message.response();
              for(uint32_t i = startIndex; i <= endIndex; i++)
              {
                writeObject(*response, list->getObject(i));
              }
              m_connection->sendMessage(std::move(response));
            }
            else // send error response
            {
              m_connection->sendMessage(message.errorResponse(LogMessage::C1017_INVALID_INDICES));
            }
          }
          else
          {
            m_connection->sendMessage(message.errorResponse(LogMessage::C1015_UNKNOWN_OBJECT));
          }
        }
        else
        {
          m_connection->sendMessage(message.errorResponse(LogMessage::C1015_UNKNOWN_OBJECT));
        }
        return true;
      }
      break;

    case Message::Command::GetDiagnosticReport:
      if(message.isRequest())
      {
        auto response = message.response();

        response->write(Traintastic::getInfo());

        {
          std::string serverLog;
          if(auto* memoryLogger = Log::getMemoryLogger())
          {
            serverLog.reserve(memoryLogger->size() * 50); // ~50 chars/line

#ifdef HAS_CXX20_TIMEZONES
            const auto tz = std::chrono::current_zone();
#endif
            for(const auto& log : *memoryLogger)
            {
#ifdef HAS_CXX20_TIMEZONES
              const std::chrono::zoned_time zoneTime{tz, log.time};
              const auto localTime = zoneTime.get_local_time();
#else
              const auto localTime = log.time;
#endif
              const auto s = std::chrono::floor<std::chrono::seconds>(localTime);
              const auto us = std::chrono::duration_cast<std::chrono::microseconds>(localTime - s).count();

              serverLog.append(
                std::format(
                  "{:%Y-%m-%d;%H:%M:%S}.{:06}"
#ifdef HAS_CXX20_TIMEZONES
                  "{:%z}"
#endif
                  ";{};{}{:04};",
                  s,
                  us,
#ifdef HAS_CXX20_TIMEZONES
                  zoneTime,
#endif
                  log.objectId,
                  logMessageChar(log.message),
                  logMessageNumber(log.message)));

              if(log.args)
              {
                serverLog.append(Logger::toString(log.message, *log.args));
              }
              else
              {
                serverLog.append(Logger::toString(log.message));
              }

              serverLog.append("\n");
            }
          }
          response->write(serverLog);
        }

        {
          std::vector<std::byte> worldData;
          Traintastic::instance->world->export_(worldData);
          response->write(worldData);
        }

        m_connection->sendMessage(std::move(response));
      }
      break;

    default:
      break;
  }
  return false;
}

bool Session::isSessionObject(const ObjectPtr& object)
{
  assert(object);
  return dynamic_cast<ClientThrottle*>(object.get());
}

bool Session::callMethod(const Message& message, AbstractMethod& method)
{
  const auto resultType = message.read<ValueType>();
  const auto argumentCount = message.read<uint8_t>();

  Arguments args;
  for(uint8_t i = 0; i < argumentCount; i++)
  {
    switch(message.read<ValueType>())
    {
      case ValueType::Boolean:
        args.push_back(message.read<bool>());
        break;

      case ValueType::Enum:
      case ValueType::Integer:
      case ValueType::Set:
        args.push_back(message.read<int64_t>());
        break;

      case ValueType::Float:
        args.push_back(message.read<double>());
        break;

      case ValueType::String:
      {
        auto arg = message.read<std::string>();
        if(i < method.argumentTypeInfo().size() && method.argumentTypeInfo()[i].type == ValueType::Object)
        {
          if(arg.empty())
            args.push_back(ObjectPtr());
          else if(ObjectPtr obj = Traintastic::instance->world->getObjectByPath(arg))
            args.push_back(obj);
          else
            args.push_back(arg);
        }
        else
          args.push_back(arg);
        break;
      }
      case ValueType::Object:
        args.push_back(m_handles.getItem(message.read<Handle>()));
        break;

      default:
        assert(false);
        break;
    }
  }

  try
  {
    AbstractMethod::Result result = method.call(args);

    if(message.isRequest())
    {
      auto response = Message::newResponse(message.command(), message.requestId());

      switch(resultType)
      {
        case ValueType::Boolean:
          response->write(std::get<bool>(result));
          break;

        case ValueType::Integer:
        case ValueType::Enum:
        case ValueType::Set:
          response->write(std::get<int64_t>(result));
          break;

        case ValueType::Float:
          response->write(std::get<double>(result));
          break;

        case ValueType::String:
          response->write(std::get<std::string>(result));
          break;

        case ValueType::Object:
          writeObject(*response, std::get<ObjectPtr>(result));
          break;

        case ValueType::Invalid:
          break;
      }

      m_connection->sendMessage(std::move(response));
      return true;
    }
  }
  catch(const LogMessageException& e)
  {
    if(message.isRequest())
    {
      m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), e.message(), e.args()));
      return true;
    }
    // we can't report it back to the caller, so just log it.
    Log::log(method.object(), e.message(), e.args());
  }
  catch(const std::exception& e)
  {
    if(message.isRequest())
    {
      m_connection->sendMessage(Message::newErrorResponse(message.command(), message.requestId(), LogMessage::C1018_EXCEPTION_X, e.what()));
      return true;
    }
  }
  return false;
}

void Session::writeObject(Message& message, const ObjectPtr& object)
{
  message.writeBlock(); // object

  auto handle = m_handles.getHandle(object);
  if(handle == Handles::invalidHandle)
  {
    using namespace std::placeholders;

    handle = m_handles.addItem(object);

    m_objectSignals.emplace(handle, object->onDestroying.connect(std::bind(&Session::objectDestroying, this, std::placeholders::_1)));
    m_objectSignals.emplace(handle, object->propertyChanged.connect(std::bind(&Session::objectPropertyChanged, this, std::placeholders::_1)));
    m_objectSignals.emplace(handle, object->attributeChanged.connect(std::bind(&Session::objectAttributeChanged, this, std::placeholders::_1)));

    if(auto* board = dynamic_cast<Board*>(object.get()))
    {
      m_objectSignals.emplace(handle, board->tileDataChanged.connect(std::bind(&Session::boardTileDataChanged, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)));
    }

    bool hasPublicEvents = false;

    message.write(handle);
    message.write(object->getClassId());

    message.writeBlock(); // items
    const InterfaceItems& interfaceItems = object->interfaceItems();
    for(const auto& name : interfaceItems.names())
    {
      InterfaceItem& item = interfaceItems[name];

      if(item.isInternal())
        continue;

      message.writeBlock(); // item
      message.write(name);

      if(auto* baseProperty = dynamic_cast<BaseProperty*>(&item))
      {
        AbstractProperty* property = nullptr;
        AbstractUnitProperty* unitProperty = nullptr;
        AbstractVectorProperty* vectorProperty = nullptr;

        if((property = dynamic_cast<AbstractProperty*>(baseProperty)))
        {
          if((unitProperty = dynamic_cast<AbstractUnitProperty*>(property)))
            message.write(InterfaceItemType::UnitProperty);
          else
            message.write(InterfaceItemType::Property);
        }
        else if((vectorProperty = dynamic_cast<AbstractVectorProperty*>(baseProperty)))
          message.write(InterfaceItemType::VectorProperty);
        else
        {
          assert(false);
          continue;
        }

        message.write(baseProperty->flags());
        message.write(baseProperty->type());

        if(baseProperty->type() == ValueType::Enum)
          message.write(baseProperty->enumName());
        else if(baseProperty->type() == ValueType::Set)
          message.write(baseProperty->setName());

        if(property)
        {
          writePropertyValue(message, *property);

          if(unitProperty)
          {
            message.write(unitProperty->unitName());
            message.write(unitProperty->unitValue());
          }
        }
        else if(vectorProperty)
          writeVectorPropertyValue(message, *vectorProperty);
        else
          assert(false);
      }
      else if(const auto* method = dynamic_cast<const AbstractMethod*>(&item))
      {
        message.write(InterfaceItemType::Method);
        message.write(method->resultTypeInfo().type);
        message.write(static_cast<uint8_t>(method->argumentTypeInfo().size()));
        for(const auto& info : method->argumentTypeInfo())
          message.write(info.type);
      }
      else if(const auto* event = dynamic_cast<const AbstractEvent*>(&item))
      {
        hasPublicEvents = true;

        message.write(InterfaceItemType::Event);
        message.write(static_cast<uint8_t>(event->argumentTypeInfo().size()));
        for(const auto& typeInfo : event->argumentTypeInfo())
          writeTypeInfo(message, typeInfo);
      }
      else
        assert(false);

      message.writeBlock(); // attributes

      for(const auto& it : item.attributes())
      {
        const AbstractAttribute& attribute = *it.second;
        message.writeBlock(); // attribute
        writeAttribute(message, attribute);
        message.writeBlockEnd(); // end attribute
      }

      message.writeBlockEnd(); // end attributes
      message.writeBlockEnd(); // end item
    }
    message.writeBlockEnd(); // end items

    if(hasPublicEvents)
      m_objectSignals.emplace(handle, object->onEventFired.connect(std::bind(&Session::objectEventFired, this, std::placeholders::_1, std::placeholders::_2)));
  }
  else
    message.write(handle);

  message.writeBlockEnd(); // end object
}

void Session::writeTableModel(Message& message, const TableModelPtr& model)
{
  message.writeBlock(); // model
  assert(m_handles.getHandle(std::dynamic_pointer_cast<Object>(model)) == Handles::invalidHandle);
  auto handle = m_handles.addItem(std::dynamic_pointer_cast<Object>(model));
  message.write(handle);
  message.write(model->getClassId());
  message.write(model->columnCount());
  for(const auto& text : model->columnHeaders())
    message.write(text);
  message.write(model->rowCount());
  message.writeBlockEnd(); // end model
}

void Session::memoryLoggerChanged(const MemoryLogger& logger, const uint32_t added, const uint32_t removed)
{
  auto event = Message::newEvent(Message::Command::ServerLog);
  event->write(removed);
  event->write(added);

  const uint32_t size = logger.size();
  for(uint32_t i = size - added; i < size; i++)
  {
    const auto& log = logger[i];
    event->write((std::chrono::duration_cast<std::chrono::microseconds>(log.time.time_since_epoch())).count());
    event->write(log.objectId);
    event->write(log.message);
    const size_t argc = log.args ? std::min<size_t>(log.args->size(), std::numeric_limits<uint8_t>::max()) : 0;
    event->write(static_cast<uint8_t>(argc));
    for(size_t j = 0; j < argc; j++)
      event->write(log.args->at(j));
  }

  m_connection->sendMessage(std::move(event));
}

void Session::objectDestroying(Object& object)
{
  const auto handle = m_handles.getHandle(object.shared_from_this());
  m_handles.removeHandle(handle);
  m_objectSignals.erase(handle);

  auto event = Message::newEvent(Message::Command::ObjectDestroyed, sizeof(Handle));
  event->write(handle);
  m_connection->sendMessage(std::move(event));
}

void Session::objectPropertyChanged(BaseProperty& baseProperty)
{
  if(baseProperty.isInternal())
    return;

  auto event = Message::newEvent(Message::Command::ObjectPropertyChanged);
  event->write(m_handles.getHandle(baseProperty.object().shared_from_this()));
  event->write(baseProperty.name());
  event->write(baseProperty.type());
  if(auto* property = dynamic_cast<AbstractProperty*>(&baseProperty))
  {
    writePropertyValue(*event, *property);

    if(auto* unitProperty = dynamic_cast<AbstractUnitProperty*>(property))
      event->write(unitProperty->unitValue());
  }
  else if(auto* vectorProperty = dynamic_cast<AbstractVectorProperty*>(&baseProperty))
    writeVectorPropertyValue(*event, *vectorProperty);
  else
    assert(false);

  m_connection->sendMessage(std::move(event));
}

void Session::writePropertyValue(Message& message , const AbstractProperty& property)
{
  switch(property.type())
  {
    case ValueType::Boolean:
      message.write(property.toBool());
      break;

    case ValueType::Enum:
    case ValueType::Integer:
    case ValueType::Set:
      message.write(property.toInt64());
      break;

    case ValueType::Float:
      message.write(property.toDouble());
      break;

    case ValueType::String:
      message.write(property.toString());
      break;

    case ValueType::Object:
      if(ObjectPtr obj = property.toObject())
        message.write(obj->getObjectId());
      else
        message.write<std::string_view>("");
      break;

    case ValueType::Invalid:
      assert(false);
      break;
  }
}

void Session::writeVectorPropertyValue(Message& message , const AbstractVectorProperty& vectorProperty)
{
  const size_t size = vectorProperty.size();
  message.write(static_cast<uint32_t>(size));

  switch(vectorProperty.type())
  {
    case ValueType::Boolean:
      for(size_t i = 0; i < size; i++)
        message.write(vectorProperty.getBool(i));
      break;

    case ValueType::Enum:
    case ValueType::Integer:
    case ValueType::Set:
      for(size_t i = 0; i < size; i++)
        message.write(vectorProperty.getInt64(i));
      break;

    case ValueType::Float:
      for(size_t i = 0; i < size; i++)
        message.write(vectorProperty.getDouble(i));
      break;

    case ValueType::String:
      for(size_t i = 0; i < size; i++)
        message.write(vectorProperty.getString(i));
      break;

    case ValueType::Object:
      for(size_t i = 0; i < size; i++)
        if(ObjectPtr obj = vectorProperty.getObject(i))
          message.write(obj->getObjectId());
        else
          message.write<std::string>("");
      break;

    case ValueType::Invalid:
      assert(false);
      break;
  }
}

void Session::objectAttributeChanged(AbstractAttribute& attribute)
{
  auto event = Message::newEvent(Message::Command::ObjectAttributeChanged);
  event->write(m_handles.getHandle(attribute.item().object().shared_from_this()));
  event->write(attribute.item().name());
  writeAttribute(*event, attribute);
  m_connection->sendMessage(std::move(event));
}

void Session::objectEventFired(const AbstractEvent& event, const Arguments& arguments)
{
  auto message = Message::newEvent(Message::Command::ObjectEventFired);
  message->write(m_handles.getHandle(event.object().shared_from_this()));
  message->write(event.name());
  message->write(static_cast<uint32_t>(arguments.size()));
  size_t i = 0;
  for(const auto& typeInfo : event.argumentTypeInfo())
  {
    switch(typeInfo.type)
    {
      case ValueType::Boolean:
        message->write(std::get<bool>(arguments[i]));
        break;

      case ValueType::Enum:
      case ValueType::Integer:
      case ValueType::Set:
        message->write(std::get<int64_t>(arguments[i]));
        break;

      case ValueType::Float:
        message->write(std::get<double>(arguments[i]));
        break;

      case ValueType::String:
        message->write(std::get<std::string>(arguments[i]));
        break;

      case ValueType::Object:
        if(ObjectPtr obj = std::get<ObjectPtr>(arguments[i]))
          message->write(obj->getObjectId());
        else
          message->write(std::string_view{});
        break;

      case ValueType::Invalid:
        assert(false);
        return;
    }
    i++;
  }
  m_connection->sendMessage(std::move(message));
}

void Session::writeAttribute(Message& message , const AbstractAttribute& attribute)
{
  message.write(attribute.name());
  message.write(attribute.type());
  if(const auto* valueAttribute = dynamic_cast<const AbstractValueAttribute*>(&attribute))
  {
    message.write(AttributeType::Value);
    switch(attribute.type())
    {
      case ValueType::Boolean:
        message.write(valueAttribute->toBool());
        break;

      case ValueType::Enum:
      case ValueType::Integer:
        message.write(valueAttribute->toInt64());
        break;

      case ValueType::Float:
        message.write(valueAttribute->toDouble());
        break;

      case ValueType::String:
        message.write(valueAttribute->toString());
        break;

      default:
        assert(false);
        break;
    }
  }
  else if(const auto* valuesAttributes = dynamic_cast<const AbstractValuesAttribute*>(&attribute))
  {
    const uint32_t length = valuesAttributes->length();
    message.write(AttributeType::Values);
    message.write(length);
    switch(attribute.type())
    {
      case ValueType::Boolean:
        for(uint32_t i = 0; i < length; i++)
          message.write(valuesAttributes->getBool(i));
        break;

      case ValueType::Enum:
      case ValueType::Integer:
        for(uint32_t i = 0; i < length; i++)
          message.write(valuesAttributes->getInt64(i));
        break;

      case ValueType::Float:
        for(uint32_t i = 0; i < length; i++)
          message.write(valuesAttributes->getDouble(i));
        break;

      case ValueType::String:
        for(uint32_t i = 0; i < length; i++)
          message.write(valuesAttributes->getString(i));
        break;

      default:
        assert(false);
        break;
    }
  }
  else
    assert(false);
}

void Session::writeTypeInfo(Message& message, const TypeInfo& typeInfo)
{
  assert((typeInfo.type == ValueType::Enum) != typeInfo.enumName.empty());
  assert((typeInfo.type == ValueType::Set) != typeInfo.setName.empty());

  message.write(typeInfo.type);
  if(typeInfo.type == ValueType::Enum)
    message.write(typeInfo.enumName);
  else if(typeInfo.type == ValueType::Set)
    message.write(typeInfo.setName);
}

void Session::boardTileDataChanged(Board& board, const TileLocation& location, const TileData& data)
{
  auto event = Message::newEvent(Message::Command::BoardTileDataChanged);
  event->write(m_handles.getHandle(board.shared_from_this()));
  event->write(location);
  event->write(data);
  assert(data.isActive() == isActive(data.id()));
  if(data.isActive())
  {
    auto tile = board.getTile(location);
    assert(tile);
    writeObject(*event, tile);
  }
  m_connection->sendMessage(std::move(event));
}

traintastic / traintastic / 24939412195

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous