Merge remote-tracking branch 'Kernel/master'

Kernel/include_std/streambuf

@@ -0,0 +1,312 @@
+/*
+	This file is part of Fennix Kernel.
+
+	Fennix Kernel is free software: you can redistribute it and/or
+	modify it under the terms of the GNU General Public License as
+	published by the Free Software Foundation, either version 3 of
+	the License, or (at your option) any later version.
+
+	Fennix Kernel is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <string>
+#include <locale>
+#include <ios>
+
+namespace std
+{
+	template <class CharT, class Traits = std::char_traits<CharT>>
+	class basic_streambuf
+	{
+	public:
+		typedef CharT char_type;
+		typedef Traits::char_type traits_type;
+		typedef Traits::int_type int_type;
+		typedef Traits::pos_type pos_type;
+		typedef Traits::off_type off_type;
+
+	private:
+		char_type *_eback;
+		char_type *_gptr;
+		char_type *_egptr;
+		char_type *_pbase;
+		char_type *_pptr;
+		char_type *_epptr;
+
+	public:
+		virtual ~basic_streambuf();
+
+#pragma region Locales
+
+		std::locale pubimbue(const std::locale &loc)
+		{
+			return imbue(loc);
+		}
+
+		std::locale getloc() const
+		{
+			return imbue(std::locale());
+		}
+
+#pragma endregion Locales
+
+#pragma region Positioning
+
+		basic_streambuf<CharT, Traits> *pubsetbuf(char_type *s, std::streamsize n)
+		{
+			return setbuf(s, n);
+		}
+
+		pos_type pubseekoff(off_type off, std::ios_base::seekdir dir, std::ios_base::openmode which = ios_base::in | ios_base::out)
+		{
+			return seekoff(off, dir, which);
+		}
+
+		pos_type pubseekpos(pos_type pos, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out)
+		{
+			return seekpos(pos, which);
+		}
+
+		int pubsync()
+		{
+			return sync();
+		}
+
+#pragma endregion Positioning
+
+#pragma region Get Area
+
+		std::streamsize in_avail()
+		{
+			return egptr() - gptr();
+		}
+
+		int_type snextc()
+		{
+			return gptr() == egptr() ? Traits::eof() : Traits::to_int_type(*gptr());
+		}
+
+		int_type sgetc()
+		{
+			return gptr() == egptr() ? underflow() : Traits::to_int_type(*gptr());
+		}
+
+		std::streamsize sgetn(char_type *s, std::streamsize count)
+		{
+			std::streamsize copied = 0;
+			while (copied < count)
+			{
+				if (gptr() == egptr())
+				{
+					if (underflow() == Traits::eof())
+					{
+						break;
+					}
+				}
+				*s++ = *gptr();
+				++copied;
+			}
+			return copied;
+		}
+
+#pragma endregion Get Area
+
+#pragma region Put Area
+
+		int_type sputc(char_type ch)
+		{
+			if (pptr() == epptr())
+			{
+				if (overflow(Traits::to_int_type(ch)) == Traits::eof())
+				{
+					return Traits::eof();
+				}
+			}
+			else
+			{
+				*pptr() = ch;
+				pbump(1);
+			}
+			return Traits::to_int_type(ch);
+		}
+
+		std::streamsize sputn(const char_type *s, std::streamsize count)
+		{
+			return xsputn(s, count);
+		}
+
+#pragma endregion Put Area
+
+#pragma region Putback
+
+		int_type sputbackc(char_type c)
+		{
+			if (gptr() == eback() || !Traits::eq(c, gptr()[-1]))
+			{
+				return Traits::eof();
+			}
+			gbump(-1);
+			return Traits::to_int_type(c);
+		}
+
+		int_type sungetc()
+		{
+			if (gptr() == eback())
+			{
+				return Traits::eof();
+			}
+			gbump(-1);
+			return Traits::to_int_type(*gptr());
+		}
+
+#pragma endregion Putback
+
+	protected:
+		basic_streambuf()
+			: _eback(nullptr),
+			  _gptr(nullptr),
+			  _egptr(nullptr),
+			  _pbase(nullptr),
+			  _pptr(nullptr),
+			  _epptr(nullptr)
+		{
+		}
+
+		basic_streambuf(const basic_streambuf &rhs)
+			: _eback(rhs._eback),
+			  _gptr(rhs._gptr),
+			  _egptr(rhs._egptr),
+			  _pbase(rhs._pbase),
+			  _pptr(rhs._pptr),
+			  _epptr(rhs._epptr)
+		{
+		}
+
+		basic_streambuf &operator=(const basic_streambuf &other)
+		{
+			if (this == &other)
+				return *this;
+
+			_eback = other._eback;
+			_gptr = other._gptr;
+			_egptr = other._egptr;
+			_pbase = other._pbase;
+			_pptr = other._pptr;
+			_epptr = other._epptr;
+			return *this;
+		}
+
+		void swap(basic_streambuf &other)
+		{
+			std::swap(_eback, other._eback);
+			std::swap(_gptr, other._gptr);
+			std::swap(_egptr, other._egptr);
+			std::swap(_pbase, other._pbase);
+			std::swap(_pptr, other._pptr);
+			std::swap(_epptr, other._epptr);
+		}
+
+#pragma region Locales
+
+		virtual void imbue(const std::locale &loc) = 0;
+
+#pragma endregion Locales
+
+#pragma region Positioning
+
+		virtual basic_streambuf<CharT, Traits> *setbuf(char_type *s, std::streamsize n) = 0;
+		virtual pos_type seekoff(off_type off, std::ios_base::seekdir dir, std::ios_base::openmode which = ios_base::in | ios_base::out) = 0;
+		virtual pos_type seekpos(pos_type pos, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out) = 0;
+		virtual int sync() = 0;
+
+#pragma endregion Positioning
+
+#pragma region Get Area
+
+		virtual std::streamsize showmanyc() = 0;
+		virtual int_type underflow() = 0;
+		virtual int_type uflow() = 0;
+		virtual std::streamsize xsgetn(char_type *s, std::streamsize count) = 0;
+
+		char_type *eback() const
+		{
+			return _eback;
+		}
+
+		char_type *gptr() const
+		{
+			return _gptr;
+		}
+
+		char_type *egptr() const
+		{
+			return _egptr;
+		}
+
+		void gbump(int count)
+		{
+			_gptr += count;
+		}
+
+		void setg(char_type *gbeg, char_type *gcurr, char_type *gend)
+		{
+			_eback = gbeg;
+			_gptr = gcurr;
+			_egptr = gend;
+		}
+
+#pragma endregion Get Area
+
+#pragma region Put Area
+
+		virtual std::streamsize xsputn(const char_type *s, std::streamsize count) = 0;
+		virtual int_type overflow(int_type ch = Traits::eof()) = 0;
+
+		char_type *pbase() const
+		{
+			return _pbase;
+		}
+
+		char_type *pptr() const
+		{
+			return _pptr;
+		}
+
+		char_type *epptr() const
+		{
+			return _epptr;
+		}
+
+		void pbump(int count)
+		{
+			_pptr += count;
+		}
+
+		void setp(char_type *pbeg, char_type *pend)
+		{
+			_pbase = pbeg;
+			_pptr = pbeg;
+			_epptr = pend;
+		}
+
+#pragma endregion Put Area
+
+#pragma region Putback
+
+		virtual int_type pbackfail(int_type c = Traits::eof()) = 0;
+
+#pragma endregion Putback
+	};
+
+	typedef basic_streambuf<char> streambuf;
+	typedef basic_streambuf<wchar_t> wstreambuf;
+}