Updated and fixed

.travis.yml

@@ -79,7 +79,7 @@ script:
         export PKG_CONFIG_PATH=$(brew --prefix openssl)"/lib/pkgconfig";
         cmake . -DCMAKE_BUILD_TYPE=$BUILD_TYPE $BUILD_OPTS -DENABLE_UNITTESTS="ON";
       fi
-    - make -j$(nproc);
+    - make VERBOSE=1 -j$(nproc);
     - if [ "$TRAVIS_COMPILER" != "x86_64-w64-mingw32-g++" ]; then
         ulimit -c unlimited;
         ./test-srt -disable-ipv6;

apps/srt-file-transmit.cpp

@@ -389,8 +389,10 @@ bool DoUpload(UriParser& ut, string path, string filename,
             while (n > 0)
             {
                 int st = tar->Write(buf.data() + shift, n, 0, out_stats);
-                Verb() << "Upload: " << n << " --> " << st
-                    << (!shift ? string() : "+" + Sprint(shift));
+                Verb("Upload: ", n, " --> ", st, VerbNoEOL);
+                if (shift)
+                    Verb("+", shift, VerbNoEOL);
+                Verb();
                 if (st == SRT_ERROR)
                 {
                     cerr << "Upload: SRT error: " << srt_getlasterror_str()

apps/transmitmedia.cpp

@@ -41,7 +41,6 @@
 #include "srt_compat.h"
 #include "verbose.hpp"
 
-
 using namespace std;
 using namespace srt;
 
@@ -203,7 +202,7 @@ void SrtCommon::InitParameters(string host, map<string,string> par)
         if (transmit_chunk_size > SRT_LIVE_MAX_PLSIZE)
             throw std::runtime_error("Chunk size in live mode exceeds 1456 bytes; this is not supported");
 
-        par["payloadsize"] = Sprint(transmit_chunk_size);
+        par["payloadsize"] = fmts(transmit_chunk_size);
     }
 
     // Assign the others here.

apps/verbose.hpp

@@ -11,7 +11,7 @@
 #ifndef INC_SRT_VERBOSE_HPP
 #define INC_SRT_VERBOSE_HPP
 
-#include <iostream>
+#include "ofmt_iostream.h"
 #include "sync.h"
 
 namespace Verbose

srtcore/api.cpp

@@ -1403,7 +1403,7 @@ int srt::CUDTUnited::groupConnect(CUDTGroup* pg, SRT_SOCKGROUPCONFIG* targets, i
             for (size_t i = 0; i < g.m_config.size(); ++i)
             {
                 HLOGC(aclog.Debug, log << "groupConnect: OPTION @" << sid << " #" << g.m_config[i].so);
-                error_reason = Sprint("group-derived option: #", g.m_config[i].so);
+                error_reason = fmtcat("group-derived option: #", g.m_config[i].so);
                 ns->core().setOpt(g.m_config[i].so, &g.m_config[i].value[0], (int)g.m_config[i].value.size());
             }
 

srtcore/core.cpp

@@ -6000,12 +6000,12 @@ bool srt::CUDT::frequentLogAllowed(size_t logid, const time_point& tnow, std::st
         const int supr = m_aSuppressedMsg[logid];
 
         if (supr > 0)
-            w_why = Sprint("++SUPPRESSED: ", supr);
+            w_why = fmtcat("++SUPPRESSED: ", supr);
         m_aSuppressedMsg[logid] = 0;
     }
     else
     {
-        w_why = Sprint("Too early - last one was ", FormatDuration<DUNIT_MS>(tnow - m_tsLogSlowDown[logid].load()));
+        w_why = fmtcat("Too early - last one was ", FormatDuration<DUNIT_MS>(tnow - m_tsLogSlowDown[logid].load()));
         // Set YOUR OWN bit, atomically.
         m_LogSlowDownExpired |= uint8_t(BIT(logid));
         ++m_aSuppressedMsg[logid];
@@ -9328,7 +9328,7 @@ void srt::CUDT::updateAfterSrtHandshake(int hsv)
     {
         ScopedLock glock (uglobal().m_GlobControlLock);
         grpspec = m_parent->m_GroupOf
-            ? Sprint(" group=$", m_parent->m_GroupOf->id())
+            ? fmtcat(" group=$", m_parent->m_GroupOf->id())
             : string();
     }
 #else

srtcore/fec.cpp

@@ -533,7 +533,7 @@ void FECFilterBuiltin::ClipPacket(Group& g, const CPacket& pkt)
 
     ClipData(g, length_net, kflg, timestamp_hw, pkt.data(), pkt.size());
 
-    fmtc x; x.hex();
+    IF_HEAVY_LOGGING(fmtc x = fmtc().hex());
     HLOGC(pflog.Debug, log << "FEC DATA PKT CLIP: "
             << "FLAGS=" << fmt<unsigned>(kflg, x)
             << " LENGTH[ne]=" << fmt(length_net, x)
@@ -562,7 +562,7 @@ void FECFilterBuiltin::ClipControlPacket(Group& g, const CPacket& pkt)
 
     ClipData(g, *length_clip, *flag_clip, timestamp_hw, payload, payload_clip_len);
 
-    fmtc x; x.hex();
+    IF_HEAVY_LOGGING(fmtc x = fmtc().hex());
     HLOGC(pflog.Debug, log << "FEC/CTL CLIP: "
             << "FLAGS=" << fmt<unsigned>(*flag_clip, x)
             << " LENGTH[ne]=" << fmt(*length_clip, x)
@@ -586,7 +586,7 @@ void FECFilterBuiltin::ClipRebuiltPacket(Group& g, Receive::PrivPacket& pkt)
 
     ClipData(g, length_net, kflg, timestamp_hw, pkt.buffer, pkt.length);
 
-    fmtc x; x.hex();
+    IF_HEAVY_LOGGING(fmtc x = fmtc().hex());
     HLOGC(pflog.Debug, log << "FEC REBUILT DATA CLIP: "
             << "FLAGS=" << fmt<unsigned>(kflg, x)
             << " LENGTH[ne]=" << fmt(length_net, x)
@@ -769,7 +769,7 @@ void FECFilterBuiltin::PackControl(const Group& g, signed char index, SrtPacket&
     pkt.hdr[SRT_PH_TIMESTAMP] = g.timestamp_clip;
     pkt.hdr[SRT_PH_SEQNO] = seq;
 
-    fmtc x; x.hex();
+    IF_HEAVY_LOGGING(fmtc x = fmtc().hex());
     HLOGC(pflog.Debug, log << "FEC: PackControl: hdr("
             << (total_size - g.payload_clip.size()) << "): INDEX="
             << int(index) << " LENGTH[ne]=" << fmt(g.length_clip, x)

srtcore/ofmt.h

@@ -5,8 +5,32 @@
 // for FILE type from stdio. It has nothing to do with the rest of the {fmt}
 // library, except that it reuses the namespace.
 
-#ifndef INC_SRT_IFMT_H
-#define INC_SRT_IFMT_H
+// USAGE:
+//
+// 1. Using iostream style:
+//
+// ofmtstream sout;
+//
+// sout << "Value: " << v << " (" << fmt(v, fmtc().hex().width(2).fillzero()) << ")\n";
+//
+// NOTE: When passing a string literal, consider using "Value"_V (C++11 only)
+// or OFMT_RAWSTR("Value"). Unfortunately C++ doesn't distinguish "Value" and
+// char [20] v = "Value"; both here contain "Value\0", but sizeof(v) for them
+// returns the size of the allocated space, not size of the string. Although
+// the compiler should expand strlen() in place for literals, note that it
+// won't do it if optimizations are turned off.
+//
+// 2. Using variadic style:
+//
+// sout.print("Value: ", v, " (", fmt(v, fmtc().hex().width(2).fillzero()), ")\n");
+//
+//
+// OFMT has also a potential to be used together with iostream, but it requires more
+// definition support. This is only the basic fragment to be used with the logging system,
+// hence it provides only a wrapper over std::stringstream.
+
+#ifndef INC_SRT_OFMT_H
+#define INC_SRT_OFMT_H
 
 #include <string>
 #include <cstring>
@@ -139,6 +163,15 @@ struct fmt_proxy
     basic_fmtc<CharType> format_spec;
 
     fmt_proxy(const Value& v, const basic_fmtc<CharType>& f): val(v), format_spec(f) {}
+
+    template <class OutStream>
+    void sendto(OutStream& os) const
+    {
+        std::stringstream tmp;
+        format_spec.apply(tmp);
+        tmp << val;
+        os << tmp.rdbuf();
+    }
 };
 
 template <typename Value>
@@ -148,6 +181,12 @@ struct fmt_simple_proxy
                // Iostream manipulators should not be sent to the stream.
                // use fmt() with fmtc() instead.
     fmt_simple_proxy(const Value& v): val(v) {}
+
+    template <class OutStream>
+    void sendto(OutStream& os) const
+    {
+        os << val;
+    }
 };
 
 // !!! IMPORTANT !!!
@@ -199,6 +238,11 @@ inline internal::fmt_stringview fmt_rawstr(const char* dd, size_t ss)
     return internal::fmt_stringview(dd, ss);
 }
 
+inline internal::fmt_stringview fmt_rawstr(const std::string& s)
+{
+    return internal::fmt_stringview(s.data(), s.size());
+}
+
 template <class Value> inline
 internal::fmt_simple_proxy<Value> fmt(const Value& val)
 {
@@ -279,17 +323,14 @@ class ofmtstream
     template<class ValueType>
     ofmtstream& operator<<(const internal::fmt_simple_proxy<ValueType>& prox)
     {
-        buffer << prox.val;
+        prox.sendto(buffer);
         return *this;
     }
 
     template<class ValueType>
     ofmtstream& operator<<(const internal::fmt_proxy<ValueType, char>& prox)
     {
-        std::stringstream tmp;
-        prox.format_spec.apply(tmp);
-        tmp << prox.val;
-        buffer << tmp.rdbuf();
+        prox.sendto(buffer);
         return *this;
     }
 
@@ -359,6 +400,41 @@ std::string fmtcat(const Args&... args)
     return out.str();
 }
 
+#else
+
+// Provide fmtcat for C++03 for up to 4 parameters
+
+// The 1-argument version is for logical consistency.
+template <typename Arg1> inline
+std::string fmtcat(const Arg1& arg1)
+{
+    return fmts(arg1);
+}
+
+template <typename Arg1, typename Arg2> inline
+std::string fmtcat(const Arg1& arg1, const Arg2& arg2)
+{
+    ofmtstream out;
+    out << arg1 << arg2;
+    return out.str();
+}
+
+template <typename Arg1, typename Arg2, typename Arg3> inline
+std::string fmtcat(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
+{
+    ofmtstream out;
+    out << arg1 << arg2 << arg3;
+    return out.str();
+}
+
+template <typename Arg1, typename Arg2, typename Arg3, typename Arg4> inline
+std::string fmtcat(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
+{
+    ofmtstream out;
+    out << arg1 << arg2 << arg3 << arg4;
+    return out.str();
+}
+
 #endif
 
 template <class Value> inline

srtcore/queue.cpp

@@ -455,7 +455,7 @@ void srt::CSndQueue::init(CChannel* c, CTimer* t)
 
 #if ENABLE_LOGGING
     ++m_counter;
-    const std::string thrname = Sprint("SRT:SndQ:w", m_counter.load());
+    const std::string thrname = fmtcat("SRT:SndQ:w", m_counter.load());
     const char*       thname  = thrname.c_str();
 #else
     const char* thname = "SRT:SndQ";
@@ -1217,7 +1217,7 @@ void srt::CRcvQueue::init(int qsize, size_t payload, int version, int hsize, CCh
 
 #if ENABLE_LOGGING
     const int cnt = ++m_counter;
-    const std::string thrname = Sprint("SRT:RcvQ:w", cnt);
+    const std::string thrname = fmtcat("SRT:RcvQ:w", cnt);
 #else
     const std::string thrname = "SRT:RcvQ:w";
 #endif

srtcore/utilities.h

@@ -485,8 +485,8 @@ class FixedArray
 
     void throw_invalid_index(int i) const
     {
-        std::ostringstream ss;
-        ss << "Index " << i << "out of range";
+        srt::ofmtstream ss;
+        ss << OFMT_RAWSTR("Index ") << i << OFMT_RAWSTR("out of range");
         throw std::runtime_error(ss.str());
     }
 
@@ -574,23 +574,6 @@ inline auto Move(In& i) -> decltype(std::move(i)) { return std::move(i); }
 
 // Gluing string of any type, wrapper for operator <<
 
-template <class Stream>
-inline Stream& Print(Stream& in) { return in;}
-
-template <class Stream, class Arg1, class... Args>
-inline Stream& Print(Stream& sout, Arg1&& arg1, Args&&... args)
-{
-    sout << std::forward<Arg1>(arg1);
-    return Print(sout, args...);
-}
-
-template <class... Args>
-inline std::string Sprint(Args&&... args)
-{
-    srt::ofmtstream sout;
-    Print(sout, args...);
-    return sout.str();
-}
 
 // We need to use UniquePtr, in the form of C++03 it will be a #define.
 // Naturally will be used std::move() so that it can later painlessly
@@ -669,23 +652,6 @@ class UniquePtr: public std::auto_ptr<T>
     operator bool () const { return 0!= get(); }
 };
 
-// A primitive one-argument versions of Sprint and Printable
-template <class Arg1>
-inline std::string Sprint(const Arg1& arg)
-{
-    return srt::fmts(arg);
-}
-
-// Ok, let's make another version with two arguments to sweeten
-// a bit the API for C++03 users.
-template <class Arg1, class Arg2>
-inline std::string Sprint(const Arg1& arg, const Arg2& arg2)
-{
-    srt::ofmtstream out;
-    out << arg << arg2;
-    return out.str();
-}
-
 template<typename Map, typename Key>
 typename Map::mapped_type map_get(Map& m, const Key& key, typename Map::mapped_type def = typename Map::mapped_type())
 {

testing/testmedia.cpp

@@ -455,7 +455,7 @@ void SrtCommon::InitParameters(string host, string path, map<string,string> par)
             if (transmit_chunk_size > SRT_LIVE_MAX_PLSIZE)
                 throw std::runtime_error("Chunk size in live mode exceeds 1456 bytes; this is not supported");
 
-            par["payloadsize"] = Sprint(transmit_chunk_size);
+            par["payloadsize"] = fmtcat(transmit_chunk_size);
         }
     }
 
@@ -476,10 +476,10 @@ void SrtCommon::InitParameters(string host, string path, map<string,string> par)
             int version = srt::SrtParseVersion(v.c_str());
             if (version == 0)
             {
-                throw std::runtime_error(Sprint("Value for 'minversion' doesn't specify a valid version: ", v));
+                throw std::runtime_error(fmtcat("Value for 'minversion' doesn't specify a valid version: ", v));
             }
-            par["minversion"] = Sprint(version);
-            Verb() << "\tFIXED: minversion = 0x" << std::hex << std::setfill('0') << std::setw(8) << version << std::dec;
+            par["minversion"] = fmtcat(version);
+            Verb("\tFIXED: minversion = 0x", fmt(version, fmtc().hex().fillzero().width(8)));
         }
     }
 
@@ -1052,7 +1052,7 @@ void SrtCommon::OpenGroupClient()
         Verb("\t#", i, " [", c.token, "] ", c.host, ":", c.port, VerbNoEOL);
         vector<string> extras;
         if (c.weight)
-            extras.push_back(Sprint("weight=", c.weight));
+            extras.push_back(fmtcat("weight=", c.weight));
 
         if (!c.source.empty())
             extras.push_back("source=" + c.source.str());