BRAYNS-544 Upgrade to C++20 (#1178)

CMakeLists.txt

@@ -15,7 +15,7 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 set(BUILD_SHARED_LIBS ON)
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 project(Brayns VERSION 3.1.2)

Dockerfile

@@ -5,7 +5,7 @@
 # See: https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
 
 # Image where Brayns is built
-FROM debian as builder
+FROM ubuntu:22.04 as builder
 LABEL maintainer="bbp-svc-viz@groupes.epfl.ch"
 ARG DIST_PATH=/app/dist
 
@@ -135,7 +135,7 @@ RUN cd ${BRAYNS_SRC}/build && make -j4 install \
    && rm -rf ${DIST_PATH}/include ${DIST_PATH}/cmake ${DIST_PATH}/share
 
 # Final image, containing only Brayns and libraries required to run it
-FROM debian
+FROM ubuntu:22.04
 ARG DIST_PATH=/app/dist
 
 RUN apt-get update \

brayns/engine/colormethods/PrimitiveColorMethod.cpp

@@ -56,7 +56,7 @@ class IndexListExtractor
 public:
     static std::vector<size_t> fromRange(const std::string &range, size_t maxIndex)
     {
-        auto indexList = brayns::Parser::extractRanges<size_t>(range);
+        auto indexList = brayns::Parser::parseRange<size_t>(range);
         if (indexList.back() >= maxIndex)
         {
             throw std::range_error("Range out of bounds: " + range);

brayns/io/loaders/mesh/parsers/PlyMeshParser.cpp

@@ -29,7 +29,6 @@
 
 #include <brayns/utils/Log.h>
 
-#include <brayns/utils/binary/ByteOrder.h>
 #include <brayns/utils/parsing/FileStream.h>
 #include <brayns/utils/parsing/Parser.h>
 #include <brayns/utils/parsing/ParsingException.h>
@@ -661,9 +660,9 @@ class ValueParser
         case Format::Ascii:
             return Parser::extractToken<T>(data);
         case Format::BinaryBigEndian:
-            return Parser::extractChunk<T>(data, ByteOrder::BigEndian);
+            return Parser::extractChunk<T>(data, std::endian::big);
         case Format::BinaryLittleEndian:
-            return Parser::extractChunk<T>(data, ByteOrder::LittleEndian);
+            return Parser::extractChunk<T>(data, std::endian::little);
         default:
             throw std::runtime_error("Invalid format");
         }

brayns/io/loaders/mesh/parsers/StlMeshParser.cpp

@@ -23,7 +23,6 @@
 
 #include <array>
 
-#include <brayns/utils/binary/ByteOrder.h>
 #include <brayns/utils/parsing/FileStream.h>
 #include <brayns/utils/parsing/Parser.h>
 #include <brayns/utils/parsing/ParsingException.h>
@@ -274,7 +273,7 @@ class BinaryHeaderParser
         {
             throw std::runtime_error("Expected 4 bytes triangle count");
         }
-        return Parser::extractChunk<uint32_t>(data, ByteOrder::LittleEndian);
+        return Parser::extractChunk<uint32_t>(data, std::endian::little);
     }
 };
 
@@ -296,8 +295,8 @@ class BinaryFacetParser
     static Facet parse(std::string_view &data)
     {
         Facet facet;
-        Parser::extractChunk(data, facet.normal, ByteOrder::LittleEndian);
-        Parser::extractChunk(data, facet.vertices, ByteOrder::LittleEndian);
+        Parser::extractChunk(data, facet.normal, std::endian::little);
+        Parser::extractChunk(data, facet.vertices, std::endian::little);
         StringExtractor::extract(data, 2);
         return facet;
     }

brayns/network/client/ClientSender.cpp

@@ -22,7 +22,6 @@
 #include "ClientSender.h"
 
 #include <brayns/utils/binary/ByteConverter.h>
