format-util.hpp

Go to the documentation of this file.

/*
  FORMAT-UTIL.hpp  -  helpers for formatting and diagnostics

   Copyright (C)
     2009,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

*/


#ifndef LIB_FORMAT_UTIL_H
#define LIB_FORMAT_UTIL_H

#include "lib/meta/trait.hpp"
#include "lib/format-obj.hpp"
#include "lib/itertools.hpp"
#include "lib/symbol.hpp"
#include "lib/util.hpp"

#include <string>
#include <vector>
#include <sstream>
#include <utility>
#include <typeinfo>



namespace util {
  
  using lib::meta::can_IterForEach;
  using std::string;
  using std::forward;
  using std::move;
  
  
  
  namespace { // helper to convert arbitrary elements toString
    
    template<class CON>
    inline void
    do_stringify(CON&)
    { /* do nothing */ }
    
    template<class CON, typename X, typename...ELMS>
    inline void
    do_stringify(CON& container, X const& elm, ELMS const& ...args)
    {
      container += util::toString (elm);
      do_stringify (container, args...);
    }
    
    
    template<class CON, typename...ELMS>
    struct SeqContainer
      : CON
      {
        void
        operator+= (string&& s)
          {
            CON::push_back (move(s));
          }
      };
    
    // most common case: use a vector container...
    using std::vector;
    
    template<typename X, typename...ELMS>
    struct SeqContainer<vector<X>, ELMS...>
      :vector<X>
      {
        SeqContainer()
          {
            this->reserve(sizeof...(ELMS));
          }
        
        void
        operator+= (string&& s)
          {
            this->emplace_back (move(s));
          }
      };
  }//(end) stringify helper
  
  
  template<class CON, typename...ELMS>
  inline CON
  collectStr(ELMS const& ...elms)
  {
    SeqContainer<CON,ELMS...> storage;
    do_stringify (storage, elms...);
    return CON {move(storage)};
  }
  
  template<typename...ELMS>
  inline vector<string>
  stringify (ELMS const& ...elms)
  {
    return collectStr<vector<string>> (elms...);
  }
  
  template<class IT>
  inline auto
  stringify (IT&& src)
  {
    using Val = typename lib::meta::ValueTypeBinding<IT>::value_type;
    
    return lib::transformIterator(forward<IT>(src), util::toString<Val>);
  }
  
  
  
  namespace { // helper to build range iterator on demand
    template<class CON, typename TOGGLE = void>
    struct _RangeIter
      {
        using StlIter = typename CON::const_iterator;
        
        lib::RangeIter<StlIter> iter;
        
        _RangeIter(CON const& collection)
          : iter(begin(collection), end(collection))
          { }
      };
    
    template<class IT>
    struct _RangeIter<IT,   lib::meta::enable_if< can_IterForEach<IT>> >
      {
        IT iter;
        
        _RangeIter(IT&& srcIter)
          : iter(std::forward<IT>(srcIter))
          { }
        _RangeIter(IT const& srcIter)          // note: copy here
          : iter(srcIter)
          { }
        
      };
  }//(end) join helper
  
  
  template<class CON>
  inline string
  join (CON&& coll, string const& delim =", ")
  {
    using Coll = typename lib::meta::Strip<CON>::TypePlain;
    _RangeIter<Coll> range(std::forward<CON>(coll));    // copies when CON is reference
    
    auto strings = stringify (std::move (range.iter));
    if (!strings) return "";
    
    std::ostringstream buffer;
    for ( ; strings; ++strings)
      buffer << *strings << delim;
    
    // chop off last delimiter
    size_t len = buffer.str().length();
    ASSERT (len >= delim.length());
    return buffer.str().substr(0, len - delim.length());
  }
  
  template<class X>
  inline string
  join (std::initializer_list<X> const&& ili, string const& delim =", ")
  {
    return join (ili, delim);
  }
  
  // Note: offering a variant of join with var-args would create lots of ambiguities
  
  template<typename...ARGS>
  inline string
  joinArgList (ARGS const& ...args)
  {
    return "("+join (stringify (args...))+")";
  }
  
  template<typename...ARGS>
  inline string
  joinDash (ARGS const& ...args)
  {
    return join (stringify (args...), "-");
  }
  
  template<typename...ARGS>
  inline string
  joinDot (ARGS const& ...args)
  {
    return join (stringify (args...), ".");
  }
  
  
} // namespace util
#endif /*LIB_FORMAT_UTIL_H*/