Custom class xarray with shorter "of" initialization

Author: vpiotr

include/xarray.h

@@ -1,24 +1,169 @@
 //----------------------------------------------------------------------------------
 // Name:        xarray.h
-// Purpose:     Definition of vector of xnodes.
+// Purpose:     Custom array class for xnode objects.
 // Author:      Piotr Likus
 // Created:     01/09/2015
-// Last change: 
+// Last change: 15/05/2025
 // License:     BSD
 //----------------------------------------------------------------------------------
 
 #ifndef __XNODE_ARRAY_H__
 #define __XNODE_ARRAY_H__
 
 #include <vector>
+#include <initializer_list>
+#include <cassert>
 #include "xnode.h"
 
-typedef std::vector<xnode> xarray;
+// Forward declaration
+class xarray;
 
+// Type code registration for xarray
 template<>
 struct xnode_type_code<xarray> {
     enum { value = 16 }; // Ensure this doesn't conflict with other type codes
 };
 
-#endif
+/**
+ * Custom array class for xnode objects.
+ * Provides a limited array interface with static initializer "of" that accepts variable number of xnode objects.
+ */
+class xarray {
+public:
+    // Type definitions
+    using value_type = xnode;
+    using container_type = std::vector<value_type>;
+    using reference = container_type::reference;
+    using const_reference = container_type::const_reference;
+    using iterator = container_type::iterator;
+    using const_iterator = container_type::const_iterator;
+    using size_type = container_type::size_type;
+    using difference_type = container_type::difference_type;
+
+    // Constructors
+    xarray() = default;
+    
+    // Copy constructor
+    xarray(const xarray& other) = default;
+    
+    // Move constructor
+    xarray(xarray&& other) noexcept = default;
+    
+    // Construct from initializer list of xnodes
+    xarray(std::initializer_list<value_type> init) : data_(init) {}
+    
+    // Assignment operators
+    xarray& operator=(const xarray& other) = default;
+    xarray& operator=(xarray&& other) noexcept = default;
+    
+    // Basic functions
+    bool empty() const { return data_.empty(); }
+    size_type size() const { return data_.size(); }
+    
+    // Element access
+    reference at(size_type pos) { return data_.at(pos); }
+    const_reference at(size_type pos) const { return data_.at(pos); }
+    
+    reference operator[](size_type pos) { return data_[pos]; }
+    const_reference operator[](size_type pos) const { return data_[pos]; }
+    
+    // Iterators
+    iterator begin() { return data_.begin(); }
+    const_iterator begin() const { return data_.begin(); }
+    const_iterator cbegin() const { return data_.cbegin(); }
+    
+    iterator end() { return data_.end(); }
+    const_iterator end() const { return data_.end(); }
+    const_iterator cend() const { return data_.cend(); }
+    
+    // Capacity manipulation
+    void reserve(size_type new_cap) { data_.reserve(new_cap); }
+    size_type capacity() const { return data_.capacity(); }
+    
+    // Modifiers
+    void clear() { data_.clear(); }
+    void push_back(const value_type& value) { data_.push_back(value); }
+    void push_back(value_type&& value) { data_.push_back(std::move(value)); }
+    iterator insert(const_iterator pos, const value_type& value) { return data_.insert(pos, value); }
+    iterator insert(const_iterator pos, value_type&& value) { return data_.insert(pos, std::move(value)); }
+    iterator erase(const_iterator pos) { return data_.erase(pos); }
+    void resize(size_type count, const value_type& value = value_type()) { data_.resize(count, value); }
+      // C++17 and above: Static factory function that accepts variable number of arguments
+    // and converts them directly to xnode objects    
+    
+    #if __cplusplus >= 201703L
+    // C++17 version that auto-converts values to xnode objects
+    template <typename... Args>
+    static xarray of(Args&&... args) {
+        xarray result;
+        result.reserve(sizeof...(args));
+        (result.push_back(xnode::value_of(std::forward<Args>(args))), ...); // Fold expression (C++17)
+        return result;
+    }
+    
+    // C++17 version for direct xnode objects (to avoid unnecessary conversion)
+    template <typename... Args>
+    static xarray of_nodes(const xnode& first, Args&&... args) {
+        xarray result;
+        result.reserve(sizeof...(args) + 1);
+        result.push_back(first);
+        (result.push_back(std::forward<Args>(args)), ...); // Fold expression (C++17)
+        return result;
+    }
+    
+    // Specialization for empty array
+    static xarray of_nodes() {
+        return xarray();
+    }
+    #else
+    // Pre-C++17: Recursive variadic template implementations
+    
+    // Version that requires explicit xnode arguments
+    static xarray of() {
+        return xarray();
+    }
+
+    template <typename... Args>
+    static xarray of(const xnode& first, const Args&... rest) {
+        xarray result;
+        result.reserve(sizeof...(rest) + 1);
+        result.push_back(first);
+        appendToArray(result, rest...);
+        return result;
+    }
+
+    // Alias for consistency with the C++17 version
+    static xarray of_nodes() {
+        return xarray();
+    }
+
+    template <typename... Args>
+    static xarray of_nodes(const xnode& first, const Args&... rest) {
+        return of(first, rest...);
+    }
+
+    // Helper function for pre-C++17 implementation
+    private:
+    static void appendToArray(xarray& /* array */) {
+        // Base case: no more elements to add
+    }
+
+    template <typename... Args>
+    static void appendToArray(xarray& array, const xnode& first, const Args&... rest) {
+        array.push_back(first);
+        appendToArray(array, rest...);
+    }
+    public:
+    #endif
+
+    // Compatibility with algorithms that expect STL containers
+    bool operator==(const xarray& other) const { return data_ == other.data_; }
+    bool operator!=(const xarray& other) const { return data_ != other.data_; }
+    bool operator<(const xarray& other) const { return data_ < other.data_; }
+
+private:
+    container_type data_;
+};
+
+#endif // __XNODE_ARRAY_H__
 

