Updated to use C++20

Author: KojoBailey

CMakeLists.txt

@@ -8,4 +8,4 @@ add_library(binary-cpp-library INTERFACE)
 # Include header files
 target_include_directories(binary-cpp-library INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
 
-target_compile_features(binary-cpp-library INTERFACE cxx_std_11)
+set_target_properties(binary-cpp-library PROPERTIES CXX_STANDARD 23)

README.md

@@ -1,8 +1,8 @@
 # [binary++](https://github.com/KojoBailey/binary-cpp-library)
-This library for **C++11 and newer** assists reading from and writing to **binary data**, making use of my own experience as a reverse engineer.
+This library for **C++20 and newer** assists reading from and writing to **binary data**, making use of my own experience as a reverse engineer.
 
 It aims to:
-- Support as far back as **C++11** for those still using older standards.
+- Make use of modern C++ features where **useful** (i.e. `std::endian` and co.).
 - Be as **open-purposed** as possible for a wide range of use cases.
 - Mirror the **standard library's style** for interface.
 - Receive updates as necessary.
@@ -26,19 +26,21 @@ It aims to:
     - [`dump_file()`](#dump_file)
 
 ## Dependencies
-I'm not one to do strenuous testing on various different platforms and compilers, but this should work as far back as **C++11**. Earlier support will likely never be implemented by myself.
-
-Here is the full list of includes used by this library, and the C++ standards they require.
+Here is the full list of includes used by this library:
 ```cpp
-#include <cstring>
+#include <bit>
+#include <cstring>    
 #include <fstream>
-#include <cstdint>      // C++11
-#include <type_traits>  // C++11
-#include <vector>       // C++11
+#include <cstdint>
+#include <string_view>
+#include <type_traits>
+#include <vector>
 ```
 
+Otherwise, no external dependencies are used.
+
 ## Usage
-With a single header file at only ~9KB, it's very easy to start using this library. Support for build systems like **CMake** may be added in the future.
+With a single header file at only ~10KB, it's very easy to start using this library. Support for build systems like **CMake** may be added in the future.
 
 ```cpp
 #include <kojo/binary.hpp> // or something along those lines.
@@ -160,27 +162,27 @@ size_t size();
 ```
 ```cpp
 kojo::binary foo;
-foo.write<std::uint64_t>(23, kojo::endian::big);
-foo.write<std::uint32_t>(420, kojo::endian::big);
+foo.write<std::uint64_t>(23, std::endian::big);
+foo.write<std::uint32_t>(420, std::endian::big);
 std::cout << foo.size(); // 12
 ```
 
 ### `set_endian()`
 Sets the endianness of an **integer** to big or little. Mostly exists for internal use.
 ```cpp
-template <typename T> T set_endian(T value, kojo::endian endianness);
+template <typename T> T set_endian(T value, std::endian endianness);
     static_assert(std::is_integral<T>::value, "T must be an integral type.");
 ```
 ```cpp
 kojo::binary foo;
-std::uint32_t number = foo.set_endian(1, kojo::endian::big); // 00 00 00 01
-number = foo.set_endian(number, kojo::endian::little);       // 01 00 00 00
+std::uint32_t number = foo.set_endian(1, std::endian::big); // 00 00 00 01
+number = foo.set_endian(number, std::endian::little);       // 01 00 00 00
 ```
 
 ### `read()`
 Reads from data into a specified type, that being an integer, `char`, or `std::string`.
 ```cpp
-template <typename T> T read(kojo::endian endianness, size_t offset = 0);
+template <typename T> T read(std::endian endianness, size_t offset = 0);
     static_assert(std::is_integral<T>::value, "T must be an integral type.");
 template <typename T> typename std::enable_if<std::is_same<T, char>::value, char>::type read(size_t offset = 0);
 template <typename T> typename std::enable_if<std::is_same<T, std::string>::value, std::string>::type read(size_t size = 0, size_t offset = 0);
@@ -189,7 +191,7 @@ template <typename T> typename std::enable_if<std::is_same<T, std::string>::valu
 std::vector<char> vec{17, 1,  0, 0, 'h', 'P', 'N', 'G', 'J', 'o', 'h', 'n', '\0', 'B'};
 kojo::binary foo{vec.data(), 0, vec.size()};
 
-std::cout << foo.read<std::uint32_t>(kojo::endian::little); // 273
+std::cout << foo.read<std::uint32_t>(std::endian::little); // 273
 std::cout << foo.read<char>(); // 'h'
 std::cout << foo.read<std::string>(3); // "PNG"
 std::cout << foo.read<std::string>(); // "John"
@@ -206,8 +208,8 @@ template <typename T> void write(typename std::enable_if<std::is_same<T, std::ve
 ```
 ```cpp
 kojo::binary foo;
-foo.write<std::int64_t>(-281029, kojo::endian::big);
-foo.write<std::uint16_t>(934, kojo::endian::little);
+foo.write<std::int64_t>(-281029, std::endian::big);
+foo.write<std::uint16_t>(934, std::endian::little);
 foo.write<char>('E');
 foo.write<std::string>("Die Speisekarte, bitte."); // Null-terminated.
 foo.write<std::string>("NUCC", 4); // Not null-terminated.
@@ -223,7 +225,7 @@ size_t get_pos();
 ```cpp
 kojo::binary foo;
 std::cout << foo.get_pos(); // 0
-foo.write<std::uint32_t>(5, kojo::endian::big);
+foo.write<std::uint32_t>(5, std::endian::big);
 std::cout << foo.get_pos(); // 4
 foo.write<std::string>("YouGotCAGEd");
 std::cout << foo.get_pos(); // 16

include/kojo/binary.hpp

@@ -1,11 +1,13 @@
 #ifndef KOJO_BINARY_LIB
 #define KOJO_BINARY_LIB
 
+#include <bit>
 #include <cstring>      // std::memcpy
 #include <fstream>
-#include <cstdint>      // C++11
-#include <type_traits>  // C++11
-#include <vector>       // C++11
+#include <cstdint>
+#include <string_view>
+#include <type_traits>
+#include <vector>
 
 // #include <iostream>
 // #include <format>
@@ -25,14 +27,9 @@
 /** @note Not `KojoBailey` like on GitHub since that's a bit tedious. */
 namespace kojo {
 
-enum class endian {
-    big = 4321,
-    little = 1234
-};
-
-inline endian system_endian() {
+inline std::endian system_endian() {
     std::uint32_t num = 0x01020304;
-    return (reinterpret_cast<char*>(&num)[0] == 1) ? endian::big : endian::little;
+    return (reinterpret_cast<char*>(&num)[0] == 1) ? std::endian::big : std::endian::little;
 }
 
 inline void charswap(unsigned char& a, unsigned char& b) {
@@ -51,42 +48,6 @@ template<typename T> T byteswap(T t) {
     return t;
 }
 
-template< class classT = void >
-class ptr {
-private:
-    const classT* address;
-
-public:
-    ptr() = default;
-    template<typename T> ptr(T* init) : address( (decltype(address))init ) {}
-
-    /* Get address as certain type. */
-    decltype(address) addr() { return address; } // char* is default type.
-    template<typename T = classT> T* addr() { return (T*)address; }
-
-    /* Get dereferenced value as certain type. */
-    template<typename T = classT> T val() { return *(T*)address; }
-
-    /* Get dereferenced value line an array. */
-    template<typename T = classT> T array(int offset) { return *((T*)address + offset); }
-
-    template<typename T> friend ptr operator+(ptr left, T right) {
-        static_assert(std::is_integral<T>::value, "T must be an integral type.");
-        return ptr((char*)left.addr() + right);
-    }
-    template<typename T> friend ptr operator+(T left, ptr right) {
-        static_assert(std::is_integral<T>::value, "T must be an integral type.");
-        return ptr((char*)right.addr() + left);
-    }
-    template<typename T> friend ptr operator-(ptr left, T right) {
-        static_assert(std::is_integral<T>::value, "T must be an integral type.");
-        return ptr((char*)left.addr() - left);
-    }
-    std::ptrdiff_t friend operator-(ptr left, ptr right) {
-        return left.addr() - right.addr();
-    }
-};
-
 class binary {
 public:
     /** Initialise binary data from filepath. */
@@ -128,6 +89,7 @@ class binary {
                 internal_storage.push_back(buffer);
             }
         } else {
+            internal_storage.reserve(size);
             for (int i = 0; i < size; i++) {
                 internal_storage.push_back(file_input.get());
             }
@@ -141,6 +103,7 @@ class binary {
         if (size == -1) {
             internal_address = (decltype(internal_address))pointer + start;
         } else {
+            internal_storage.reserve(size);
             for (int i = start; i < size + start; i++) {
                 internal_storage.push_back(((decltype(internal_address))pointer)[i]);
             }
@@ -168,15 +131,15 @@ class binary {
     }
 
     /** Changes the endianness of an integer depending on your system. */
-    template <typename T> T set_endian(T value, endian endianness) {
+    template <typename T> T set_endian(T value, std::endian endianness) {
         static_assert(std::is_integral<T>::value, "T must be an integral type.");
         return (system_endian() != endianness)
             ? byteswap(value)
             : value;
     }
 
     /** Reads integer of select size from current position in file. */
-    template <typename T> T read(endian endianness, size_t offset = 0) {
+    template <typename T> T read(std::endian endianness, size_t offset = 0) {
         static_assert(std::is_integral<T>::value, "T must be an integral type.");
         T buffer;
         std::memcpy(&buffer, &internal_address[cursor + offset], sizeof(buffer));
@@ -205,27 +168,22 @@ class binary {
         return buffer;
     }
 
-    template <typename T> void write(T value, endian endianness) {
-        static_assert(std::is_integral<T>::value, "T must be an integral type.");
+    template <std::integral T> void write(T value, std::endian endianness) {
         value = set_endian(value, endianness);
         cursor = internal_storage.size();
         internal_storage.resize(cursor + sizeof(T));
         std::memcpy(&internal_storage[cursor], &value, sizeof(T));
         cursor += sizeof(T);
         update_pointer();
     }
-    template <typename T> void write(typename std::enable_if<std::is_same<T, char>::value, char>::type value) {
-        static_assert(std::is_same<T, char>::value, "T must be of the char type.");
+    template <std::same_as<char> T> void write(const char& value) {
         cursor = internal_storage.size();
         internal_storage.resize(cursor + 1);
         std::memcpy(&internal_storage[cursor], &value, 1);
         cursor++;
         update_pointer();
     }
-    template <typename T> void write(
-            typename std::enable_if<std::is_same<T, std::string>::value, std::string>::type value, 
-            size_t length = 0 ) {
-        static_assert(std::is_same<T, std::string>::value, "T must be of the std::string type.");
+    template <std::same_as<std::string>> void write(std::string_view value, size_t length = 0 ) {
         if (value.size() == 0) return;
         size_t padding{1};
         if (length == 0) {
@@ -248,16 +206,14 @@ class binary {
 
         update_pointer();
     }
-    template <typename T> void write(typename std::enable_if<std::is_same<T, std::vector<unsigned char>>::value, std::vector<unsigned char>>::type& value) {
-        static_assert(std::is_same<T, std::vector<unsigned char>>::value, "T must be of the std::vector<unsigned char> type.");
+    template <std::same_as<std::vector<unsigned char>>> void write(const std::vector<unsigned char>& value) {
         cursor = internal_storage.size();
         internal_storage.resize(cursor + value.size());
         std::memcpy(&internal_storage[cursor], value.data(), value.size());
         cursor += value.size();
         update_pointer();
     }
-    template <typename T> void write(typename std::enable_if<std::is_same<T, binary>::value, binary>::type& value) {
-        static_assert(std::is_same<T, binary>::value, "T must be of the kojo::binary type.");
+    template <std::same_as<binary>> void write(binary& value) {
         cursor = internal_storage.size();
         if (value.size() == -1 || value.data() == nullptr) return;
         internal_storage.resize(cursor + value.size());
@@ -305,22 +261,6 @@ class binary {
         if (internal_storage.data() != nullptr)
             internal_address = internal_storage.data();
     }
-
-    void charswap(unsigned char& a, unsigned char& b) {
-        a ^= b;
-        b ^= a;
-        a ^= b;
-    }
-
-    template<typename T> T byteswap(T t) {
-        static_assert(std::is_integral<T>::value, "T must be an integral type.");
-        unsigned char* first = (unsigned char*)&t;
-        unsigned char* last = first + sizeof(T) - 1;
-        while (first < last) {
-            charswap(*first++, *last--);
-        }
-        return t;
-    }
 };
 
 } // namespace