#include <cstdint>
#include <array>

#include <avr/pgmspace.h>
#include "stdio.h"


template<class T>
struct PgmTypeTrait {};

template<>
struct PgmTypeTrait<char>
{
    static char read(uint16_t addr_short) {return pgm_read_byte_near(addr_short);}
};

template<>
struct PgmTypeTrait<int>
{
    static int read(uint16_t addr_short) {return pgm_read_word_near(addr_short);}
};


template<class T>
class ProgmemConstIterator
{
public:
    constexpr ProgmemConstIterator(const T* ptr) : ptr_(ptr) {}
    constexpr auto operator != (const ProgmemConstIterator& rhs) { return ptr_ != rhs.ptr_;}
    constexpr auto operator ++ () { return ProgmemConstIterator(ptr_++);}
    T operator * () const         { return PgmTypeTrait<T>::read((uint16_t)ptr_);}
private:
    const T* ptr_;
};

template<class T, ::std::size_t N>
class ProgmemArray : protected ::std::array<T,N>
{
public:
    using const_iterator = ProgmemConstIterator<T>;

    constexpr ProgmemArray(const ::std::array<T,N> &init) : ::std::array<T,N>(init) {}
    constexpr ProgmemArray(const T (&init)[N]) : ::std::array<T,N>(::std::to_array(init)) {}

    auto begin() const noexcept {return const_iterator(::std::array<T,N>::begin()); }
    auto end()   const noexcept {return const_iterator(::std::array<T,N>::end()); }
};

const ProgmemArray my_str PROGMEM = "Hello World";


void intTest1()
{
  for (const auto c : my_str)
    putc(c, stdout);
}