range-v3 support

[robert-andrzejuk]

I would reeeaaalllllyyy love to get some insight into what is going in this piece of code:

#include <iostream>
#include <range/v3/all.hpp>

int main()
{
    std::string text = "1 22 333 4444 55555 666666 7777777 88888888";

    using namespace ranges::view;
    auto m_text = zip(ints, text | split(' '));

    for (const auto [a, b] : m_text)
        std ::cout << a << ':' << b << std::endl;
}

But no libraries are supported.

Any suggestions?

[andreasfertig]

Hello @robert-andrzejuk,

interesting, are your sure that you like to see it? I can give you a preview:

#include <iostream>
#include <range/v3/all.hpp>

int main()
{
  std::string text = std::basic_string<char, std::char_traits<char>, std::allocator<char> >("1 22 333 4444 55555 666666 7777777 88888888", std::allocator<char>());
  using namespace ranges;
  ranges::zip_view<ranges::view::ints_fn, ranges::split_view<ranges::iterator_range<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, element_pred<std::basic_string<char, std::char_traits<char>, std::allocator<char> > &> > > m_text = ranges::view::zip.operator()(ranges::view::ints, ranges::operator|(text, ranges::view::split.operator()(' ')));
  {
    ranges::zip_view<ranges::view::ints_fn, ranges::split_view<ranges::iterator_range<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, element_pred<std::basic_string<char, std::char_traits<char>, std::allocator<char> > &> > > & __range1 = m_text;
    ranges::basic_iterator<cursor<0> > __begin1 = static_cast<ranges::view_facade<ranges::iter_zip_with_view<ranges::detail::indirect_zip_fn_, ranges::view::ints_fn, ranges::split_view<ranges::iterator_range<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, element_pred<std::basic_string<char, std::char_traits<char>, std::allocator<char> > &> > >, -1>&>(__range1).begin();
    sentinel<0> __end1 = static_cast<ranges::view_facade<ranges::iter_zip_with_view<ranges::detail::indirect_zip_fn_, ranges::view::ints_fn, ranges::split_view<ranges::iterator_range<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, element_pred<std::basic_string<char, std::char_traits<char>, std::allocator<char> > &> > >, -1>&>(__range1).end();
    for(; operator!=(__begin1, __end1); __begin1.operator++()) 
    {
      const ranges::common_pair<int, ranges::indirect_view<ranges::take_while_view<ranges::iota_view<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, void>, ranges::split_view<ranges::iterator_range<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, ranges::view::split_fn::element_pred<std::basic_string<char, std::char_traits<char>, std::allocator<char> > &> >::cursor<false>::search_pred> > > __operator11 = __begin1.operator*();
      std::tuple_element<0, const ranges::common_pair<int, ranges::indirect_view<ranges::take_while_view<ranges::iota_view<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, void>, ranges::split_view<ranges::iterator_range<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, ranges::view::split_fn::element_pred<std::basic_string<char, std::char_traits<char>, std::allocator<char> > &> >::cursor<false>::search_pred> > > >::type& a = std::get<0ul>(static_cast<const std::pair<int, ranges::indirect_view<ranges::take_while_view<ranges::iota_view<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, void>, ranges::split_view<ranges::iterator_range<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, ranges::view::split_fn::element_pred<std::basic_string<char, std::char_traits<char>, std::allocator<char> > &> >::cursor<false>::search_pred> > >&>(__operator11));
      const ranges::indirect_view<ranges::take_while_view<ranges::iota_view<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, void>, ranges::split_view<ranges::iterator_range<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, ranges::view::split_fn::element_pred<std::basic_string<char, std::char_traits<char>, std::allocator<char> > &> >::cursor<false>::search_pred> >& b = std::get<1ul>(static_cast<const std::pair<int, ranges::indirect_view<ranges::take_while_view<ranges::iota_view<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, void>, ranges::split_view<ranges::iterator_range<__gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char *, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, ranges::view::split_fn::element_pred<std::basic_string<char, std::char_traits<char>, std::allocator<char> > &> >::cursor<false>::search_pred> > >&>(__operator11));
    }
    
  }
}

You can do this yourself by using the docker project and add the headers there. However, I assume you like to have the support directly in cppinsights.io. I'm not entirely sure whether this is a good idea. It takes a significant amount of time to transform this small example. Plus how should compatibility be handled?

Andreas

[robert-andrzejuk]

Thanks!
First I need to learn how to make a docker project ;-)

By setting a max column length of 100 and formatting it, the insight is much better:

