stringify.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
/* -*-c++-*- */
 
#ifndef LIB_STRINGIFY_H_
#define LIB_STRINGIFY_H_
 
#include <cstdarg>
#include <string>
#include <string_view>
#include <type_traits>
 
// FIXME: Replace with big_int_fwd.h with Boost 1.84+
#include "big_int.h"
#include "cstring.h"
 
namespace P4 {
 
class IHasDbPrint {
 public:
    virtual void dbprint(std::ostream &out) const = 0;
    void print() const;  // useful in the debugger
    virtual ~IHasDbPrint() = default;
};
 
inline std::ostream &operator<<(std::ostream &out, const IHasDbPrint &obj) {
    obj.dbprint(out);
    return out;
}
 
inline std::ostream &operator<<(std::ostream &out, const IHasDbPrint *obj) {
    if (obj)
        obj->dbprint(out);
    else
        out << "<null>";
    return out;
}

template <class, class = void>
struct has_dbprint : std::false_type {};
 
template <class T>
struct has_dbprint<T,
                   std::void_t<decltype(std::declval<T>().dbprint(std::declval<std::ostream &>()))>>
    : std::true_type {};
 
template <class T>
inline constexpr bool has_dbprint_v = has_dbprint<T>::value;
 
template <class, class = void>
struct has_ostream_operator : std::false_type {};
 
template <class T>
struct has_ostream_operator<
    T, std::void_t<decltype(std::declval<std::ostream &>() << std::declval<T>())>>
    : std::true_type {};
 
template <class T>
inline constexpr bool has_ostream_operator_v = has_ostream_operator<T>::value;
 
// convert values to cstrings
namespace Util {

template <class, class = void>
struct has_toString : std::false_type {};
 
template <class T>
struct has_toString<T, std::void_t<decltype(std::declval<T>().toString())>> : std::true_type {};
 
template <class T>
inline constexpr bool has_toString_v = has_toString<T>::value;
 
template <typename T, typename = decltype(std::to_string(std::declval<T>()))>
cstring toString(T value) {
    return cstring(std::to_string(value));
}
 
template <typename T>
auto toString(const T &value) -> typename std::enable_if_t<has_toString_v<T>, cstring> {
    return value.toString();
}
 
template <typename T>
auto toString(T &value) -> typename std::enable_if_t<has_toString_v<T>, cstring> {
    return value.toString();
}
 
template <typename T>
auto toString(const T *value) -> typename std::enable_if_t<has_toString_v<T>, cstring> {
    return value->toString();
}
 
template <typename T>
auto toString(T *value) -> typename std::enable_if_t<has_toString_v<T>, cstring> {
    return value->toString();
}
 
cstring toString(bool value);
cstring toString(const std::string &value);
cstring toString(const char *value);
cstring toString(cstring value);
cstring toString(std::string_view value);
cstring toString(const big_int &value, unsigned width, bool sign, unsigned int base = 10);
cstring toString(const void *value);
 
char DigitToChar(int digit);
 
}  // namespace Util
}  // namespace P4
 
#endif /* LIB_STRINGIFY_H_ */