iomanip.h

Go to the documentation of this file.

//   Copyright 2016-2021 Jean-Francois Poilpret
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
 
 
#ifndef IOMANIP_H
#define IOMANIP_H
 
#include <ctype.h>
#include <stddef.h>
#include "ios.h"
 
namespace streams
{
    class setw_
    {
    public:
        template<typename FSTREAM> void operator()(FSTREAM& stream) const
        {
            stream.width(width_);
        }
 
    private:
        explicit constexpr setw_(uint8_t width) : width_{width} {}
        const uint8_t width_;
        friend constexpr const setw_ setw(uint8_t width);
    };
    template<typename FSTREAM> FSTREAM& operator<<(FSTREAM& stream, const setw_ f)
    {
        f(stream);
        return stream;
    }
    template<typename FSTREAM> FSTREAM& operator>>(FSTREAM& stream, const setw_ f)
    {
        f(stream);
        return stream;
    }
 
    class setprecision_
    {
    public:
        template<typename FSTREAM> void operator()(FSTREAM& stream) const
        {
            stream.precision(precision_);
        }
 
    private:
        explicit constexpr setprecision_(uint8_t precision) : precision_{precision} {}
        const uint8_t precision_;
        friend constexpr const setprecision_ setprecision(uint8_t precision);
    };
    template<typename FSTREAM> FSTREAM& operator<<(FSTREAM& stream, const setprecision_ f)
    {
        f(stream);
        return stream;
    }
    template<typename FSTREAM> FSTREAM& operator>>(FSTREAM& stream, const setprecision_ f)
    {
        f(stream);
        return stream;
    }
 
    class setfill_
    {
    public:
        template<typename FSTREAM> void operator()(FSTREAM& stream) const
        {
            stream.fill(fill_);
        }
 
    private:
        explicit constexpr setfill_(char fill) : fill_{fill} {}
        const char fill_;
        friend constexpr const setfill_ setfill(char fill);
    };
    template<typename FSTREAM> FSTREAM& operator<<(FSTREAM& stream, const setfill_ f)
    {
        f(stream);
        return stream;
    }
    template<typename FSTREAM> FSTREAM& operator>>(FSTREAM& stream, const setfill_ f)
    {
        f(stream);
        return stream;
    }
 
    class setbase_
    {
    public:
        template<typename FSTREAM> void operator()(FSTREAM& stream) const
        {
            stream.setf(base_, ios::basefield);
        }
 
    private:
        static constexpr ios::fmtflags convert_base(int base)
        {
            if (base == 2) return ios::bin; 
            if (base == 8) return ios::oct; 
            if (base == 16) return ios::hex;
            return ios::dec; 
        }
        explicit constexpr setbase_(int base) : base_{convert_base(base)} {}
        const ios::fmtflags base_;
        friend constexpr const setbase_ setbase(int base);
    };
    template<typename FSTREAM> FSTREAM& operator<<(FSTREAM& stream, const setbase_ f)
    {
        f(stream);
        return stream;
    }
    template<typename FSTREAM> FSTREAM& operator>>(FSTREAM& stream, const setbase_ f)
    {
        f(stream);
        return stream;
    }
 
    class setiosflags_
    {
    public:
        template<typename FSTREAM> void operator()(FSTREAM& stream) const
        {
            stream.setf(mask_);
        }
 
    private:
        explicit constexpr setiosflags_(ios::fmtflags mask) : mask_{mask} {}
        const ios::fmtflags mask_;
        friend constexpr const setiosflags_ setiosflags(ios::fmtflags mask);
    };
    template<typename FSTREAM> FSTREAM& operator<<(FSTREAM& stream, const setiosflags_ f)
    {
        f(stream);
        return stream;
    }
    template<typename FSTREAM> FSTREAM& operator>>(FSTREAM& stream, const setiosflags_ f)
    {
        f(stream);
        return stream;
    }
 
    class resetiosflags_
    {
    public:
        template<typename FSTREAM> void operator()(FSTREAM& stream) const
        {
            stream.unsetf(mask_);
        }
 
    private:
        explicit constexpr resetiosflags_(ios::fmtflags mask) : mask_{mask} {}
        const ios::fmtflags mask_;
        friend constexpr const resetiosflags_ resetiosflags(ios::fmtflags mask);
    };
    template<typename FSTREAM> FSTREAM& operator<<(FSTREAM& stream, const resetiosflags_ f)
    {
        f(stream);
        return stream;
    }
    template<typename FSTREAM> FSTREAM& operator>>(FSTREAM& stream, const resetiosflags_ f)
    {
        f(stream);
        return stream;
    }
 
    constexpr const setw_ setw(uint8_t width)
    {
        return setw_{width};
    }
 
    constexpr const setprecision_ setprecision(uint8_t precision)
    {
        return setprecision_{precision};
    }
 
    constexpr const setbase_ setbase(int base)
    {
        return setbase_{base};
    }
 
    constexpr const setfill_ setfill(char fill)
    {
        return setfill_{fill};
    }
 
    constexpr const setiosflags_ setiosflags(ios::fmtflags mask)
    {
        return setiosflags_{mask};
    }
 
    constexpr const resetiosflags_ resetiosflags(ios::fmtflags mask)
    {
        return resetiosflags_{mask};
    }
}
 
#endif /* IOMANIP_H */