From 139ef0e750330ab71286e83a26fffd24829680a0 Mon Sep 17 00:00:00 2001
From: Niels <niels.lohmann@gmail.com>
Date: Sun, 12 Apr 2015 14:14:00 +0200
Subject: [PATCH] implemented front() and back()

---
 src/json.hpp      | 32 ++++++++++++++++-
 src/json.hpp.re2c | 28 +++++++++++++++
 test/unit.cpp     | 91 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 150 insertions(+), 1 deletion(-)

diff --git a/src/json.hpp b/src/json.hpp
index af8e490d..593a9f20 100644
--- a/src/json.hpp
+++ b/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<
diff --git a/src/json.hpp.re2c b/src/json.hpp.re2c
index 2ad9924c..b7742e44 100644
--- a/src/json.hpp.re2c
+++ b/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<
diff --git a/test/unit.cpp b/test/unit.cpp
index fe6a31b0..c4e669a7 100644
--- a/test/unit.cpp
+++ b/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")