IoManip.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
#ifndef SQUID_SRC_BASE_IOMANIP_H
#define SQUID_SRC_BASE_IOMANIP_H
 
#include "debug/Stream.h"
 
#include <iostream>
#include <iomanip>
#include <optional>
 
 
template <class Pointer>
class RawPointerT {
public:
    RawPointerT(const char *aLabel, const Pointer &aPtr):
        label(aLabel), ptr(aPtr) {}
 
    RawPointerT<Pointer> &asExtra() { onExtraLine = true; return *this; }
 
    RawPointerT<Pointer> &orNil(const char *nilTextToUse = "[nil]") { nilText = nilTextToUse; return *this; }
 
    const char *label; 
 
    const char *nilText = nullptr;
 
    const Pointer &ptr; 
    bool onExtraLine = false;
};
 
template <class Pointer>
inline RawPointerT<Pointer>
RawPointer(const char *label, const Pointer &ptr)
{
    return RawPointerT<Pointer>(label, ptr);
}
 
template <class Pointer>
inline RawPointerT<Pointer>
RawPointer(const Pointer &ptr)
{
    return RawPointerT<Pointer>(nullptr, ptr);
}
 
template <class Pointer>
inline std::ostream &
operator <<(std::ostream &os, const RawPointerT<Pointer> &pd)
{
    if (!pd.ptr) {
        if (pd.nilText)
            os << pd.nilText;
        return os;
    }
 
    if (pd.onExtraLine)
        os << Debug::Extra;
 
    if (pd.label)
        os << pd.label;
 
    os << *pd.ptr;
 
    return os;
}
 
template <class Integer>
class AsHex
{
public:
    // Without this assertion, asHex(pointer) and AsHex(3.14) compile, but their
    // caller is likely confused about the actual argument type and expects
    // different output. Enum values are not integral types but arguably do not
    // cause similar problems.
    static_assert(std::is_integral<Integer>::value || std::is_enum<Integer>::value);
 
    explicit AsHex(const Integer n): io_manip(n) {}
 
    auto &minDigits(const size_t w) { forcePadding = w; return *this; }
 
    auto &upperCase(const bool u = true) { forceCase = u; return *this; }
 
    Integer io_manip; 
 
    std::optional<size_t> forcePadding;
 
    std::optional<bool> forceCase;
};
 
template <class Integer>
inline std::ostream &
operator <<(std::ostream &os, const AsHex<Integer> number)
{
    const auto oldFlags = os.flags();
    const auto oldFill = os.fill();
 
    if (number.forceCase)
        os << (*number.forceCase ? std::uppercase : std::nouppercase);
 
    if (number.forcePadding) {
        os.width(*number.forcePadding);
        os.fill('0');
    }
 
    // When Integer is smaller than int, the unary plus converts the stored
    // value into an equivalent integer because C++ "arithmetic operators do not
    // accept types smaller than int as arguments, and integral promotions are
    // automatically applied". For larger integer types, plus is a no-op.
    os << std::hex << +number.io_manip;
 
    os.fill(oldFill);
    os.flags(oldFlags);
    return os;
}
 
template <class Integer>
inline AsHex<Integer> asHex(const Integer n) { return AsHex<Integer>(n); }
 
void PrintHex(std::ostream &, const char *data, size_t n);
 
template <typename Container>
class AsList
{
public:
    explicit AsList(const Container &c): container(c) {}
 
    auto &prefixedBy(const char * const p) { prefix = p; return *this; }
 
    auto &suffixedBy(const char * const p) { suffix = p; return *this; }
 
    auto &delimitedBy(const char * const d) { delimiter = d; return *this; }
 
    auto &quoted(const char * const q = "\"") { preQuote = postQuote = q; return *this; }
 
    auto &quoted(const char * const preQ, const char * const postQ) { preQuote = preQ; postQuote = postQ; return *this; }
 
    void print(std::ostream &) const;
 
public:
    const Container &container; 
 
    const char *prefix = nullptr; 
    const char *suffix = nullptr; 
    const char *delimiter = nullptr; 
    const char *preQuote = nullptr; 
    const char *postQuote = nullptr; 
};
 
template <typename Container>
void
AsList<Container>::print(std::ostream &os) const
{
    bool opened = false;
 
    for (const auto &item: container) {
        if (!opened) {
            if (prefix)
                os << prefix;
            opened = true;
        } else {
            if (delimiter)
                os << delimiter;
        }
 
        if (preQuote)
            os << preQuote;
        os << item;
        if (postQuote)
            os << postQuote;
    }
 
    if (opened && suffix)
        os << suffix;
}
 
template <typename Container>
inline std::ostream &
operator <<(std::ostream &os, const AsList<Container> &manipulator)
{
    manipulator.print(os);
    return os;
}
 
template <typename Container>
inline auto asList(const Container &c) { return AsList<Container>(c); }
 
template <class T>
class AtMostOnce
{
public:
    explicit AtMostOnce(const T &t): toPrint(t) {}
 
    void print(std::ostream &os) {
        if (!printed) {
            os << toPrint;
            printed = true;
        }
    }
 
private:
    const T &toPrint;
    bool printed = false;
};
 
template <class T>
inline auto &
operator <<(std::ostream &os, AtMostOnce<T> &a) {
    a.print(os);
    return os;
}
 
template <class T>
class WithExtras
{
public:
    explicit WithExtras(const T &t): toPrint(t) {}
    const T &toPrint;
};
 
template <class T>
inline auto &
operator <<(std::ostream &os, const WithExtras<T> &a) {
    a.toPrint.printWithExtras(os);
    return os;
}
 
#endif /* SQUID_SRC_BASE_IOMANIP_H */