Line data    Source code

       1             : // Copyright 2024 Accenture.
       2             : 
       3             : #include "estd/slice.h"
       4             : 
       5             : #include "estd/array.h"
       6             : #include "estd/assert.h"
       7             : #include "estd/vector.h"
       8             : 
       9             : #include <gtest/gtest.h>
      10             : 
      11             : // clang-format off
      12             : namespace
      13             : {
      14           1 : void example_construction()
      15             : {
      16           1 :     {
      17             :     // [EXAMPLE_BEGIN estd static construction from C array]
      18           1 :     uint8_t data[] = {0, 1, 2, 3, 4};
      19             : 
      20             :     // statically-sized slice of size 5
      21           1 :     ::estd::slice<uint8_t, 5U> slice5(data);
      22             : 
      23             :     // statically-sized slice of size 3 which points to the first three elements
      24           1 :     ::estd::slice<uint8_t, 3U> slice3(data);
      25             :     // [EXAMPLE_END estd static construction from C array]
      26             :     }
      27             : 
      28           1 :     {
      29             :     // [EXAMPLE_BEGIN estd dynamic construction from C array]
      30           1 :     uint8_t data[] = {0, 1, 2, 3, 4};
      31             : 
      32             :     // dynamically-sized slice of size 5
      33           1 :     ::estd::slice<uint8_t> dynSizeSlice(data);
      34             : 
      35             :     // dynamically-sized slice can be constructed from a statically sized slice:
      36           1 :     ::estd::slice<uint8_t, 5U> slice5(data);
      37             : 
      38             :     // [EXAMPLE_END estd dynamic construction from C array]
      39             :     }
      40             : 
      41           1 :     {
      42             :     // [EXAMPLE_BEGIN estd construction from an estd array]
      43           1 :     ::estd::array<int32_t, 4U> data = {0, 1, 2, 3};
      44           1 :     ::estd::slice<int32_t, 4U> slice4(data);
      45             :     // EXAMPLE_END estd construction from an estd array
      46             :     }
      47             : 
      48           1 :     {
      49             :     // [EXAMPLE_BEGIN estd construction from pointer]
      50           1 :     uint8_t data[]                       = {0, 1, 2, 3, 4};
      51           1 :     uint8_t* pointer                     = data;
      52           1 :     ::estd::slice<uint8_t, 5U> slice5_fp = ::estd::slice<uint8_t, 5U>::from_pointer(pointer);
      53             :     // [EXAMPLE_END estd construction from pointer]
      54             :     }
      55             : 
      56           1 :     {
      57             :     // [EXAMPLE_BEGIN estd dynamic construction from estd vector]
      58           1 :     ::estd::declare::vector<int32_t, 10> v1;
      59           1 :     ::estd::slice<int32_t> s1(v1);
      60             : 
      61           1 :     ::estd::declare::vector<int32_t, 20> v2;
      62           1 :     ::estd::vector<int32_t>& v3 = v2;
      63           1 :     ::estd::slice<int32_t> s3(v3);
      64             :     // [EXAMPLE_END estd dynamic construction from estd vector]
      65           1 :     }
      66             : 
      67             : #if 0 // this won't compile, therefore disabled
      68             :     // [EXAMPLE_BEGIN estd array too small]
      69             :     ::estd::slice<uint8_t, 6U> slice6(data); // won't compile - array is smaller than the size of slice
      70             :     // [EXAMPLE_END estd array too small]
      71             : #endif
      72           1 : }
      73             : 
      74           1 : void example_make_slice()
      75             : {
      76             :     // [EXAMPLE_BEGIN estd make_slice]
      77             : 
      78           1 :     uint32_t data[] = {0, 1, 2, 3, 4};
      79           1 :     auto staticSlice = ::estd::make_static_slice(data); // staticSlice has type slice<uint32_t, 5>
      80             : 
      81             :     // [EXAMPLE_END estd make_slice]
      82             : }
      83             : 
      84           1 : void example_iterate()
      85             : {
      86             :     // [EXAMPLE_BEGIN estd iterate]
      87           1 :     uint32_t data[] = {0, 1, 2, 3, 4};
      88           1 :     ::estd::slice<uint32_t> slice5{data};
      89             : 
      90             :     // iterate over all elements, incrementing each of them:
      91           1 :     for (auto& i : slice5)
      92             :     {
      93             :         ++i;
      94             :     }
      95             : 
      96             :     // iterate over elements in reverse order
      97           1 :     for (auto rev_it = slice5.rbegin(); rev_it != slice5.rend(); ++rev_it)
      98             :     {
      99             :         *rev_it = *rev_it + 10;
     100             :     }
     101             : 
     102             :     // [EXAMPLE_END estd iterate]
     103             : }
     104             : 
     105           1 : void example_access_at()
     106             : {
     107             :     // [EXAMPLE_BEGIN estd access_at]
     108           1 :     uint8_t data[] = {0, 1, 2, 3, 4};
     109           1 :     ::estd::slice<uint8_t, 5> const slice5(data);
     110             : 
     111           1 :     slice5.at<0>() = 42; // assign 42 to the first element
     112             : 
     113             :     // [EXAMPLE_END estd access_at]
     114             : }
     115             : 
     116           1 : void example_subviews()
     117             : {
     118             :     // [EXAMPLE_BEGIN estd subviews]
     119           1 :     uint8_t data[] = {0, 1, 2, 3, 4};
     120           1 :     ::estd::slice<uint8_t> const slice(data);
     121             : 
     122             :     // [EXAMPLE_END estd subviews]
     123             : }
     124             : 
     125           1 : void example_subviews_static()
     126             : {
     127             :     // [EXAMPLE_BEGIN estd subviews_static]
     128           1 :     uint8_t data[] = {0, 1, 2, 3, 4};
     129           1 :     ::estd::slice<uint8_t, 5U> const slice5(data);
     130           1 :     ::estd::slice<uint8_t, 4U> slice4 = slice5.offset<1>();   // skip 1 element: {1, 2, 3, 4}
     131           1 :     ::estd::slice<uint8_t, 3U> slice3 = slice5.subslice<3>(); // first 3 elements: {0, 1, 2}
     132             :     // [EXAMPLE_END estd subviews_static]
     133             : }
     134             : 
     135           1 : void example_modify()
     136             : {
     137             :     // [EXAMPLE_BEGIN estd modify]
     138           1 :     uint8_t data[] = {0, 1, 2, 3, 4};
     139           1 :     ::estd::slice<uint8_t> slice(data);
     140             : 
     141           1 :     slice.advance(1U); // slice's pointer incremented by one, now points to {1, 2, 3, 4}
     142           1 :     slice.trim(2U);    // slice's size decreased to 2, now points to {1, 2}
     143             :     // [EXAMPLE_END estd modify]
     144             : }
     145             : 
     146             : } // namespace
     147             : 
     148           3 : TEST(Slice, run_examples)
     149             : {
     150           1 :     example_construction();
     151           1 :     example_make_slice();
     152           1 :     example_iterate();
     153           1 :     example_subviews();
     154           1 :     example_subviews_static();
     155           1 :     example_modify();
     156           1 :     example_access_at();
     157           1 : }
     158             : 
     159             : // clang-format off