Kernel/include_std/locale

/*
	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 <cstddef>
#include <cassert>
#include <string>

namespace std
{
	class locale
	{
	public:
#pragma region Member Types

		class id
		{
		public:
			id() = default;
			id(const id &) = delete;
		};

		class facet
		{
		private:
			std::size_t refs;

		public:
			explicit facet(std::size_t refs = 0)
			{
				this->refs = refs;
			}

			facet(const facet &) = delete;

		protected:
			virtual ~facet() = default;
		};

		typedef int category;

#pragma endregion Member Types

#pragma region Member Objects

		static const category none = 0;
		static const category collate = 1;
		static const category ctype = 2;
		static const category monetary = 4;
		static const category numeric = 8;
		static const category time = 16;
		static const category messages = 32;
		static const category all = collate | ctype | monetary | numeric | time | messages;

#pragma endregion Member Objects

#pragma region Member Functions

		locale() noexcept
		{
			assert(!"Function not implemented");
		}

		locale(const locale &other) noexcept
		{
			assert(!"Function not implemented");
		}

		explicit locale(const char *std_name)
		{
			assert(!"Function not implemented");
		}

		explicit locale(const std::string &std_name)
		{
			assert(!"Function not implemented");
		}

		locale(const locale &other, const char *std_name, category cats)
		{
			assert(!"Function not implemented");
		}

		locale(const locale &other, const std::string &std_name, category cats)
		{
			assert(!"Function not implemented");
		}

		template <class Facet>
		locale(const locale &other, Facet *f)
		{
			assert(!"Function not implemented");
		}

		locale(const locale &other, const locale &one, category cats)
		{
			assert(!"Function not implemented");
		}

		~locale()
		{
			assert(!"Function not implemented");
		}

		const locale &operator=(const locale &other) noexcept
		{
			assert(!"Function not implemented");
		}

		template <class Facet>
		locale combine(const locale &other) const
		{
			assert(!"Function not implemented");
		}

		std::string name() const
		{
			assert(!"Function not implemented");
		}

		bool operator==(const locale &other) const
		{
			assert(!"Function not implemented");
		}

		template <class CharT, class Traits, class Alloc>
		bool operator()(const basic_string<CharT, Traits, Alloc> &s1, const basic_string<CharT, Traits, Alloc> &s2) const
		{
			assert(!"Function not implemented");
		}

		static locale global(const locale &loc)
		{
			assert(!"Function not implemented");
		}

		static const locale &classic()
		{
			assert(!"Function not implemented");
		}

#pragma endregion Member Functions
	};
}