Merge pull request #764 from ckormanyos/more_11_07a

More 11_07a

Author: ckormanyos

examples/chapter11_07a/chapter11_07a.vcxproj.filters

@@ -533,12 +533,6 @@
     <ClInclude Include="src\mcal\host\mcal_dev.h">
       <Filter>src\mcal\host</Filter>
     </ClInclude>
-    <ClInclude Include="src\mcal_memory\mcal_memory_nonconst_address_ptr.h">
-      <Filter>src\mcal_memory</Filter>
-    </ClInclude>
-    <ClInclude Include="src\mcal_memory\mcal_memory_progmem_access.h">
-      <Filter>src\mcal_memory</Filter>
-    </ClInclude>
     <ClInclude Include="src\mcal_memory\mcal_memory_progmem_array.h">
       <Filter>src\mcal_memory</Filter>
     </ClInclude>
@@ -581,6 +575,12 @@
     <ClInclude Include="src\mcal_memory\mcal_memory_const_address_ptr.h">
       <Filter>src\mcal_memory</Filter>
     </ClInclude>
+    <ClInclude Include="src\mcal_memory\mcal_memory_nonconst_address_ptr.h">
+      <Filter>src\mcal_memory</Filter>
+    </ClInclude>
+    <ClInclude Include="src\mcal_memory\mcal_memory_progmem_access.h">
+      <Filter>src\mcal_memory</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="src\util\STL_C++XX_stdfloat\cstdfloat">

examples/chapter11_07a/src/mcal_memory/mcal_memory_const_address_ptr.h

@@ -50,7 +50,7 @@
 
     auto operator[](const difference_type i) const noexcept -> reference
     {
-      return *(my_ptr + (i * difference_type(static_size)));
+      return *offset_pointer(my_ptr, i);
     }
 
     auto operator++() noexcept -> const_address_ptr& { my_ptr += static_size; return *this; }

examples/chapter11_07a/src/mcal_memory/mcal_memory_nonconst_address_ptr.h

@@ -53,14 +53,14 @@
 
     auto operator[](const difference_type i) noexcept -> reference
     {
-      reference value = *(my_ptr + (i * difference_type(static_size)));
+      reference value = *offset_pointer(my_ptr, i);
 
       return value;
     }
 
     auto operator[](const difference_type i) const noexcept -> const_reference
     {
-      const_reference value = *(my_ptr + (i * difference_type(static_size)));
+      const_reference value = *offset_pointer(my_ptr, i);
 
       return value;
     }
