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_IO_MANIP_H
#define SQUID_SRC_BASE_IO_MANIP_H
 
#include "debug/Stream.h"
 
#include <iostream>
#include <iomanip>
 
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:
    explicit AsHex(const Integer n): io_manip(n) {}
    Integer io_manip; 
};
 
template <class Integer>
inline std::ostream &
operator <<(std::ostream &os, const AsHex<Integer> number)
{
    const auto oldFlags = os.flags();
    os << std::hex << std::showbase << number.io_manip;
    os.setf(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 &delimitedBy(const char * const d) { delimiter = d; return *this; }
 
public:
    const Container &container; 
 
    const char *prefix = nullptr; 
    const char *delimiter = nullptr; 
};
 
template <class Container>
inline std::ostream &
operator <<(std::ostream &os, const AsList<Container> &manipulator)
{
    bool opened = false;
    for (const auto &item: manipulator.container) {
        if (!opened) {
            if (manipulator.prefix)
                os << manipulator.prefix;
            opened = true;
        } else {
            if (manipulator.delimiter)
                os << manipulator.delimiter;
        }
        os << item;
    }
    return os;
}
 
template <typename Container>
inline auto asList(const Container &c) { return AsList<Container>(c); }
 
#endif /* SQUID_SRC_BASE_IO_MANIP_H */