Base class providing polymorphic string conversion capabilities. More...

#include <printable.h>

Collaboration diagram for original::printable:

Public Member Functions
virtual std::string	className () const
	Gets the class name for type identification.

virtual std::string	toString (bool enter) const
	Generates formatted string representation.

	operator std::string () const
	Explicit conversion to std::string.

	operator const char * () const
	Explicit conversion to C-style string.

const char *	toCString (bool enter) const
	Direct C-string access with formatting control.

template<typename TYPE >
auto	formatString (const TYPE &t) -> std::string

template<typename TYPE >
auto	formatCString (const TYPE &t) -> const char *

template<typename TYPE >
auto	formatEnum (const TYPE &t) -> std::string

template<typename TYPE >
auto	formatString (TYPE *const &ptr) -> std::string

Static Public Member Functions
template<typename TYPE >
static std::string	formatString (const TYPE &t)
	Universal value-to-string conversion with type-specific formatting.

template<Printable TYPE>
static std::string	formatString (const TYPE &t)
	Specialization for types deriving from printable.

template<EnumType TYPE>
static std::string	formatString (const TYPE &t)
	Specialization for enum types with type-safe formatting.

template<typename TYPE >
static std::string	formatString (TYPE *const &ptr)
	Pointer-specific formatting with null safety.

template<typename TYPE >
static const char *	formatCString (const TYPE &t)
	C-string cache for temporary usage with static storage.

template<typename TYPE >
static std::string	formatEnum (const TYPE &t)
	Enum formatting utility with underlying value extraction.

template<>
auto	formatString (const char &t) -> std::string

template<>
auto	formatString (const bool &t) -> std::string

template<>
auto	formatString (const char *const &ptr) -> std::string

Friends
std::ostream &	operator<< (std::ostream &os, const printable &p)
	Stream insertion operator for printable objects.

Detailed Description

Base class providing polymorphic string conversion capabilities.

Inherit from this class to enable automatic string representation for output streams, C-style string access, and std::format support. Provides extensible formatting through template specializations.

Note: All derived classes automatically gain string conversion capabilities and can be used with std::cout, std::format, and other output mechanisms.

Member Function Documentation

◆ className()

auto original::printable::className ( ) const

inlinevirtual

Gets the class name for type identification.

Returns: Class name as string.

Override in derived classes to provide accurate type names.

class MyClass : public printable {
    std::string className() const override { return "MyClass"; }
};

◆ formatCString()

template<typename TYPE >

static const char * original::printable::formatCString ( const TYPE & t )

static

C-string cache for temporary usage with static storage.

Template Parameters

TYPE	Input type

Parameters

t	Value to format

Returns: Static C-string buffer containing formatted result

Warning: Not thread-safe due to static buffer - avoid in multi-threaded contexts

Note: The returned pointer points to static storage that will be overwritten on subsequent calls. For thread-safe usage or persistent strings, use formatString() and store the result.

// Single-threaded usage only:
const char* str = printable::formatCString(42);
printf("%s\n", str);  // Safe if no concurrent calls

◆ formatEnum()

template<typename TYPE >

static std::string original::printable::formatEnum ( const TYPE & t )

static

Enum formatting utility with underlying value extraction.

Template Parameters

TYPE Enum type

Parameters

t	Enum value

Returns: String in "EnumName(value)" format

Formats enum values by combining the type name from typeid with the underlying integer value. Provides consistent enum representation across the codebase.

enum Color { Red = 1, Green = 2 };
printable::formatEnum(Color::Red);  // "Color(1)"
printable::formatEnum(Color::Green); // "Color(2)"

◆ formatString() [1/4]

template<original::EnumType TYPE>

std::string original::printable::formatString ( const TYPE & t )

static

Universal value-to-string conversion with type-specific formatting.

Template Parameters

TYPE	Input value type

Parameters

t	Value to format

Returns: Formatted string with type-specific handling

Automatically dispatches to appropriate formatting based on type:

Printable types: Uses operator<< or toString()
Enum types: Formats as "EnumName(value)" via formatEnum
String types: Wraps in quotes
Character types: Wraps in single quotes
Pointer types: Formats as hex address with @ prefix
Boolean types: Formats as "true"/"false"
nullptr_t: Formats as "nullptr"
Other types: Uses typeid and address formatting

