ORIGINAL
Loading...
Searching...
No Matches
printable.h
Go to the documentation of this file.
1#ifndef PRINTABLE_H
2#define PRINTABLE_H
3#pragma once
4
5#include <memory>
6#include "format"
7#include "types.h"
8#include "sstream"
9
27namespace original {
28
39class printable {
40 mutable std::string cache_string_;
41
42public:
43 virtual ~printable() = 0;
44
56 [[nodiscard]] virtual std::string className() const;
57
68 [[nodiscard]] virtual std::string toString(bool enter) const;
69
74 explicit operator std::string() const;
75
82 explicit operator const char*() const;
83
91 [[nodiscard]] const char* toCString(bool enter) const;
92
93 // ----------------- Static Format Utilities -----------------
94
126 template<typename TYPE>
127 static std::string formatString(const TYPE& t);
128
138 template<Printable TYPE>
139 static std::string formatString(const TYPE& t);
140
150 template<EnumType TYPE>
151 static std::string formatString(const TYPE& t);
152
170 template <typename TYPE>
171 static std::string formatString(TYPE* const& ptr);
172
189 template<typename TYPE>
190 static const char* formatCString(const TYPE& t);
191
207 template<typename TYPE>
208 static std::string formatEnum(const TYPE& t);
209
210 friend std::ostream& operator<<(std::ostream& os, const printable& p);
211};
212
228std::ostream& operator<<(std::ostream& os, const printable& p);
229
230} // namespace original
231
236namespace std {
251 template<typename T>
253 std::string to_string(const T& t); // NOLINT
254
273 template<typename T>
275 struct formatter<T> { // NOLINT
276
284 static constexpr auto parse(format_parse_context& ctx);
285
295 static auto format(const T& p, format_context& ctx);
296 };
297}
298
299// ----------------- Definitions of printable.h -----------------
300
301inline original::printable::~printable() = default;
302
304{
305 return "printable";
306}
307
308inline auto original::printable::toString(const bool enter) const -> std::string
309{
310 std::stringstream ss;
311 ss << this->className() << "(" << formatString(this) << ")";
312 if (enter) ss << "\n";
313 return ss.str();
314}
315
316inline original::printable::operator std::string() const {
317 return this->toString(false);
318}
319
320inline original::printable::operator const char*() const {
321 return this->toCString(false);
322}
323
324inline auto original::printable::toCString(const bool enter) const -> const char*
325{
326 this->cache_string_ = this->toString(enter);
327 return this->cache_string_.c_str();
328}
329
330template<typename TYPE>
331auto original::printable::formatString(const TYPE& t) -> std::string
332{
333 std::stringstream ss;
334 ss << typeid(t).name() << "(" << formatString(&t) << ")";
335 return ss.str();
336}
337
338template<original::Printable TYPE>
340{
341 std::stringstream ss;
342 ss << t;
343 return ss.str();
344}
345
346template <original::EnumType TYPE>
347std::string original::printable::formatString(const TYPE& t)
348{
349 return formatEnum(t);
350}
351
352template <typename TYPE>
353auto original::printable::formatCString(const TYPE& t) -> const char*
354{
355 static auto result =
356 std::make_unique<std::string>(formatString<TYPE>(t));
357 return result->c_str();
358}
359
360template <typename TYPE>
361auto original::printable::formatEnum(const TYPE& t) -> std::string
362{
363 const std::string enum_name = typeid(t).name();
364 const int enum_value = static_cast<std::underlying_type_t<TYPE>>(t);
365 return enum_name + "(" + std::to_string(enum_value) + ")";
366}
367
368template<>
369inline auto original::printable::formatString<std::nullptr_t>(const std::nullptr_t&) -> std::string
370{
371 return "nullptr";
372}
373
374template<>
375inline auto original::printable::formatString<std::string>(const std::string& t) -> std::string
376{
377 return "\"" + t + "\"";
378}
379
380template<>
381inline auto original::printable::formatString<char>(const char& t) -> std::string
382{
383 return "'" + std::string(1, t) + "'";
384}
385
386template<>
387inline auto original::printable::formatString<bool>(const bool& t) -> std::string
388{
389 return t ? "true" : "false";
390}
391
392template <typename TYPE>
393auto original::printable::formatString(TYPE* const& ptr) -> std::string
394{
395 if (!ptr)
396 return "nullptr";
397
398 std::stringstream ss;
399 ss << "@" << ptr;
400 return ss.str();
401}
402
403template<>
404inline auto original::printable::formatString<const char>(const char* const &ptr) -> std::string {
405 return formatString<std::string>(ptr);
406}
407
408inline std::ostream& original::operator<<(std::ostream& os, const printable& p){
409 os << p.toString(false);
410 return os;
411}
412
413template<typename T>
415std::string std::to_string(const T& t)
416{
418}
419
420template<typename T>
422constexpr auto std::formatter<T>::parse(std::format_parse_context &ctx) {
423 return ctx.begin();
424}
425
426template<typename T>
428auto std::formatter<T>::format(const T &p, std::format_context &ctx) {
429 return formatter<std::string>().format(static_cast<std::string>(p), ctx);
430}
431
432#endif // PRINTABLE_H
Unique ownership smart pointer with move semantics.
Definition ownerPtr.h:37
Base class providing polymorphic string conversion capabilities.
Definition printable.h:39
const char * toCString(bool enter) const
Direct C-string access with formatting control.
Definition printable.h:324
static std::string formatString(const TYPE &t)
Universal value-to-string conversion with type-specific formatting.
Definition printable.h:339
static std::string formatString(TYPE *const &ptr)
Pointer-specific formatting with null safety.
friend std::ostream & operator<<(std::ostream &os, const printable &p)
Stream insertion operator for printable objects.
virtual std::string toString(bool enter) const
Generates formatted string representation.
Definition printable.h:308
virtual std::string className() const
Gets the class name for type identification.
Definition printable.h:303
static const char * formatCString(const TYPE &t)
C-string cache for temporary usage with static storage.
static std::string formatEnum(const TYPE &t)
Enum formatting utility with underlying value extraction.
static std::string formatString(const TYPE &t)
Specialization for types deriving from printable.
Checks derivation or type identity using std::derived_from.
Definition types.h:472
Main namespace for the project Original.
Definition algorithms.h:21
std::ostream & operator<<(std::ostream &os, const printable &p)
Stream insertion operator for printable objects.
Definition printable.h:408
Standard namespace extensions for original::alternative.
Definition allocator.h:351
std::string to_string(const T &t)
std::to_string overload for printable-derived types
Definition printable.h:415
Core type system foundations and concept definitions.