int main()
{
    std::string text = std::basic_string<
          char,
          std::char_traits< char >,
          std::allocator< char > >("1 22 333 4444 55555 666666 7777777 88888888",
                                   std::allocator< char >());
    using namespace ranges;
    ranges::zip_view<
          ranges::view::ints_fn,
          ranges::split_view<
                ranges::iterator_range<
                      __gnu_cxx::__normal_iterator< char*,
                                                    std::basic_string< char,
                                                                       std::char_traits< char >,
                                                                       std::allocator< char > > >,
                      __gnu_cxx::__normal_iterator< char*,
                                                    std::basic_string< char,
                                                                       std::char_traits< char >,
                                                                       std::allocator< char > > > >,
                element_pred< std::basic_string< char,
                                                 std::char_traits< char >,
                                                 std::allocator< char > >& > > >
          m_text = ranges::view::zip.operator()(ranges::view::ints,
                                                ranges::operator|(text,
                                                                  ranges::view::split.operator()(
                                                                        ' ')));
    {
        ranges::zip_view<
              ranges::view::ints_fn,
              ranges::split_view<
                    ranges::iterator_range< __gnu_cxx::__normal_iterator<
                                                  char*,
                                                  std::basic_string< char,
                                                                     std::char_traits< char >,
                                                                     std::allocator< char > > >,
                                            __gnu_cxx::__normal_iterator<
                                                  char*,
                                                  std::basic_string< char,
                                                                     std::char_traits< char >,
                                                                     std::allocator< char > > > >,
                    element_pred< std::basic_string< char,
                                                     std::char_traits< char >,
                                                     std::allocator< char > >& > > >&
              __range1 = m_text;
        ranges::basic_iterator< cursor< 0 > > __begin1 = static_cast< ranges::view_facade<
              ranges::iter_zip_with_view<
                    ranges::detail::indirect_zip_fn_,
                    ranges::view::ints_fn,
                    ranges::split_view<
                          ranges::iterator_range<
                                __gnu_cxx::__normal_iterator<
                                      char*,
                                      std::basic_string< char,
                                                         std::char_traits< char >,
                                                         std::allocator< char > > >,
                                __gnu_cxx::__normal_iterator<
                                      char*,
                                      std::basic_string< char,
                                                         std::char_traits< char >,
                                                         std::allocator< char > > > >,
                          element_pred< std::basic_string< char,
                                                           std::char_traits< char >,
                                                           std::allocator< char > >& > > >,
              -1 >& >(__range1)
                                                               .begin();
        sentinel< 0 > __end1 = static_cast< ranges::view_facade<
              ranges::iter_zip_with_view<
                    ranges::detail::indirect_zip_fn_,
                    ranges::view::ints_fn,
                    ranges::split_view<
                          ranges::iterator_range<
                                __gnu_cxx::__normal_iterator<
                                      char*,
                                      std::basic_string< char,
                                                         std::char_traits< char >,
                                                         std::allocator< char > > >,
                                __gnu_cxx::__normal_iterator<
                                      char*,
                                      std::basic_string< char,
                                                         std::char_traits< char >,
                                                         std::allocator< char > > > >,
                          element_pred< std::basic_string< char,
                                                           std::char_traits< char >,
                                                           std::allocator< char > >& > > >,
              -1 >& >(__range1)
                                     .end();
        for (; operator!=(__begin1, __end1); __begin1.operator++())
        {
            const ranges::common_pair<
                  int,
                  ranges::indirect_view< ranges::take_while_view<
                        ranges::iota_view< __gnu_cxx::__normal_iterator<
                                                 char*,
                                                 std::basic_string< char,
                                                                    std::char_traits< char >,
                                                                    std::allocator< char > > >,
                                           void >,
                        ranges::split_view<
                              ranges::iterator_range<
                                    __gnu_cxx::__normal_iterator<
                                          char*,
                                          std::basic_string< char,
                                                             std::char_traits< char >,
                                                             std::allocator< char > > >,
                                    __gnu_cxx::__normal_iterator<
                                          char*,
                                          std::basic_string< char,
                                                             std::char_traits< char >,
                                                             std::allocator< char > > > >,
                              ranges::view::split_fn::element_pred<
                                    std::basic_string< char,
                                                       std::char_traits< char >,
                                                       std::allocator< char > >& > >::
                              cursor< false >::search_pred > > >
                  __operator11 = __begin1.operator*();
            std::tuple_element<
                  0,
                  const ranges::common_pair<
                        int,
                        ranges::indirect_view< ranges::take_while_view<
                              ranges::iota_view<
                                    __gnu_cxx::__normal_iterator<
                                          char*,
                                          std::basic_string< char,
                                                             std::char_traits< char >,
                                                             std::allocator< char > > >,
                                    void >,
                              ranges::split_view<
                                    ranges::iterator_range<
                                          __gnu_cxx::__normal_iterator<
                                                char*,
                                                std::basic_string< char,
                                                                   std::char_traits< char >,
                                                                   std::allocator< char > > >,
                                          __gnu_cxx::__normal_iterator<
                                                char*,
                                                std::basic_string< char,
                                                                   std::char_traits< char >,
                                                                   std::allocator< char > > > >,
                                    ranges::view::split_fn::element_pred<
                                          std::basic_string< char,
                                                             std::char_traits< char >,
                                                             std::allocator< char > >& > >::
                                    cursor< false >::search_pred > > > >::type&
                  a = std::get< 0ul >(
                        static_cast< const std::pair<
                              int,
                              ranges::indirect_view< ranges::take_while_view<
                                    ranges::iota_view<
                                          __gnu_cxx::__normal_iterator<
                                                char*,
                                                std::basic_string< char,
                                                                   std::char_traits< char >,
                                                                   std::allocator< char > > >,
                                          void >,
                                    ranges::split_view<
                                          ranges::iterator_range<
                                                __gnu_cxx::__normal_iterator<
                                                      char*,
                                                      std::basic_string< char,
                                                                         std::char_traits< char >,
                                                                         std::allocator< char > > >,
                                                __gnu_cxx::__normal_iterator<
                                                      char*,
                                                      std::basic_string<
                                                            char,
                                                            std::char_traits< char >,
                                                            std::allocator< char > > > >,
                                          ranges::view::split_fn::element_pred<
                                                std::basic_string< char,
                                                                   std::char_traits< char >,
                                                                   std::allocator< char > >& > >::
                                          cursor< false >::search_pred > > >& >(__operator11));
            const ranges::indirect_view< ranges::take_while_view<
                  ranges::iota_view<
                        __gnu_cxx::__normal_iterator< char*,
                                                      std::basic_string< char,
                                                                         std::char_traits< char >,
                                                                         std::allocator< char > > >,
                        void >,
                  ranges::split_view< ranges::iterator_range<
                                            __gnu_cxx::__normal_iterator<
                                                  char*,
                                                  std::basic_string< char,
                                                                     std::char_traits< char >,
                                                                     std::allocator< char > > >,
                                            __gnu_cxx::__normal_iterator<
                                                  char*,
                                                  std::basic_string< char,
                                                                     std::char_traits< char >,
                                                                     std::allocator< char > > > >,
                                      ranges::view::split_fn::element_pred<
                                            std::basic_string< char,
                                                               std::char_traits< char >,
                                                               std::allocator< char > >& > >::
                        cursor< false >::search_pred > >&
                  b = std::get< 1ul >(
                        static_cast< const std::pair<
                              int,
                              ranges::indirect_view< ranges::take_while_view<
                                    ranges::iota_view<
                                          __gnu_cxx::__normal_iterator<
                                                char*,
                                                std::basic_string< char,
                                                                   std::char_traits< char >,
                                                                   std::allocator< char > > >,
                                          void >,
                                    ranges::split_view<
                                          ranges::iterator_range<
                                                __gnu_cxx::__normal_iterator<
                                                      char*,
                                                      std::basic_string< char,
                                                                         std::char_traits< char >,
                                                                         std::allocator< char > > >,
                                                __gnu_cxx::__normal_iterator<
                                                      char*,
                                                      std::basic_string<
                                                            char,
                                                            std::char_traits< char >,
                                                            std::allocator< char > > > >,
                                          ranges::view::split_fn::element_pred<
                                                std::basic_string< char,
                                                                   std::char_traits< char >,
                                                                   std::allocator< char > >& > >::
                                          cursor< false >::search_pred > > >& >(__operator11));
        }
    }
}

