.. _program_listing_file__tmp_ws_src_locator_ros_bridge_bosch_locator_bridge_include_bosch_locator_bridge_enums.hpp:

Program Listing for File enums.hpp
==================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_locator_ros_bridge_bosch_locator_bridge_include_bosch_locator_bridge_enums.hpp>` (``/tmp/ws/src/locator_ros_bridge/bosch_locator_bridge/include/bosch_locator_bridge/enums.hpp``)

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

.. code-block:: cpp

   // Copyright (c) 2021 - for information on the respective copyright owner
   // see the NOTICE file and/or the repository https://github.com/boschglobal/locator_ros_bridge.
   //
   // Licensed under the Apache License, Version 2.0 (the "License");
   // you may not use this file except in compliance with the License.
   // You may obtain a copy of the License at
   //
   //     http://www.apache.org/licenses/LICENSE-2.0
   //
   // Unless required by applicable law or agreed to in writing, software
   // distributed under the License is distributed on an "AS IS" BASIS,
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   // See the License for the specific language governing permissions and
   // limitations under the License.
   
   #ifndef BOSCH_LOCATOR_BRIDGE__ENUMS_HPP_
   #define BOSCH_LOCATOR_BRIDGE__ENUMS_HPP_
   
   #include <cstdint>
   #include <string>
   
   enum ModuleIdentifier : uint16_t
   {
     COMMON = 0x000,
     ABOUT_MODULES = 0x0001,
     SESSION = 0x0002,
     // error in documentation, 0x0002 is used twice
     // DIAGNOSTIC = 0x0002,
     LICENSINGFEATURE = 0x0003,
     CONFIG = 0x0004,
     ABOUT_BUILD = 0x0005,
     CERTIFICATES = 0x0006,
     SYSTEM = 0x0007,
     CLIENT_RECORDING = 0x0100,
     CLIENT_MAP = 0x0101,
     CLIENT_LOCALIZATION = 0x0102,
     CLIENT_MANUAL_ALIGN = 0x0103,
     CLIENT_GLOBAL_ALIGN = 0x0104,
     CLIENT_LASER_MASK = 0x0105,
     CLIENT_USER = 0x0106,
     SERVER_MAP = 0x0200,
     SERVER_USER = 0x0201,
     SUPPORT_REPORT = 0x0300,
     SUPPORT_RECOVERY = 0x0301,
   };
   
   inline std::string stringifyModuleId(ModuleIdentifier id)
   {
     switch (id) {
       case COMMON:
         return "Common";
       case ABOUT_MODULES:
         return "ABOUT_MODULES";
       case SESSION:
         return "SESSION";
       // case DIAGNOSTIC:
       //  return "DIAGNOSTIC";
       case LICENSINGFEATURE:
         return "LICENSINGFEATURE";
       case CONFIG:
         return "CONFIG";
       case ABOUT_BUILD:
         return "ABOUT_BUILD";
       case CERTIFICATES:
         return "CERTIFICATES";
       case SYSTEM:
         return "SYSTEM";
       case CLIENT_RECORDING:
         return "CLIENT_RECORDING";
       case CLIENT_MAP:
         return "CLIENT_MAP";
       case CLIENT_LOCALIZATION:
         return "CLIENT_LOCALIZATION";
       case CLIENT_MANUAL_ALIGN:
         return "CLIENT_MANUAL_ALIGN";
       case CLIENT_GLOBAL_ALIGN:
         return "CLIENT_GLOBAL_ALIGN";
       case CLIENT_LASER_MASK:
         return "CLIENT_LASER_MASK";
       case CLIENT_USER:
         return "CLIENT_USER";
       case SERVER_MAP:
         return "SERVER_MAP";
       case SERVER_USER:
         return "SERVER_USER";
       case SUPPORT_REPORT:
         return "SUPPORT_REPORT";
       case SUPPORT_RECOVERY:
         return "SUPPORT_RECOVERY";
       default:
         return "<unknown module>";
     }
   }
   
   enum CommonResponseCode : uint64_t
   {
     OK = 0x0000000000000000,
     WARNING = 0x0000000000000001,
     INTERNAL_ERROR = 0x0000000000000002,
     UNKNOWN_ERROR = 0x0000000000000003,
     SESSION_INVALID = 0x0000000000000004,
     SESSION_EXPIRED = 0x0000000000000005,
     NOT_AUTHORIZED = 0x0000000000000006,
     NOT_IN_REQUIRED_STATE = 0x0000000000000007,
     FEATURE_NOT_LICENSED = 0x0000000000000008,
     INVALID_MESSAGE_CONTENT = 0x0000000000000009,
     ENTITY_ALREADY_EXISTS = 0x000000000000000a,
     ENTITY_NOT_FOUND = 0x000000000000000b,
     FILE_ACCESS_FAILED = 0x000000000000000c,
     SENSOR_NOT_AVAILABLE = 0x000000000000000d,
     ENTITY_IN_USE = 0x000000000000000e,
   };
   
   inline std::string stringifyCommonResponseCode(CommonResponseCode c)
   {
     switch (c) {
       case OK:
         return "OK";
       case WARNING:
         return "WARNING";
       case INTERNAL_ERROR:
         return "INTERNAL_ERROR";
       case UNKNOWN_ERROR:
         return "UNKNOWN_ERROR";
       case SESSION_INVALID:
         return "SESSION_INVALID";
       case SESSION_EXPIRED:
         return "SESSION_EXPIRED";
       case NOT_AUTHORIZED:
         return "NOT_AUTHORIZED";
       case NOT_IN_REQUIRED_STATE:
         return "NOT_IN_REQUIRED_STATE";
       case FEATURE_NOT_LICENSED:
         return "FEATURE_NOT_LICENSED";
       case INVALID_MESSAGE_CONTENT:
         return "INVALID_MESSAGE_CONTENT";
       case ENTITY_ALREADY_EXISTS:
         return "ENTITY_ALREADY_EXISTS";
       case ENTITY_NOT_FOUND:
         return "ENTITY_NOT_FOUND";
       case FILE_ACCESS_FAILED:
         return "FILE_ACCESS_FAILED";
       case SENSOR_NOT_AVAILABLE:
         return "SENSOR_NOT_AVAILABLE";
       case ENTITY_IN_USE:
         return "ENTITY_IN_USE";
       default:
         return "";
     }
   }
   
   #endif  // BOSCH_LOCATOR_BRIDGE__ENUMS_HPP_