The function uses template specialization and concept constraints to select the appropriate formatting strategy at compile time.

Example outputs:

printable::formatString(42);              // "42"
printable::formatString("hello");         // "\"hello\""
printable::formatString('A');             // "'A'"
printable::formatString(true);            // "true"
printable::formatString(nullptr);         // "nullptr"
printable::formatString((void*)0x1234);  // "@0x1234"
 
enum Color { Red, Green };
printable::formatString(Color::Red);     // "Color(0)"

◆ formatString() [2/4]

template<Printable TYPE>

static std::string original::printable::formatString ( const TYPE & t )

static

Specialization for types deriving from printable.

Template Parameters

TYPE	Printable-derived type (constrained by Printable concept)

Parameters

t	Printable object to format

Returns: String representation using the object's toString() method

Uses the printable object's streaming operator or toString() method to generate the string representation. This ensures consistent formatting across all printable-derived types.

◆ formatString() [3/4]

template<EnumType TYPE>

static std::string original::printable::formatString ( const TYPE & t )

static

Specialization for enum types with type-safe formatting.

Template Parameters

TYPE	Enum type (constrained by EnumType concept)

Parameters

t	Enum value to format

Returns: String in "EnumName(value)" format

Extracts the underlying integer value and combines it with the type name for readable enum representation. Uses std::underlying_type_t for safe value extraction.

◆ formatString() [4/4]

template<typename TYPE >

static std::string original::printable::formatString ( TYPE *const & ptr )

static

Pointer-specific formatting with null safety.

Template Parameters

TYPE	Pointer type

Parameters

ptr	Pointer to format

Returns: String with hex address prefixed by @, or "nullptr" for null

Safely handles null pointers by returning "nullptr" and formats valid pointers as hexadecimal addresses with @ prefix for easy identification.

int* p = nullptr;
printable::formatString(p);          // "nullptr"
 
int x = 42;
printable::formatString(&x);         // "@0x7ffeeb4a4c5c"

◆ operator const char *()

original::printable::operator const char * ( ) const

inlineexplicit

Explicit conversion to C-style string.

Returns: Null-terminated C-string (lifetime tied to object).

Note: The returned pointer is valid until the next call to toCString() or destruction of the object.

◆ operator std::string()

original::printable::operator std::string ( ) const

inlineexplicit

Explicit conversion to std::string.

Returns: String representation without newline.

◆ toCString()

auto original::printable::toCString ( bool enter ) const

inline

Direct C-string access with formatting control.

Parameters

enter Append newline if true.

Returns: Managed C-string buffer.

Note: The returned pointer is valid until the next call to toCString() or destruction of the object.

◆ toString()

auto original::printable::toString ( bool enter ) const

inlinevirtual

Generates formatted string representation.

Parameters

enter Whether to append newline.

Returns: Formatted string in "ClassName(data)" format.

MyClass obj;

std::cout << obj.toString(true); // Outputs "printable(@0x7ffd) \n"

original::autoPtr::toString

std::string toString(bool enter) const override

String representation formatter.

Definition autoPtr.h:724

Friends And Related Symbol Documentation

◆ operator<<

std::ostream & operator<<	(	std::ostream &	os,
		const printable &	p
	)

friend

Stream insertion operator for printable objects.

Parameters

os	Output stream
p	Printable object

Returns: Modified output stream

Enables direct streaming of printable objects to output streams. Uses the object's toString(false) method to generate the output without trailing newline.

MyClass obj;
std::cout << obj;                    // Outputs "MyClass(custom_data)"
std::cout << obj << std::endl;       // Adds newline separately

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

src/core/printable.h

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Member Function Documentation

◆ className()

◆ formatCString()

◆ formatEnum()

◆ formatString() [1/4]

◆ formatString() [2/4]

◆ formatString() [3/4]

◆ formatString() [4/4]

◆ operator const char *()

◆ operator std::string()

◆ toCString()

◆ toString()

Friends And Related Symbol Documentation

◆ operator<<