include/xnode_utils.h

@@ -82,14 +82,11 @@ namespace XN_CHECK_EQUALS
 
 namespace XN_CHECK_LESS
 {
-	typedef char no[7];
-	template<typename T> no& operator < (const T&, const T&);
+	template <typename T, typename = void>
+	struct opLessExists : std::false_type {};
 
 	template <typename T>
-	struct opLessExists
-	{
-		enum { value = (sizeof(*(T*)(0) < *(T*)(0)) != sizeof(no)) };
-	};
+	struct opLessExists<T, decltype(void(std::declval<T>() < std::declval<T>()))> : std::true_type {};
 }
 
 template<typename T>

test/CMakeLists.txt

@@ -32,6 +32,20 @@ target_link_libraries(xarray_test PRIVATE xnode)
 # Add xarray test to CTest
 add_test(NAME xarray_test COMMAND xarray_test)
 
+# Add xarray of test
+add_executable(xarray_of_test xarray_of_test.cpp)
+target_link_libraries(xarray_of_test PRIVATE xnode)
+
+# Add xarray of test to CTest
+add_test(NAME xarray_of_test COMMAND xarray_of_test)
+
+# Add xarray of versions test
+add_executable(xarray_of_versions_test xarray_of_versions_test.cpp)
+target_link_libraries(xarray_of_versions_test PRIVATE xnode)
+
+# Add xarray of versions test to CTest
+add_test(NAME xarray_of_versions_test COMMAND xarray_of_versions_test)
+
 # Add xobject tests
 add_executable(xobject_test xobject_test.cpp)
 target_link_libraries(xobject_test PRIVATE xnode)
@@ -47,7 +61,7 @@ target_link_libraries(property_list_test PRIVATE xnode)
 add_test(NAME property_list_test COMMAND property_list_test)
 
 # Install the test executable if needed (optional)