-#include <brayns/utils/binary/ByteOrder.h>
 
 namespace
 {
@@ -42,15 +41,7 @@ class BinaryFormatter
     static std::string _formatHeader(size_t size)
     {
         auto jsonSize = static_cast<uint32_t>(size);
-        return _formatJsonSize(jsonSize);
-    }
-
-    static std::string _formatJsonSize(uint32_t size)
-    {
-        auto bytes = brayns::ByteConverter::getBytes(size);
-        auto stride = sizeof(size);
-        brayns::ByteOrderHelper::convertFromSystemByteOrder(bytes, brayns::ByteOrder::LittleEndian);
-        return {bytes, stride};
+        return brayns::ByteConverter::convertToBytes(jsonSize, std::endian::little);
     }
 };
 } // namespace

brayns/network/jsonrpc/JsonRpcParser.cpp

@@ -104,7 +104,7 @@ class JsonSizeParser
         {
             throw brayns::ParsingErrorException("Invalid binary packet, expected at least 4 bytes for the JSON size.");
         }
-        auto jsonSize = brayns::Parser::extractChunk<uint32_t>(data, brayns::ByteOrder::LittleEndian);
+        auto jsonSize = brayns::Parser::extractChunk<uint32_t>(data, std::endian::little);
         if (jsonSize > size - 4)
         {
             throw brayns::ParsingErrorException(fmt::format("Invalid binary packet, JSON size too bi: {}", jsonSize));

brayns/utils/binary/ByteConverter.h

@@ -21,43 +21,85 @@
 
 #pragma once
 
-#include <cstddef>
+#include <bit>
+#include <cstring>
+#include <stdexcept>
+#include <string>
+#include <string_view>
 
 namespace brayns
 {
 class ByteConverter
 {
 public:
-    static void copyBytes(const char *from, char *to, size_t stride);
-    static void swapBytes(char *bytes, size_t stride);
+    static_assert(
+        std::endian::native == std::endian::big || std::endian::native == std::endian::little,
+        "Unsupported native endian");
 
     template<typename T>
     static const char *getBytes(const T &value)
     {
-        auto address = static_cast<const void *>(&value);
-        return static_cast<const char *>(address);
+        return reinterpret_cast<const char *>(&value);
     }
 
     template<typename T>
     static char *getBytes(T &value)
     {
-        auto address = static_cast<void *>(&value);
-        return static_cast<char *>(address);
+        return reinterpret_cast<char *>(&value);
     }
 
     template<typename T>
-    static void copyBytes(const T &from, T &to)
+    static T swapBytes(T value)
     {
-        auto source = getBytes(from);
-        auto destination = getBytes(to);
-        return copyBytes(source, destination, sizeof(T));
+        auto bytes = getBytes(value);
+        auto stride = sizeof(T);
+        for (size_t i = 0; i < stride / 2; ++i)
+        {
+            std::swap(bytes[i], bytes[stride - 1 - i]);
+        }
+        return value;
+    }
+
+    template<typename T>
+    static T convertFromLocalEndian(T value, std::endian endian)
+    {
+        if (std::endian::native == endian)
+        {
+            return value;
+        }
+        return swapBytes(value);
+    }
+
+    template<typename T>
+    static T convertToLocalEndian(T value, std::endian endian)
+    {
+        if (std::endian::native == endian)
+        {
+            return value;
+        }
+        return swapBytes(value);
+    }
+
+    template<typename T>
+    static T convertFromBytes(std::string_view data, std::endian endian)
+    {
+        auto stride = sizeof(T);
+        if (data.size() != stride)
+        {
+            throw std::invalid_argument("Invalid byte count");
+        }
+        auto value = T();
+        std::memcpy(&value, data.data(), stride);
+        return convertToLocalEndian(value, endian);
     }
 
     template<typename T>
-    static void swapBytes(T &value)
+    static std::string convertToBytes(T value, std::endian endian)
     {
+        value = convertFromLocalEndian(value, endian);
+        auto stride = sizeof(T);
         auto bytes = getBytes(value);
-        swapBytes(bytes, sizeof(T));
+        return {bytes, stride};
     }
 };
 } // namespace brayns