implemented front() and back()

src/json.hpp

@@ -587,7 +587,7 @@ class basic_json
         alloc.construct(m_value.array, count, other);
     }
 
-    // construct a JSON container given an iterator range
+    /// construct a JSON container given an iterator range
     template <class T, typename
               std::enable_if<
                   std::is_same<T, basic_json::iterator>::value or
@@ -603,8 +603,10 @@ class basic_json
             throw std::runtime_error("iterators are not compatible");
         }
 
+        // set the type
         m_type = first.m_object->m_type;
 
+        // check if iterator range is complete for non-compound values
         switch (m_type)
         {
             case value_t::number_integer:
@@ -1261,6 +1263,34 @@ class basic_json
         return m_value.object->operator[](key);
     }
 
+    /// access the first element
+    inline reference front()
+    {
+        return *begin();
+    }
+
+    /// access the first element
+    inline const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /// access the last element
+    inline reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /// access the last element
+    inline const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
     /// remove element given an iterator
     template <class T, typename
               std::enable_if<

src/json.hpp.re2c

@@ -1263,6 +1263,34 @@ class basic_json
         return m_value.object->operator[](key);
     }
 
+    /// access the first element
+    inline reference front()
+    {
+        return *begin();
+    }
+
+    /// access the first element
+    inline const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /// access the last element
+    inline reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /// access the last element
+    inline const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
     /// remove element given an iterator
     template <class T, typename
               std::enable_if<

test/unit.cpp

@@ -2471,6 +2471,14 @@ TEST_CASE("element access")
             }
         }
 
+        SECTION("front and back")
+        {
+            CHECK(j.front() == json(1));
+            CHECK(j_const.front() == json(1));
+            CHECK(j.back() == json({1, 2, 3}));
+            CHECK(j_const.back() == json({1, 2, 3}));
+        }
+
         SECTION("access specified element")
         {
             SECTION("access within bounds")
@@ -2829,6 +2837,16 @@ TEST_CASE("element access")
             }
         }
 
+        SECTION("front and back")
+        {
+            // "array" is the smallest key
+            CHECK(j.front() == json({1, 2, 3}));
+            CHECK(j_const.front() == json({1, 2, 3}));
+            // "string" is the largest key
+            CHECK(j.back() == json("hello world"));
+            CHECK(j_const.back() == json("hello world"));
+        }
+
         SECTION("access specified element")
         {
             SECTION("access within bounds")
@@ -3282,6 +3300,79 @@ TEST_CASE("element access")
 
     SECTION("other values")
     {
+        SECTION("front and back")
+        {
+            SECTION("null")
+            {
+                {
+                    json j;
+                    CHECK_THROWS_AS(j.front(), std::out_of_range);
+                    CHECK_THROWS_AS(j.back(), std::out_of_range);
+                }
+                {
+                    const json j{};
+                    CHECK_THROWS_AS(j.front(), std::out_of_range);
+                    CHECK_THROWS_AS(j.back(), std::out_of_range);
+                }
+            }
+
+            SECTION("string")
+            {
+                {
+                    json j = "foo";
+                    CHECK(j.front() == j);
+                    CHECK(j.back() == j);
+                }
+                {
+                    const json j = "bar";
+                    CHECK(j.front() == j);
+                    CHECK(j.back() == j);
+                }
+            }
+
+            SECTION("number (boolean)")
+            {
+                {
+                    json j = false;
+                    CHECK(j.front() == j);
+                    CHECK(j.back() == j);
+                }
+                {
+                    const json j = true;
+                    CHECK(j.front() == j);
+                    CHECK(j.back() == j);
+                }
+            }
+
+            SECTION("number (integer)")
+            {
+                {
+                    json j = 17;
+                    CHECK(j.front() == j);
+                    CHECK(j.back() == j);
+                }
+                {
+                    const json j = 17;
+                    CHECK(j.front() == j);
+                    CHECK(j.back() == j);
+                }
+            }
+
+            SECTION("number (floating point)")
+            {
+                {
+                    json j = 23.42;
+                    CHECK(j.front() == j);
+                    CHECK(j.back() == j);
+                }
+                {
+                    const json j = 23.42;
+                    CHECK(j.front() == j);
+                    CHECK(j.back() == j);
+                }
+            }
+        }
+
         SECTION("erase with one valid iterator")
         {
             SECTION("null")