iomanip.hpp

Go to the documentation of this file.

// ===-- include/psystem/framework/iomanip.hpp ------------ -*- C++ -*- --=== //
// Copyright (c) 2014 Matt Bisson.  All rights reserved.

#pragma once
#ifndef PSYSTEM_FRAMEWORK_IOMANIP_HPP
#define PSYSTEM_FRAMEWORK_IOMANIP_HPP

#include "platform.hpp"
#include <iostream>
#include <iomanip>

#include "stack_allocated.hpp"

namespace psystem {

namespace format {

namespace internal {

} // namespace internal
} // namespace format
} // namespace psystem

namespace psystem {
namespace format {


namespace internal {

template <typename T>
struct mask_ostream_output_tag
{
    static_assert(
        std::is_integral<T>::value,
        "Mask ostream output must be an integral type.");

    T value; 

    static void  operator delete  (void*)  = delete;
    static void  operator delete[](void*)  = delete;
    static void *operator new     (size_t) = delete;
    static void *operator new[]   (size_t) = delete;
};

} // namespace internal

template <typename T>
inline internal::mask_ostream_output_tag<T>
mask(T const m) noexcept
{
    return internal::mask_ostream_output_tag<T>{m};
}


namespace internal {

template <typename T>
struct hex_ostream_output_tag
{
    static_assert(
        std::is_integral<T>::value,
        "Hex ostream output must be an integral type.");

    T value; 

    static void  operator delete  (void*)  = delete;
    static void  operator delete[](void*)  = delete;
    static void *operator new     (size_t) = delete;
    static void *operator new[]   (size_t) = delete;
};

} // internal

template <typename T>
inline internal::hex_ostream_output_tag<T>
hex(T const v) noexcept
{
    return internal::hex_ostream_output_tag<T>{v};
}


namespace internal {

struct ptr_ostream_output_tag
{
    void const *value; 

    static void  operator delete  (void*)  = delete;
    static void  operator delete[](void*)  = delete;
    static void *operator new     (size_t) = delete;
    static void *operator new[]   (size_t) = delete;
};

}

inline internal::ptr_ostream_output_tag
ptr(void const *p) noexcept
{
    return internal::ptr_ostream_output_tag{p};
}

inline internal::ptr_ostream_output_tag
ptr(psystem::address_t const p) noexcept
{
    return internal::ptr_ostream_output_tag{reinterpret_cast<void*>(p)};
}

template <typename R, typename... Args>
inline internal::ptr_ostream_output_tag
ptr(R(*p)(Args...)) noexcept
{
    return internal::ptr_ostream_output_tag{reinterpret_cast<void*>(p)};
}


namespace internal {

struct swtch_ostream_output_tag
{
    bool value; 

    static void  operator delete  (void*)  = delete;
    static void  operator delete[](void*)  = delete;
    static void *operator new     (size_t) = delete;
    static void *operator new[]   (size_t) = delete;
};

} // namespace internal

inline internal::swtch_ostream_output_tag
swtch(bool const s) noexcept
{
    return internal::swtch_ostream_output_tag{s};
}


} // namespace format
} // namespace psystem

inline std::ostream&
operator<<(
    std::ostream& out,
    psystem::format::internal::swtch_ostream_output_tag&& v)
{
    return out << ((v.value) ? "on" : "off");
}

template <typename T>
inline std::ostream&
operator<<(
    std::ostream& out,
    psystem::format::internal::hex_ostream_output_tag<T>&& v)
{
    return out << "0x" << std::hex << v.value << std::dec;
}

template <typename T>
inline std::ostream&
operator<<(
    std::ostream& out,
    psystem::format::internal::mask_ostream_output_tag<T>&& m)
{
    return out
        << "(0x"
        << std::setfill('0') << std::setw(sizeof(T)*2) << std::hex << m.value
        << std::setfill(' ') << std::dec
        << ')';
}

inline std::ostream&
operator<<(
    std::ostream& out,
    psystem::format::internal::ptr_ostream_output_tag&& p)
{
    return out
        << "0x"
        << std::setfill('0') << std::setw(sizeof(void*)*2) << std::hex
        << reinterpret_cast<psystem::integral_address_t>(p.value)
        << std::setfill(' ') << std::dec;
}

#endif // PSYSTEM_FRAMEWORK_IOMANIP_HPP