mtcore::Padded< T > Struct Template Reference

Formats data with padding into a writer's output stream Uses Formatter<T> under the hood Usually will use extract_padding_options to get padding options. More...

#include <formats.hpp>

Static Public Member Functions
template<WriterImpl WI>
static Result< size_t, typename Writer< WI >::ErrType >	write_padded (Writer< WI > &writer, const PaddingOptions &padOpts, const FormatOptions &opts, const T &elem)

Detailed Description

template<typename T>
struct mtcore::Padded< T >

Formats data with padding into a writer's output stream Uses Formatter<T> under the hood Usually will use extract_padding_options to get padding options.

See also

extract_padding_options

Template Parameters

T	Type of data to pad

Definition at line 153 of file formats.hpp.

Member Function Documentation

write_padded()

template<typename T>

template<WriterImpl WI>

Result< size_t, typename Writer< WI >::ErrType > mtcore::Padded< T >::write_padded ( Writer< WI > & writer, const PaddingOptions & padOpts, const FormatOptions & opts, const T & elem )

static

Definition at line 791 of file formats.hpp.

                                                                                                                     {
    // Do a dry run to get what the ending length will be
    // Doing a dry run since we're so disconnected from the logic
    // that we can't accurately tell the final length without "printing"
    auto dryRunWriter = void_writer<typename Writer<WI>::WriteElem>();
    auto sizeRes      = Formatter<T>::fmt(dryRunWriter, opts, elem);
    ensure(sizeRes.is_success());
    size_t len = sizeRes.value();
 
    // If we don't need to pad, just write it directly
    if (len >= padOpts.padLen) {
      return Formatter<T>::fmt(writer, opts, elem);
    }
 
    switch (padOpts.alignment) {
      case ContentAlignment::LEFT: {
        auto padRes = writer.write_n_times(padOpts.pad, padOpts.padLen - len);
        if (padRes.is_error()) {
          return padRes.error();
        }
        return Formatter<T>::fmt(writer, opts, elem).with_success_val(padOpts.padLen);
      }
      case ContentAlignment::RIGHT: {
        auto contentRes = Formatter<T>::fmt(writer, opts, elem);
        if (contentRes.is_error()) {
          return contentRes.error();
        }
        return writer.write_n_times(padOpts.pad, padOpts.padLen - len).with_success_val(padOpts.padLen);
      }
      case ContentAlignment::CENTER: {
        auto leftPad  = (padOpts.padLen - len) / 2;
        auto rightPad = leftPad;
 
        // If we have to be lopsided, put the extra padding on the right
        if (leftPad + rightPad + len != padOpts.padLen) {
          ++rightPad;
        }
        auto padLeftRes = writer.write_n_times(padOpts.pad, leftPad);
        if (padLeftRes.is_error()) {
          return padLeftRes.error();
        }
        auto contentRes = Formatter<T>::fmt(writer, opts, elem);
        if (contentRes.is_error()) {
          return contentRes.error();
        }
        return writer.write_n_times(padOpts.pad, rightPad).with_success_val(padOpts.padLen);
      }
      default:
        unreachable();
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this struct was generated from the following file:

• formats.hpp