@@ -97,8 +97,8 @@
 
   private:
     static constexpr pointer offset_pointer(pointer ptr,
-                                             difference_type n,
-                                             bool subtract = false) noexcept
+                                            difference_type n,
+                                            bool subtract = false) noexcept
     {
       return ((n < 0) ? (subtract ? ptr + difference_type((size_type(0U) - size_type(n)) * static_size)
                                   : ptr - difference_type((size_type(0U) - size_type(n)) * static_size))

examples/chapter11_07a/src/mcal_memory/mcal_memory_progmem_access.h

@@ -8,12 +8,12 @@
 #ifndef MCAL_MEMORY_PROGMEM_ACCESS_2019_08_17_H
   #define MCAL_MEMORY_PROGMEM_ACCESS_2019_08_17_H
 
+  #include <mcal_memory_progmem.h>
+
   #include <cstddef>
   #include <cstdint>
   #include <type_traits>
 
-  #include <mcal_memory_progmem.h>
-
   namespace mcal { namespace memory { namespace progmem {
 
   template<typename ValueType>
@@ -24,9 +24,12 @@
                                    && (sizeof(ValueType) != 4U)
     && (sizeof(ValueType) != 8U))>::type* = nullptr) noexcept -> ValueType
   {
+    static_assert(std::is_trivially_copyable<ValueType>::value,
+                  "Program-memory values must be trivially copyable.");
+
     using local_value_type = ValueType;
 
-    local_value_type dest;
+    local_value_type dest { };
 
     for(std::size_t i = 0U; i < sizeof(ValueType); ++i)
     {

examples/chapter11_07a/src/mcal_memory/mcal_memory_progmem_array.h

@@ -8,14 +8,14 @@
 #ifndef MCAL_MEMORY_PROGMEM_ARRAY_2019_05_04_H
   #define MCAL_MEMORY_PROGMEM_ARRAY_2019_05_04_H
 
+  #include <mcal_memory/mcal_memory_progmem_iterator.h>
+
   #include <algorithm>
   #include <cstddef>
   #include <iterator>
   #include <type_traits>
 
-  #include <mcal_memory/mcal_memory_progmem_iterator.h>
-
-  // Implement most an std::array-like container for read-only program memory.
+  // Implement most of an std::array-like container for read-only program memory.
   // See ISO/IEC 14882:2011 Chapter 23.3.2.
 
   namespace mcal { namespace memory { namespace progmem {
@@ -136,28 +136,34 @@
     return (!(right < left));
   }
 
-  template<typename T>
-  struct tuple_size;
-
-  template<typename T, const mcal_progmem_uintptr_t N>
-  struct tuple_size<mcal::memory::progmem::array<T, N>>
-    : public std::integral_constant<mcal_progmem_uintptr_t, N> { };
-
-  template<mcal_progmem_uintptr_t N, typename T>
-  struct tuple_element;
-
   template<mcal_progmem_uintptr_t I,
            typename T,
            mcal_progmem_uintptr_t N>
-  struct tuple_element<I, mcal::memory::progmem::array<T, N>>
+  auto get(const array<T, N>& source) noexcept -> typename array<T, N>::const_reference
   {
-    static_assert(I < N, "Sorry, tuple_element index is out of bounds.");
-
-    typedef T type;
-  };
+    static_assert(I < N, "Sorry, get index is out of bounds.");
+    return source[I];
+  }
 
   } } } // namespace mcal::memory::progmem
 
+  namespace std
+  {
+    template<typename T, mcal_progmem_uintptr_t N>
+    struct tuple_size<mcal::memory::progmem::array<T, N>>
+      : integral_constant<std::size_t, static_cast<std::size_t>(N)> { };
+
+    template<std::size_t I,
+             typename T,
+             mcal_progmem_uintptr_t N>
+    struct tuple_element<I, mcal::memory::progmem::array<T, N>>
+    {
+      static_assert(I < N, "Sorry, tuple_element index is out of bounds.");
+
+      using type = T;
+    };
+  }
+
   template<typename T, mcal_progmem_uintptr_t N>
   constexpr mcal_progmem_uintptr_t mcal::memory::progmem::array<T, N>::static_size;
 

examples/chapter11_07a/src/mcal_memory/mcal_memory_progmem_iterator.h

@@ -8,14 +8,13 @@
 #ifndef MCAL_MEMORY_PROGMEM_ITERATOR_2019_05_04_H
   #define MCAL_MEMORY_PROGMEM_ITERATOR_2019_05_04_H
 
-  #include <iterator>
-
-  #include <type_traits>
-
   #include <mcal_memory/mcal_memory_const_address_ptr.h>
   #include <mcal_memory/mcal_memory_progmem_ptr.h>
   #include <mcal_memory/mcal_memory_random_access_iterator_operations.h>
 
+  #include <iterator>
+  #include <type_traits>
+
   // Implement specialized iterator types for read-only program memory.
 
   namespace mcal { namespace memory { namespace progmem {
@@ -53,15 +52,15 @@
 
     progmem_iterator(const pointer x) noexcept : current(x) { }
 
-    template<typename OtherIteratorType,
+    template<typename OtherValueType,
              typename OtherAddressType,
              typename OtherAddressDifferenceType,
-             typename std::enable_if<
-               std::is_convertible<OtherIteratorType, ValueType>::value &&
+             typename std::enable_if_t<
+                std::is_convertible<OtherValueType, ValueType>::value &&
                std::is_convertible<OtherAddressType, AddressType>::value &&
                std::is_convertible<OtherAddressDifferenceType, AddressDifferenceType>::value
-             >::type* = nullptr>
-    progmem_iterator(const progmem_iterator<OtherIteratorType, OtherAddressType, OtherAddressDifferenceType>& other) noexcept
+             >* = nullptr>
+    progmem_iterator(const progmem_iterator<OtherValueType, OtherAddressType, OtherAddressDifferenceType>& other) noexcept
       : current(static_cast<const pointer>(other.current)) { }
 
     auto operator*() const noexcept -> reference
@@ -91,7 +90,50 @@
     }
 
     auto operator+=(difference_type n) noexcept -> progmem_iterator& { operations::increment(current, n); return *this; }
-    auto operator-=(difference_type n) noexcept -> progmem_iterator& { current = operations::subtract(current, n); return *this; }
+    auto operator-=(difference_type n) noexcept -> progmem_iterator& { operations::increment(current, -n); return *this; }
+
+    template<typename OtherValueType, typename OtherAddressType, typename OtherAddressDifferenceType>
+    auto operator==(const progmem_iterator<OtherValueType, OtherAddressType, OtherAddressDifferenceType>& other) const noexcept -> bool
+    {
+      return (const_pointer(current) == const_pointer(other.current));
+    }
+
+    template<typename OtherValueType, typename OtherAddressType, typename OtherAddressDifferenceType>
+    auto operator!=(const progmem_iterator<OtherValueType, OtherAddressType, OtherAddressDifferenceType>& other) const noexcept -> bool
+    {
+      return !(*this == other);
+    }
+
+    template<typename OtherValueType, typename OtherAddressType, typename OtherAddressDifferenceType>
+    auto operator-(const progmem_iterator<OtherValueType, OtherAddressType, OtherAddressDifferenceType>& other) const noexcept
+      -> difference_type
+    {
+      return const_pointer(current) - const_pointer(other.current);
+    }
+
+    template<typename OtherValueType, typename OtherAddressType, typename OtherAddressDifferenceType>
+    auto operator<(const progmem_iterator<OtherValueType, OtherAddressType, OtherAddressDifferenceType>& other) const noexcept -> bool
+    {
+      return const_pointer(current) < const_pointer(other.current);
+    }
+
+    template<typename OtherValueType, typename OtherAddressType, typename OtherAddressDifferenceType>
+    auto operator<=(const progmem_iterator<OtherValueType, OtherAddressType, OtherAddressDifferenceType>& other) const noexcept -> bool
+    {
+      return const_pointer(current) <= const_pointer(other.current);
+    }
+
+    template<typename OtherValueType, typename OtherAddressType, typename OtherAddressDifferenceType>
+    auto operator>(const progmem_iterator<OtherValueType, OtherAddressType, OtherAddressDifferenceType>& other) const noexcept -> bool
+    {
+      return const_pointer(current) > const_pointer(other.current);
+    }
+
+    template<typename OtherValueType, typename OtherAddressType, typename OtherAddressDifferenceType>
+    auto operator>=(const progmem_iterator<OtherValueType, OtherAddressType, OtherAddressDifferenceType>& other) const noexcept -> bool
+    {
+      return const_pointer(current) >= const_pointer(other.current);
+    }
 
   private:
     pointer current{};

examples/chapter11_07a/src/mcal_memory/mcal_memory_progmem_ptr.h

@@ -10,6 +10,7 @@
 
   #include <mcal_memory/mcal_memory_progmem_ref.h>
 
+  #include <iterator>
   #include <type_traits>
 
   // Implement a specialized pointer type for read-only program memory.
@@ -33,19 +34,19 @@
 
     static constexpr size_type value_size = sizeof(value_type);
 
-    progmem_ptr() noexcept = default;
+    constexpr progmem_ptr() noexcept = default;
 
     explicit constexpr progmem_ptr(address_type addr) noexcept
       : my_address(addr) { }
 
     template<typename OtherValueType,
              typename OtherAddressType,
              typename OtherAddressDifferenceType,
-             typename std::enable_if<
+             typename std::enable_if_t<
                std::is_convertible<OtherValueType, ValueType>::value &&
                std::is_convertible<OtherAddressType, address_type>::value &&
                std::is_convertible<OtherAddressDifferenceType, AddressDifferenceType>::value
-             >::type* = nullptr>
+             >* = nullptr>
     progmem_ptr(const progmem_ptr<OtherValueType, OtherAddressType, OtherAddressDifferenceType>& other) noexcept
       : my_address(other.my_address) { }
 

examples/chapter11_07a/src/mcal_memory/mcal_memory_sram_access.h

@@ -19,8 +19,13 @@
   auto read(const mcal_sram_uintptr_t src_addr,
             const typename std::enable_if<(sizeof(ValueType) == 1U)>::type* = nullptr) noexcept -> ValueType
   {
+    static_assert(std::is_trivially_copyable<ValueType>::value,
+                  "SRAM values must be trivially copyable.");
+
     auto byte_to_read = std::uint8_t { };
 
+    // The backend status is intentionally ignored. SRAM proxy operations are
+    // value-oriented and do not expose a transaction status.
     const auto result_read_is_ok = mcal_memory_sram_device().read(src_addr, &byte_to_read);
 
     static_cast<void>(result_read_is_ok);
@@ -32,10 +37,15 @@
   auto read(const mcal_sram_uintptr_t src_addr,
             const typename std::enable_if<(sizeof(ValueType) != 1U)>::type* = nullptr) noexcept -> ValueType
   {
+    static_assert(std::is_trivially_copyable<ValueType>::value,
+                  "SRAM values must be trivially copyable.");
+
     using local_value_type = ValueType;
 
     auto value_to_read = local_value_type { };
 
+    // The backend status is intentionally ignored. SRAM proxy operations do
+    // not expose a transaction status.
     const auto result_read_is_ok =
       mcal_memory_sram_device().read_n(src_addr, reinterpret_cast<std::uint8_t*>(&value_to_read), sizeof(local_value_type));
 
@@ -49,6 +59,11 @@
              const mcal_sram_uintptr_t dest_addr,
              const typename std::enable_if<(sizeof(ValueType) == 1U)>::type* = nullptr) noexcept -> void
   {
+    static_assert(std::is_trivially_copyable<ValueType>::value,
+                  "SRAM values must be trivially copyable.");
+
+    // The backend status is intentionally ignored. SRAM proxy operations do
+    // not expose a transaction status.
     const auto result_write_is_ok = mcal_memory_sram_device().write(dest_addr, &src_value);
 
     static_cast<void>(result_write_is_ok);
@@ -59,6 +74,11 @@
              const mcal_sram_uintptr_t dest_addr,
              const typename std::enable_if<(sizeof(ValueType) != 1U)>::type* = nullptr) noexcept -> void
   {
+    static_assert(std::is_trivially_copyable<ValueType>::value,
+                  "SRAM values must be trivially copyable.");
+
+    // The backend status is intentionally ignored. SRAM proxy operations do
+    // not expose a transaction status.
     using local_value_type = ValueType;
 
     const auto result_write_is_ok = mcal_memory_sram_device().write_n(dest_addr, reinterpret_cast<const std::uint8_t*>(&src_value), sizeof(local_value_type));