-install(TARGETS xnode_test xnode_convert_test xnode_type_test xnode_overflow_test xarray_test xobject_test property_list_test
+install(TARGETS xnode_test xnode_convert_test xnode_type_test xnode_overflow_test xarray_test xarray_of_test xarray_of_versions_test xobject_test property_list_test
     RUNTIME DESTINATION bin
     OPTIONAL
 )

test/xarray_of_test.cpp

@@ -0,0 +1,139 @@
+//----------------------------------------------------------------------------------
+// Name:        xarray_of_test.cpp
+// Purpose:     Unit tests for xarray of() static initializer
+// Author:      Piotr Likus
+// Created:     May 15, 2025
+// License:     BSD
+//----------------------------------------------------------------------------------
+
+#include "xnode.h"
+#include "xarray.h"
+#include <iostream>
+#include <string>
+#include "cunit.h"
+#include "xobject.h"
+
+using namespace std;
+
+void TestArrayOf() {
+    // Test the static "of" initializer with different numbers of arguments
+    
+    // Empty array
+    xarray empty = xarray::of_nodes();
+    Assert(empty.empty(), "Empty array should be empty");
+    Assert(empty.size() == 0, "Empty array size should be 0");
+    
+    // Single element (using appropriate version based on C++ standard)
+#if __cplusplus >= 201703L
+    // C++17: Use direct value
+    xarray single = xarray::of(42);
+#else
+    // Pre-C++17: Use xnode objects
+    xarray single = xarray::of(xnode::value_of(42));
+#endif
+    Assert(single.size() == 1, "Single element array size should be 1");
+    Assert(single[0].get_as<int>() == 42, "Single element should be 42");
+    
+    // Multiple elements of the same type (using of_nodes which works on all standards)
+    xarray multi = xarray::of_nodes(
+        xnode::value_of(10),
+        xnode::value_of(20),
+        xnode::value_of(30)
+    );
+    Assert(multi.size() == 3, "Multi-element array size should be 3");
+    Assert(multi[0].get_as<int>() == 10, "First element should be 10");
+    Assert(multi[1].get_as<int>() == 20, "Second element should be 20");
+    Assert(multi[2].get_as<int>() == 30, "Third element should be 30");
+    
+    // Different types
+#if __cplusplus >= 201703L
+    // C++17: Use direct values
+    xarray mixed = xarray::of(10, "test", true, 3.14);
+#else
+    // Pre-C++17: Use xnode objects
+    xarray mixed = xarray::of(
+        xnode::value_of(10),
+        xnode::value_of("test"),
+        xnode::value_of(true),
+        xnode::value_of(3.14)
+    );
+#endif
+    Assert(mixed.size() == 4, "Mixed type array size should be 4");
+    Assert(mixed[0].is<int>(), "First element should be int");
+    Assert(mixed[1].is<std::string>(), "Second element should be string");
+    Assert(mixed[2].is<bool>(), "Third element should be bool");
+    Assert(mixed[3].is<double>(), "Fourth element should be double");
+}
+
+void TestArrayOfWithNestedStructures() {
+    // Create an object
+    xobject person;
+    person.put("name", xnode::value_of("John Doe"));
+    person.put("age", xnode::value_of(30));
+    
+    // Create a nested array
+    xarray hobbies = xarray::of(
+        xnode::value_of("reading"),
+        xnode::value_of("coding"),
+        xnode::value_of("hiking")
+    );
+    
+    // Create main array with nested structures
+    xarray data = xarray::of(
+        xnode::value_of(person),
+        xnode::value_of(hobbies),
+        xnode::value_of(42)
+    );
+    
+    // Verify the structure
+    Assert(data.size() == 3, "Main array size should be 3");
+    Assert(data[0].is<xobject>(), "First element should be xobject");
+    Assert(data[1].is<xarray>(), "Second element should be xarray");
+    Assert(data[2].is<int>(), "Third element should be int");
+    
+    // Verify nested object
+    Assert(data[0].get_ptr<xobject>()->contains("name"), "Person object should contain name");
+    Assert(data[0].get_ptr<xobject>()->get("name").get_as<std::string>() == "John Doe", 
+           "Person name should be John Doe");
+    
+    // Verify nested array
+    Assert(data[1].get_ptr<xarray>()->size() == 3, "Hobbies array should have 3 elements");
+    Assert(data[1].get_ptr<xarray>()->at(0).get_as<std::string>() == "reading", 
+           "First hobby should be reading");
+}
+
+void TestArrayOfIterations() {
+    // Test iteration over array created with "of"
+    xarray numbers = xarray::of(
+        xnode::value_of(10),
+        xnode::value_of(20),
+        xnode::value_of(30),
+        xnode::value_of(40)
+    );
+    
+    // Range-based for loop
+    int sum = 0;
+    for (const auto& item : numbers) {
+        sum += item.get_as<int>();
+    }
+    Assert(sum == 100, "Sum of elements should be 100");
+    
+    // STL algorithms with array created by "of"
+    int product = 1;
+    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
+        product *= it->get_as<int>();
+    }
+    Assert(product == 240000, "Product of elements should be 240000");
+}
+
+int xarray_of_test() {
+    TEST_PROLOG();
+    TEST_FUNC(ArrayOf);
+    TEST_FUNC(ArrayOfWithNestedStructures);
+    TEST_FUNC(ArrayOfIterations);
+    TEST_EPILOG();
+}
+
+int main() {
+    return xarray_of_test();
+}