BS 0.0.1

Convention/[Runtime]/Config.hpp

@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 #ifndef Convention_Runtime_Config_hpp
 #define Convention_Runtime_Config_hpp
 #pragma warning(disable : 4267)
@@ -1733,7 +1733,7 @@ namespace Convention
 			elements = std::forward<Arg>(value);
 		}
 		template<size_t index, typename Arg,
-			std::enable_if_t<std::is_convertible_v<const Arg&, Element>>, size_t> = 0 >
+			std::enable_if_t<std::is_convertible_v<const Arg&, Element>, size_t> = 0 >
 			void SetValue(const Arg & value) noexcept
 		{
 			static_assert(index == 0, "Index out of bounds for ElementTuple.");

Convention/[Runtime]/Generics/NTree.hpp

@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 #ifndef Convention_Runtime_Generics_NTree_hpp
 #define Convention_Runtime_Generics_NTree_hpp
 

Convention/[Runtime]/Generics/Sequence.hpp

@@ -9,13 +9,172 @@ namespace Convention
 	namespace Generics
 	{
 
+		class IIterator
+		{
+		public:
+
+		};
+
+		template<typename>
+		class ISequence
+		{
+		public:
+			virtual ~ISequence() {}
+			virtual IIterator begin() abstract;
+			virtual IIterator end() abstract;
+		};
+
+		/**
+		* @brief 序列容器枚举
+		* @tparam Sequence 序列类型
+		* @tparam _Index 索引类型
+		* @version BS 0.0.1
+		*/
+		template<typename Sequence, typename _Index = int>
+		class SequenceIterator
+		{
+		private:
+			const Sequence& target;
+			_Index index;
+		public:
+			SequenceIterator(const Sequence& target, _Index index) :__init(target), __init(index) {}
+			SequenceIterator(const SequenceIterator& other) : target(other.target), index(other.index) {}
+			SequenceIterator& operator=(const SequenceIterator& other)
+			{
+				target = other.target;
+				index = other.index;
+				return *this;
+			}
+			bool operator==(const SequenceIterator& other) noexcept
+			{
+				return other.index == index;
+			}
+			bool operator!=(const SequenceIterator& other) noexcept
+			{
+				return other.index != index;
+			}
+			SequenceIterator& operator++() noexcept
+			{
+				++index;
+				return *this;
+			}
+			SequenceIterator operator++(int) noexcept
+			{
+				++index;
+				return SequenceIterator(target, index - 1);
+			}
+			SequenceIterator& operator--() noexcept
+			{
+				--index;
+				return *this;
+			}
+			SequenceIterator operator--(int) noexcept
+			{
+				--index;
+				return SequenceIterator(target, index + 1);
+			}
+		};
+
+		/**
+		* @brief 序列容器可枚举类型
+		* @tparam Sequence 序列类型
+		* @tparam _Index 索引类型
+		* @version BS 0.0.1
+		*/
+		template<typename Sequence, typename _Index = int>
+		struct SequenceRange
+		{
+			using iterator = SequenceIterator<Sequence, _Index>;
+			iterator mbegin, mend;
+			SequenceRange(const Sequence& target, _Index begin = 0, _Index end = 0ll - 1) :mbegin(target, begin), mend(target, end) {}
+
+			constexpr iterator begin()
+			{
+				return mbegin;
+			}
+			constexpr iterator end()
+			{
+				return mend;
+			}
+		};
+
+
+		/**
+		* @brief 栈上静态数组
+		* @tparam Element 内容物类型
+		* @tparam size 元素大小
+		* @version BS 0.0.1
+		*/
 		template<typename Element, size_t size>
 		using Array = std::array<Element, size>;
 
+		/**
+		* @brief 栈上静态Bool数组
+		* @tparam size 元素大小
+		* @version BS 0.0.1
+		*/
+		template<size_t capacity>
+		class BoolArray
+			: private Array<
+			std::conditional_t<PlatformIndicator::IsPlatformx64, int64_t, int32_t>,
+			capacity / sizeof(std::conditional_t<PlatformIndicator::IsPlatformx64, int64_t, int32_t>) + (capacity % sizeof(std::conditional_t<PlatformIndicator::IsPlatformx64, int64_t, int32_t>) ? 1 : 0)
+			>
+		{
+		private:
+			constexpr static const char* out_of_range_message = "out of range, capacity: ";
+			using _MyElementTy = std::conditional_t<PlatformIndicator::IsPlatformx64, int64_t, int32_t>;
+			constexpr static size_t _MyCapacity = capacity / sizeof(_MyElementTy) + (capacity % sizeof(_MyElementTy) ? 1 : 0);
+			using _Mybase = Array<_MyElementTy, _MyCapacity>;
+			constexpr _Mybase& _GetBaseArray() noexcept
+			{
+				return *this;
+			}
+			constexpr const _Mybase& _GetBaseArray() const noexcept
+			{
+				return *this;
+			}
+		public:
+			inline constexpr size_t size() const noexcept
+			{
+				return capacity;
+			}
+			int ReadValue(size_t index) const
+			{
+				if (index < capacity)
+				{
+					size_t i = index / sizeof(_MyElementTy), offset = index % sizeof(_MyElementTy);
+					return _GetBaseArray()[i] & (1ll << offset);
+				}
+				throw std::out_of_range(StringIndicator::Combine<std::string>(out_of_range_message, capacity));
+			}
+			bool operator[](int index) const
+			{
+				return ReadValue(index < 0 ? capacity + index : index);
+			}
+			void WriteValue(size_t index, bool value)
+			{
+				if (index < capacity)
+				{
+					size_t i = index / sizeof(_MyElementTy), offset = index % sizeof(_MyElementTy);
+					if (value)
+						_GetBaseArray()[i] |= 1ll << offset;
+					else
+						_GetBaseArray()[i] &= ~(1ll << offset);
+				}
+				throw std::out_of_range(StringIndicator::Combine<std::string>(out_of_range_message, capacity));
+			}
+		};
+
+		/**
+		* @brief 堆上动态数组
+		* @tparam Element 内容物类型
+		* @tparam Allocator 内存分配器
+		* @version BS 0.0.1
+		*/
 		template<typename Element, template<typename> class Allocator>
 		using Vector = std::vector<Element, Allocator<Element>>;
 
 	}
 }
 
-#endif Convention_Runtime_Generics_Sequence_hpp
+#endif Convention_Runtime_Generics_Sequence_hpp

Convention/[Runtime]/Generics/Stack.hpp

@@ -0,0 +1,20 @@
+#pragma once
+#ifndef Convention_Runtime_Generics_Sequence_hpp
+#define Convention_Runtime_Generics_Sequence_hpp
+
+#include"Generics/Sequence.hpp"
+
+namespace Convention
+{
+	namespace Generics
+	{
+
+		class Stack
+		{
+
+		};
+
+	}
+}
+
+#endif Convention_Runtime_Generics_Sequence_hpp