catsep: cat arguments to string with separator

Functions
template<class Sep, class Arg, class... Args>
size_t	c4::catsep (substr buf, Sep const &sep, Arg const &a, Args const &...more)
	serialize the arguments, concatenating them to the given fixed-size buffer, using a separator between each argument.
template<class... Args>
substr	c4::catsep_sub (substr buf, Args &&...args)
	like c4::catsep() but return a substr instead of a size
template<class CharOwningContainer, class Sep, class... Args>
void	c4::catseprs (CharOwningContainer *cont, Sep const &sep, Args const &...args)
	catsep+resize: like c4::catsep(), but receives a container, and resizes it as needed to contain the result.
template<class CharOwningContainer, class Sep, class... Args>
CharOwningContainer	c4::catseprs (Sep const &sep, Args const &...args)
	catsep+resize: like c4::catsep(), but create a new container with the result.
template<class CharOwningContainer, class Sep, class... Args>
csubstr	c4::catseprs_append (CharOwningContainer *cont, Sep const &sep, Args const &...args)
	catsep+resize+append: like c4::catsep(), but receives a container, and appends the arguments, resizing the container as needed to contain the result.

Detailed Description

Function Documentation

catsep()

template<class Sep, class Arg, class... Args>

size_t c4::catsep	(	substr	buf,
		Sep const &	sep,
		Arg const &	a,
		Args const &...	more )

serialize the arguments, concatenating them to the given fixed-size buffer, using a separator between each argument.

The buffer size is strictly respected: no writes will occur beyond its end.

Returns

the number of characters needed to write all the arguments into the buffer.

See also

c4::catseprs() if instead of a fixed-size buffer, a resizeable container is desired

c4::uncatsep() for the inverse function (ie, reading instead of writing)

c4::cat() if no separator is needed

c4::format() if a format string is desired

Note

The arguments to format are restricted (legal because they are rvalues). This may require a workaround when arguments of type char[]/const char[] are passed repeatedly to the function. For example,

const char str[] = "Hi! ";
cat(buf, str, str, str); // compile error: 'passing argument 2 to ‘restrict’-qualified parameter aliases with arguments 3, 4'

It is possible to work around the problem by suppressing -Wrestrict or by using the decayed type char* or const char*, or even wrapping the argument in a csubstr():

const char str[] = "Hi! ";
csubstr ss = to_csubstr(str);
cat(buf, ss, ss, ss); // ok! compiles cleanly

Definition at line 774 of file format.hpp.

{
    size_t num = to_chars(buf, a);
    buf  = buf.len >= num ? buf.sub(num) : substr{};
    num += detail::catsep_more(buf, sep, more...);
    return num;
}

catsep_sub()

template<class... Args>

substr c4::catsep_sub	(	substr	buf,
		Args &&...	args )

like c4::catsep() but return a substr instead of a size

See also

c4::catsep(). c4::uncatsep() is the inverse of c4::catsep().

Definition at line 786 of file format.hpp.

{
    size_t sz = catsep(buf, std::forward<Args>(args)...);
    C4_CHECK(sz <= buf.len);
    return {buf.str, sz <= buf.len ? sz : buf.len};
}

catseprs() [1/2]

template<class CharOwningContainer, class Sep, class... Args>

void c4::catseprs ( CharOwningContainer * cont, Sep const & sep, Args const &... args )

inline

catsep+resize: like c4::catsep(), but receives a container, and resizes it as needed to contain the result.

The container is overwritten. To append to the container use c4::catseprs_append().

See also

c4::catsep()

c4::catseprs_append()

Note

The arguments to format are restricted (legal because they are rvalues). This may require a workaround when arguments of type char[]/const char[] are passed repeatedly to the function. For example,

const char str[] = "Hi! ";
cat(buf, str, str, str); // compile error: 'passing argument 2 to ‘restrict’-qualified parameter aliases with arguments 3, 4'

It is possible to work around the problem by suppressing -Wrestrict or by using the decayed type char* or const char*, or even wrapping the argument in a csubstr():

const char str[] = "Hi! ";
csubstr ss = to_csubstr(str);
cat(buf, ss, ss, ss); // ok! compiles cleanly

Definition at line 1152 of file format.hpp.

{
    cont->resize(cont->capacity()); // improve the odds of fitting in the original buffer
retry:
    substr buf = to_substr(*cont);
    size_t ret = catsep(buf, sep, args...);
    cont->resize(ret);
    if(ret > buf.len)
        goto retry;
}

catseprs() [2/2]

template<class CharOwningContainer, class Sep, class... Args>

CharOwningContainer c4::catseprs ( Sep const & sep, Args const &... args )

inline

catsep+resize: like c4::catsep(), but create a new container with the result.

Returns

the requested container

Note

The arguments to format are restricted (legal because they are rvalues). This may require a workaround when arguments of type char[]/const char[] are passed repeatedly to the function. For example,

const char str[] = "Hi! ";
cat(buf, str, str, str); // compile error: 'passing argument 2 to ‘restrict’-qualified parameter aliases with arguments 3, 4'

It is possible to work around the problem by suppressing -Wrestrict or by using the decayed type char* or const char*, or even wrapping the argument in a csubstr():

const char str[] = "Hi! ";
csubstr ss = to_csubstr(str);
cat(buf, ss, ss, ss); // ok! compiles cleanly

Definition at line 1187 of file format.hpp.

{
    CharOwningContainer cont;
    catseprs(&cont, sep, args...);
    return cont;
}

catseprs_append()

template<class CharOwningContainer, class Sep, class... Args>

csubstr c4::catseprs_append ( CharOwningContainer * cont, Sep const & sep, Args const &... args )

inline

catsep+resize+append: like c4::catsep(), but receives a container, and appends the arguments, resizing the container as needed to contain the result.

The buffer is appended to.

Returns

a csubstr of the appended part

Note

The arguments to format are restricted (legal because they are rvalues). This may require a workaround when arguments of type char[]/const char[] are passed repeatedly to the function. For example,

const char str[] = "Hi! ";
cat(buf, str, str, str); // compile error: 'passing argument 2 to ‘restrict’-qualified parameter aliases with arguments 3, 4'

It is possible to work around the problem by suppressing -Wrestrict or by using the decayed type char* or const char*, or even wrapping the argument in a csubstr():

const char str[] = "Hi! ";
csubstr ss = to_csubstr(str);
cat(buf, ss, ss, ss); // ok! compiles cleanly

Definition at line 1220 of file format.hpp.

{
    const size_t pos = cont->size();
    cont->resize(cont->capacity()); // improve the odds of fitting in the original buffer
retry:
    substr buf = to_substr(*cont).sub(pos);
    size_t ret = catsep(buf, sep, args...);
    cont->resize(pos + ret);
    if(ret > buf.len)
        goto retry;
    return to_csubstr(*cont).range(pos, cont->size());
}