[andreasfertig]

Thanks for the column limit tip. That's great!

Regarding the docker, you can have a look here: cppinsights-docker. What you then need to do is add the includes to the Dockerfile like this:

COPY range-v3/ /usr/include/
RUN find /usr/include/range -type f -exec chmod 0644 {} \;
RUN find /usr/include/range -type d -exec chmod 0755 {} \;
RUN find /usr/include/meta -type f -exec chmod 0644 {} \;
RUN find /usr/include/meta -type d -exec chmod 0755 {} \;

assuming range-v3 was downloaded and unpacked to the folder where you cloned the cppinsights-docker repo to. With that change after running make you code should transform.

Back to the web front-end. What is the insight you like to get from the code? With the preview, is this what you want?

Andreas

[robert-andrzejuk]

It's just interesting for me to see the techniques used, such that a simple piece of code - creates all this machinery behind it:

• the way different classes are aggregated(?composed?) together with templates, to create the required end product (which is not just a simple non-templated ranges::view::zip class)
• that static objects with the operator() are used to "emulate" a function call - now I can go look at where the source is.

Errors with ranges-v3 don't give much tips, where something is wrong (the compiler just throws out a massive amount of incomprehensible types)
So I'm hoping that by creating a "Minimal, Complete, and Verifiable example" this will let me get to the root of my issues.

[stale]

Thanks for contributing to this issue. As it has been 60 days since the last activity waiting for a followup. This issue will be automatically closed in 7 days, if no further activity occurs. This is often because the request was already solved in some way and it just wasn't updated or it's no longer applicable. If that's not the case, please respond before the issue is closed. We'll gladly take a look again! In any case, thank you for your contributions!