Update project to be able to build.

saffronjam · saffronjam · commit 2a9b144cc577 · 2022-03-07T17:22:18.000+01:00
Fix gitignore to build exe demo
diff --git a/Source/Algorithm.cpp b/Source/Algorithm.cpp
@@ -6,13 +6,13 @@ namespace Se
 {
 struct ContainerRefGroup
 {
-	List<Element>& elements;
-	List<Element>& elementsRestart;
-	List<Element>& elementsReset;
+	std::vector<Element>& elements;
+	std::vector<Element>& elementsRestart;
+	std::vector<Element>& elementsReset;
 };
 
-Algorithm::Algorithm(String name) :
-	_name(Move(name)),
+Algorithm::Algorithm(std::string name) :
+	_name(std::move(name)),
 	_sleepDelay(sf::seconds(0.01f)),
 	_minorDelay(false),
 	_minorDelayTimer(0),
@@ -144,7 +144,7 @@ void Algorithm::Start()
 	{
 		CollectSorter();
 		_state = State::Sorting;
-		_sorter = Thread([this]
+		_sorter = std::thread([this]
 		{
 			SortThreadFn();
 		});
@@ -230,7 +230,7 @@ void Algorithm::SoftResize(size_t size)
 	_numberLineVA.resize(size * 4);
 }
 
-void Algorithm::SetImage(const String& filepath)
+void Algorithm::SetImage(const std::string& filepath)
 {
 	Reset();
 	_image = ImageStore::Get(filepath);
@@ -244,7 +244,7 @@ void Algorithm::Shuffle(Random::Engine generator)
 	_elements = _elementsRestart;
 }
 
-auto Algorithm::Name() const -> const String& { return _name; }
+auto Algorithm::Name() const -> const std::string& { return _name; }
 
 void Algorithm::SetSleepDelay(sf::Time delay)
 {
@@ -284,12 +284,12 @@ auto Algorithm::Elements() -> std::vector<Element>&
 	return _elements;
 }
 
-auto Algorithm::RestartElements() -> List<Element>&
+auto Algorithm::RestartElements() -> std::vector<Element>&
 {
 	return _elementsRestart;
 }
 
-auto Algorithm::ResetElements() -> List<Element>&
+auto Algorithm::ResetElements() -> std::vector<Element>&
 {
 	return _elementsReset;
 }
@@ -356,7 +356,7 @@ void Algorithm::SleepDelay()
 	}
 }
 
-auto Algorithm::Generator() -> Function<long(size_t)>
+auto Algorithm::Generator() -> std::function<long(size_t)>
 {
 	switch (_numberGeneratorType)
 	{
diff --git a/Source/Algorithm.h b/Source/Algorithm.h
@@ -57,7 +57,7 @@ class Algorithm
 	};
 
 public:
-	explicit Algorithm(String name);
+	explicit Algorithm(std::string name);
 
 	virtual ~Algorithm() = default;
 
@@ -79,11 +79,11 @@ class Algorithm
 	void Resize(size_t size);
 	void SoftResize(size_t size);
 
-	void SetImage(const String& filepath);
+	void SetImage(const std::string& filepath);
 
 	void Shuffle(Random::Engine generator);
 
-	auto Name() const -> const String&;
+	auto Name() const -> const std::string&;
 
 	void SetSleepDelay(sf::Time delay);
 	void SetVisType(VisType visType);
@@ -93,9 +93,9 @@ class Algorithm
 	void SetPalette(Palette palette);
 	auto PaletteImage() -> const sf::Image&;
 
-	auto Elements() -> List<Element>&;
-	auto RestartElements() -> List<Element>&;
-	auto ResetElements() -> List<Element>&;
+	auto Elements() -> std::vector<Element>&;
+	auto RestartElements() -> std::vector<Element>&;
+	auto ResetElements() -> std::vector<Element>&;
 
 protected:
 	virtual void Sort() = 0;
@@ -115,7 +115,7 @@ class Algorithm
 	void SleepDelay();
 
 private:
-	auto Generator() -> Function<long(size_t)>;
+	auto Generator() -> std::function<long(size_t)>;
 	auto HighestElementValue() -> long;
 
 	auto PixelCoord(size_t index) const -> sf::Vector2u;
@@ -141,11 +141,11 @@ class Algorithm
 	auto VerifyElements() -> bool;
 
 protected:
-	String _name;
+	std::string _name;
 
-	Thread _sorter;
+	std::thread _sorter;
 
-	Shared<sf::Image> _image;
+	std::shared_ptr<sf::Image> _image;
 	sf::RenderTexture _imageRenderTexture;
 
 	sf::Time _sleepDelay;
@@ -155,35 +155,35 @@ class Algorithm
 	State _state;
 	bool _isActive;
 
-	Shared<sf::Font> _nameTextFont;
+	std::shared_ptr<sf::Font> _nameTextFont;
 	sf::Text _nameText;
 	VisType _visType;
 
 private:
 	static constexpr int MaxElements = 10000;
 	static constexpr int PaletteWidth = 2048;
 
-	List<Element> _elements;
-	List<Element> _elementsRestart;
-	List<Element> _elementsReset;
+	std::vector<Element> _elements;
+	std::vector<Element> _elementsRestart;
+	std::vector<Element> _elementsReset;
 
 	NumberGeneratorType _numberGeneratorType = NumberGeneratorType::Linear;
 
 	// Shapes cache
 	sf::VertexArray _barsVA;
-	List<sf::CircleShape> _hoopsShapes;
+	std::vector<sf::CircleShape> _hoopsShapes;
 	sf::VertexArray _numberLineVA;
-	List<sf::Text> _numberLineTextList;
+	std::vector<sf::Text> _numberLineTextList;
 
 	// Palette
 	sf::Texture _paletteTexture;
 	Palette _desiredPalette = Palette::Rainbow;
 	sf::Image _currentPalette;
-	Array<TransitionColor, PaletteWidth> _colorsStart;
-	Array<TransitionColor, PaletteWidth> _colorsCurrent;
+	std::array<TransitionColor, PaletteWidth> _colorsStart;
+	std::array<TransitionColor, PaletteWidth> _colorsCurrent;
 	float _colorTransitionTimer;
 	float _colorTransitionDuration;
-	List<Shared<sf::Image>> _palettes;
+	std::vector<std::shared_ptr<sf::Image>> _palettes;
 	bool _usePalette = false;
 };
 }
diff --git a/Source/AlgorithmManager.cpp b/Source/AlgorithmManager.cpp
@@ -8,15 +8,15 @@ AlgorithmManager::AlgorithmManager() :
 	_numberGeneratorTypeComboBoxNames({"Linear", "Quadratic", "Random"}),
 	_gnomeSound(SoundStore::Get("gnomed.wav", false))
 {
-	Add(CreateUnique<BubbleSort>());
-	Add(CreateUnique<SelectionSort>());
-	Add(CreateUnique<InsertionSort>());
-	Add(CreateUnique<GnomeSort>());
-	Add(CreateUnique<ShellSort>());
-	Add(CreateUnique<MergeSort>());
-	Add(CreateUnique<HeapSort>());
-	Add(CreateUnique<QuickSort>());
-	Add(CreateUnique<RadixSort>());
+	Add(std::make_unique<BubbleSort>());
+	Add(std::make_unique<SelectionSort>());
+	Add(std::make_unique<InsertionSort>());
+	Add(std::make_unique<GnomeSort>());
+	Add(std::make_unique<ShellSort>());
+	Add(std::make_unique<MergeSort>());
+	Add(std::make_unique<HeapSort>());
+	Add(std::make_unique<QuickSort>());
+	Add(std::make_unique<RadixSort>());
 
 	for (const auto& algorithm : _algorithms)
 	{
@@ -209,21 +209,21 @@ void AlgorithmManager::OnViewportResize(const sf::Vector2f& size)
 	_wantNewDrawContainers = true;
 }
 
-void AlgorithmManager::Add(Unique<Algorithm> algorithm)
+void AlgorithmManager::Add(std::unique_ptr<Algorithm> algorithm)
 {
-	_algorithms.emplace_back(Move(algorithm));
+	_algorithms.emplace_back(std::move(algorithm));
 	_algorithms.back()->Activate();
 }
 
-void AlgorithmManager::Activate(const Unique<Algorithm>& algorithm)
+void AlgorithmManager::Activate(const std::unique_ptr<Algorithm>& algorithm)
 {
 	algorithm->Activate();
 	_wantNewDrawContainers = true;
 
 	OnAlgorithmStateChange();
 }
 
-void AlgorithmManager::Deactivate(const Unique<Algorithm>& algorithm)
+void AlgorithmManager::Deactivate(const std::unique_ptr<Algorithm>& algorithm)
 {
 	algorithm->Deactivate();
 	_wantNewDrawContainers = true;
@@ -311,7 +311,7 @@ void AlgorithmManager::Shuffle()
 void AlgorithmManager::CustomShuffle(int degree)
 {
 	_algorithms.front()->Reset();
-	List<Element>& newElements = _algorithms.front()->RestartElements();
+	std::vector<Element>& newElements = _algorithms.front()->RestartElements();
 
 	const auto degreePecentage = static_cast<float>(degree) / 100.0f;
 	const int noElements = newElements.size();
@@ -380,7 +380,7 @@ void AlgorithmManager::SetNumberGeneratorType(Algorithm::NumberGeneratorType num
 	}
 }
 
-auto AlgorithmManager::Algorithms() const -> const List<Unique<Algorithm>>& { return _algorithms; }
+auto AlgorithmManager::Algorithms() const -> const std::vector<std::unique_ptr<Algorithm>>& { return _algorithms; }
 
 void AlgorithmManager::GenerateDrawContainers(const Scene& scene)
 {
diff --git a/Source/AlgorithmManager.h b/Source/AlgorithmManager.h
@@ -31,10 +31,10 @@ class AlgorithmManager
 	void OnGuiRender();
 	void OnViewportResize(const sf::Vector2f& size);
 
-	void Add(Unique<Algorithm> algorithm);
+	void Add(std::unique_ptr<Algorithm> algorithm);
 
-	void Activate(const Unique<Algorithm>& algorithm);
-	void Deactivate(const Unique<Algorithm>& algorithm);
+	void Activate(const std::unique_ptr<Algorithm>& algorithm);
+	void Deactivate(const std::unique_ptr<Algorithm>& algorithm);
 
 	void UsePalette(bool use);
 
@@ -57,7 +57,7 @@ class AlgorithmManager
 	void SetPalette(Algorithm::Palette palette);
 	void SetNumberGeneratorType(Algorithm::NumberGeneratorType numberGeneratorType);
 
-	auto Algorithms() const -> const List<Unique<Algorithm>>&;
+	auto Algorithms() const -> const std::vector<std::unique_ptr<Algorithm>>&;
 
 private:
 	void GenerateDrawContainers(const Scene& scene);
@@ -67,8 +67,8 @@ class AlgorithmManager
 	void OnAlgorithmStateChange();
 
 private:
-	List<Unique<Algorithm>> _algorithms;
-	List<sf::FloatRect> _drawContainers;
+	std::vector<std::unique_ptr<Algorithm>> _algorithms;
+	std::vector<sf::FloatRect> _drawContainers;
 
 	// A cache used for getter
 	Algorithm::VisType _visType;
@@ -81,17 +81,17 @@ class AlgorithmManager
 	float _sleepDelayMicroseconds = 10000.0f;
 	bool _usePalette = false;
 	int _activeVisTypeIndex = static_cast<int>(Algorithm::VisType::Bars);
-	List<const char*> _visTypeNames;
-	List<const char*> _algorithmNames;
+	std::vector<const char*> _visTypeNames;
+	std::vector<const char*> _algorithmNames;
 	int _customShuffleDegree = 10;
 
-	List<const char*> _paletteComboBoxNames;
+	std::vector<const char*> _paletteComboBoxNames;
 	int _activePaletteInt = static_cast<int>(Algorithm::Palette::Rainbow);
 
-	List<const char*> _numberGeneratorTypeComboBoxNames;
+	std::vector<const char*> _numberGeneratorTypeComboBoxNames;
 	int _numberGeneratorTypeInt = static_cast<int>(Algorithm::NumberGeneratorType::Linear);
 
 	bool _gnomeActive = false;
-	Shared<sf::Sound> _gnomeSound;
+	std::shared_ptr<sf::Sound> _gnomeSound;
 };
 }
diff --git a/Source/Algorithms/MergeSort.cpp b/Source/Algorithms/MergeSort.cpp
@@ -25,7 +25,7 @@ void MergeSort::Split(size_t iStart, size_t iEnd)
 
 void MergeSort::Merge(size_t iLeftStart, size_t iLeftEnd, size_t iRightStart, size_t iRightEnd)
 {
-	List<long> sorted;
+	std::vector<long> sorted;
 
 	size_t iCurrLeft = iLeftStart;
 	size_t iCurrRight = iRightStart;
diff --git a/Source/Algorithms/RadixSort.cpp b/Source/Algorithms/RadixSort.cpp
@@ -15,7 +15,7 @@ void RadixSort::Sort()
 
 void RadixSort::CountSort(size_t exponent)
 {
-	List<Element> outBucket(Elements().size());
+	std::vector<Element> outBucket(Elements().size());
 	std::array<size_t, 10> count = {0};
 
 	// Store count of occurrences in count[]
diff --git a/Source/Layers/BaseLayer.cpp b/Source/Layers/BaseLayer.cpp
@@ -8,7 +8,7 @@ BaseLayer::BaseLayer() :
 {
 }
 
-void BaseLayer::OnAttach(Shared<Batch>& batch)
+void BaseLayer::OnAttach(std::shared_ptr<Batch>& batch)
 {
 	_scene.ViewportPane().Resized += SE_EV_ACTION(BaseLayer::OnWantRenderTargetResize);
 	RenderTargetManager::Add(&_controllableRenderTexture);
diff --git a/Source/Layers/BaseLayer.h b/Source/Layers/BaseLayer.h
@@ -9,7 +9,7 @@ class BaseLayer : public Layer
 public:
 	BaseLayer();
 
-	void OnAttach(Shared<Batch>& batch) override;
+	void OnAttach(std::shared_ptr<Batch>& batch) override;
 	void OnDetach() override;
 
 	void OnPreFrame() override;
@@ -25,7 +25,7 @@ class BaseLayer : public Layer
 	void OnWantRenderTargetResize(const sf::Vector2f &newSize);
 
 public:
-	EventSubscriberList<const sf::Vector2f &> RenderTargetResized;
+	SubscriberList<const sf::Vector2f &> RenderTargetResized;
 
 protected:
 	ControllableRenderTexture _controllableRenderTexture;
diff --git a/Source/Layers/ProjectLayer.cpp b/Source/Layers/ProjectLayer.cpp
@@ -2,11 +2,11 @@
 
 namespace Se
 {
-void ProjectLayer::OnAttach(Shared<Batch>& batch)
+void ProjectLayer::OnAttach(std::shared_ptr<Batch>& batch)
 {
 	BaseLayer::OnAttach(batch);
 
-	_algorithmManager = CreateShared<AlgorithmManager>();
+	_algorithmManager = std::make_shared<AlgorithmManager>();
 }
 
 void ProjectLayer::OnDetach()
diff --git a/Source/Layers/ProjectLayer.h b/Source/Layers/ProjectLayer.h
@@ -9,7 +9,7 @@ namespace Se
 class ProjectLayer : public BaseLayer
 {
 public:
-	void OnAttach(Shared<Batch>& batch) override;
+	void OnAttach(std::shared_ptr<Batch>& batch) override;
 	void OnDetach() override;
 
 	void OnUpdate() override;
@@ -18,6 +18,6 @@ class ProjectLayer : public BaseLayer
 	void OnRenderTargetResize(const sf::Vector2f& newSize) override;
 
 private:
-	Shared<AlgorithmManager> _algorithmManager;
+	std::shared_ptr<AlgorithmManager> _algorithmManager;
 };
 }
diff --git a/Source/ProjectApp.cpp b/Source/ProjectApp.cpp
@@ -3,14 +3,14 @@
 
 namespace Se
 {
-auto CreateApplication() -> Unique<App>
+auto CreateApplication() -> std::unique_ptr<App>
 {
-	return CreateUnique<ProjectApp>(AppProperties::CreateFullscreen("Algorithms"));
+	return std::make_unique<ProjectApp>(AppProperties::CreateFullscreen("Algorithms"));
 }
 
 ProjectApp::ProjectApp(const AppProperties& properties) :
 	App(properties),
-	_projectLayer(CreateShared<ProjectLayer>())
+	_projectLayer(std::make_shared<ProjectLayer>())
 {
 }
 
diff --git a/Source/ProjectApp.h b/Source/ProjectApp.h
diff --git a/ThirdParty/SaffronEngine2D b/ThirdParty/SaffronEngine2D

Original file line number	Diff line number	Diff line change
`@@ -6,13 +6,13 @@ namespace Se`
`6`	`6`	`{`
`7`	`7`	`struct ContainerRefGroup`
`8`	`8`	`{`
`9`		`- List<Element>& elements;`
`10`		`- List<Element>& elementsRestart;`
`11`		`- List<Element>& elementsReset;`
	`9`	`+ std::vector<Element>& elements;`
	`10`	`+ std::vector<Element>& elementsRestart;`
	`11`	`+ std::vector<Element>& elementsReset;`
`12`	`12`	`};`
`13`	`13`
`14`		`-Algorithm::Algorithm(String name) :`
`15`		`- _name(Move(name)),`
	`14`	`+Algorithm::Algorithm(std::string name) :`
	`15`	`+ _name(std::move(name)),`
`16`	`16`	`_sleepDelay(sf::seconds(0.01f)),`
`17`	`17`	`_minorDelay(false),`
`18`	`18`	`_minorDelayTimer(0),`
`@@ -144,7 +144,7 @@ void Algorithm::Start()`
`144`	`144`	`{`
`145`	`145`	`CollectSorter();`
`146`	`146`	`_state = State::Sorting;`
`147`		`- _sorter = Thread([this]`
	`147`	`+ _sorter = std::thread([this]`
`148`	`148`	`{`
`149`	`149`	`SortThreadFn();`
`150`	`150`	`});`
`@@ -230,7 +230,7 @@ void Algorithm::SoftResize(size_t size)`
`230`	`230`	`_numberLineVA.resize(size * 4);`
`231`	`231`	`}`
`232`	`232`
`233`		`-void Algorithm::SetImage(const String& filepath)`
	`233`	`+void Algorithm::SetImage(const std::string& filepath)`
`234`	`234`	`{`
`235`	`235`	`Reset();`
`236`	`236`	`_image = ImageStore::Get(filepath);`
`@@ -244,7 +244,7 @@ void Algorithm::Shuffle(Random::Engine generator)`
`244`	`244`	`_elements = _elementsRestart;`
`245`	`245`	`}`
`246`	`246`
`247`		`-auto Algorithm::Name() const -> const String& { return _name; }`
	`247`	`+auto Algorithm::Name() const -> const std::string& { return _name; }`
`248`	`248`
`249`	`249`	`void Algorithm::SetSleepDelay(sf::Time delay)`
`250`	`250`	`{`
`@@ -284,12 +284,12 @@ auto Algorithm::Elements() -> std::vector<Element>&`
`284`	`284`	`return _elements;`
`285`	`285`	`}`
`286`	`286`
`287`		`-auto Algorithm::RestartElements() -> List<Element>&`
	`287`	`+auto Algorithm::RestartElements() -> std::vector<Element>&`
`288`	`288`	`{`
`289`	`289`	`return _elementsRestart;`
`290`	`290`	`}`
`291`	`291`
`292`		`-auto Algorithm::ResetElements() -> List<Element>&`
	`292`	`+auto Algorithm::ResetElements() -> std::vector<Element>&`
`293`	`293`	`{`
`294`	`294`	`return _elementsReset;`
`295`	`295`	`}`
`@@ -356,7 +356,7 @@ void Algorithm::SleepDelay()`
`356`	`356`	`}`
`357`	`357`	`}`
`358`	`358`
`359`		`-auto Algorithm::Generator() -> Function<long(size_t)>`
	`359`	`+auto Algorithm::Generator() -> std::function<long(size_t)>`
`360`	`360`	`{`
`361`	`361`	`switch (_numberGeneratorType)`
`362`	`362`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,15 +8,15 @@ AlgorithmManager::AlgorithmManager() :`
`8`	`8`	`_numberGeneratorTypeComboBoxNames({"Linear", "Quadratic", "Random"}),`
`9`	`9`	`_gnomeSound(SoundStore::Get("gnomed.wav", false))`
`10`	`10`	`{`
`11`		`- Add(CreateUnique<BubbleSort>());`
`12`		`- Add(CreateUnique<SelectionSort>());`
`13`		`- Add(CreateUnique<InsertionSort>());`
`14`		`- Add(CreateUnique<GnomeSort>());`
`15`		`- Add(CreateUnique<ShellSort>());`
`16`		`- Add(CreateUnique<MergeSort>());`
`17`		`- Add(CreateUnique<HeapSort>());`
`18`		`- Add(CreateUnique<QuickSort>());`
`19`		`- Add(CreateUnique<RadixSort>());`
	`11`	`+ Add(std::make_unique<BubbleSort>());`
	`12`	`+ Add(std::make_unique<SelectionSort>());`
	`13`	`+ Add(std::make_unique<InsertionSort>());`
	`14`	`+ Add(std::make_unique<GnomeSort>());`
	`15`	`+ Add(std::make_unique<ShellSort>());`
	`16`	`+ Add(std::make_unique<MergeSort>());`
	`17`	`+ Add(std::make_unique<HeapSort>());`
	`18`	`+ Add(std::make_unique<QuickSort>());`
	`19`	`+ Add(std::make_unique<RadixSort>());`
`20`	`20`
`21`	`21`	`for (const auto& algorithm : _algorithms)`
`22`	`22`	`{`
`@@ -209,21 +209,21 @@ void AlgorithmManager::OnViewportResize(const sf::Vector2f& size)`
`209`	`209`	`_wantNewDrawContainers = true;`
`210`	`210`	`}`
`211`	`211`
`212`		`-void AlgorithmManager::Add(Unique<Algorithm> algorithm)`
	`212`	`+void AlgorithmManager::Add(std::unique_ptr<Algorithm> algorithm)`
`213`	`213`	`{`
`214`		`- _algorithms.emplace_back(Move(algorithm));`
	`214`	`+ _algorithms.emplace_back(std::move(algorithm));`
`215`	`215`	`_algorithms.back()->Activate();`
`216`	`216`	`}`
`217`	`217`
`218`		`-void AlgorithmManager::Activate(const Unique<Algorithm>& algorithm)`
	`218`	`+void AlgorithmManager::Activate(const std::unique_ptr<Algorithm>& algorithm)`
`219`	`219`	`{`
`220`	`220`	`algorithm->Activate();`
`221`	`221`	`_wantNewDrawContainers = true;`
`222`	`222`
`223`	`223`	`OnAlgorithmStateChange();`
`224`	`224`	`}`
`225`	`225`
`226`		`-void AlgorithmManager::Deactivate(const Unique<Algorithm>& algorithm)`
	`226`	`+void AlgorithmManager::Deactivate(const std::unique_ptr<Algorithm>& algorithm)`
`227`	`227`	`{`
`228`	`228`	`algorithm->Deactivate();`
`229`	`229`	`_wantNewDrawContainers = true;`
`@@ -311,7 +311,7 @@ void AlgorithmManager::Shuffle()`
`311`	`311`	`void AlgorithmManager::CustomShuffle(int degree)`
`312`	`312`	`{`
`313`	`313`	`_algorithms.front()->Reset();`
`314`		`- List<Element>& newElements = _algorithms.front()->RestartElements();`
	`314`	`+ std::vector<Element>& newElements = _algorithms.front()->RestartElements();`
`315`	`315`
`316`	`316`	`const auto degreePecentage = static_cast<float>(degree) / 100.0f;`
`317`	`317`	`const int noElements = newElements.size();`
`@@ -380,7 +380,7 @@ void AlgorithmManager::SetNumberGeneratorType(Algorithm::NumberGeneratorType num`
`380`	`380`	`}`
`381`	`381`	`}`
`382`	`382`
`383`		`-auto AlgorithmManager::Algorithms() const -> const List<Unique<Algorithm>>& { return _algorithms; }`
	`383`	`+auto AlgorithmManager::Algorithms() const -> const std::vector<std::unique_ptr<Algorithm>>& { return _algorithms; }`
`384`	`384`
`385`	`385`	`void AlgorithmManager::GenerateDrawContainers(const Scene& scene)`
`386`	`386`	`{`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ void MergeSort::Split(size_t iStart, size_t iEnd)`
`25`	`25`
`26`	`26`	`void MergeSort::Merge(size_t iLeftStart, size_t iLeftEnd, size_t iRightStart, size_t iRightEnd)`
`27`	`27`	`{`
`28`		`- List<long> sorted;`
	`28`	`+ std::vector<long> sorted;`
`29`	`29`
`30`	`30`	`size_t iCurrLeft = iLeftStart;`
`31`	`31`	`size_t iCurrRight = iRightStart;`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ void RadixSort::Sort()`
`15`	`15`
`16`	`16`	`void RadixSort::CountSort(size_t exponent)`
`17`	`17`	`{`
`18`		`- List<Element> outBucket(Elements().size());`
	`18`	`+ std::vector<Element> outBucket(Elements().size());`
`19`	`19`	`std::array<size_t, 10> count = {0};`
`20`	`20`
`21`	`21`	`// Store count of occurrences in count[]`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ BaseLayer::BaseLayer() :`
`8`	`8`	`{`
`9`	`9`	`}`
`10`	`10`
`11`		`-void BaseLayer::OnAttach(Shared<Batch>& batch)`
	`11`	`+void BaseLayer::OnAttach(std::shared_ptr<Batch>& batch)`
`12`	`12`	`{`
`13`	`13`	`_scene.ViewportPane().Resized += SE_EV_ACTION(BaseLayer::OnWantRenderTargetResize);`
`14`	`14`	`RenderTargetManager::Add(&_controllableRenderTexture);`
Original file line number	Diff line number	Diff line change
`@@ -2,11 +2,11 @@`
`2`	`2`
`3`	`3`	`namespace Se`
`4`	`4`	`{`
`5`		`-void ProjectLayer::OnAttach(Shared<Batch>& batch)`
	`5`	`+void ProjectLayer::OnAttach(std::shared_ptr<Batch>& batch)`
`6`	`6`	`{`
`7`	`7`	`BaseLayer::OnAttach(batch);`
`8`	`8`
`9`		`- _algorithmManager = CreateShared<AlgorithmManager>();`
	`9`	`+ _algorithmManager = std::make_shared<AlgorithmManager>();`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`void ProjectLayer::OnDetach()`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace Se`
`9`	`9`	`class ProjectLayer : public BaseLayer`
`10`	`10`	`{`
`11`	`11`	`public:`
`12`		`- void OnAttach(Shared<Batch>& batch) override;`
	`12`	`+ void OnAttach(std::shared_ptr<Batch>& batch) override;`
`13`	`13`	`void OnDetach() override;`
`14`	`14`
`15`	`15`	`void OnUpdate() override;`
`@@ -18,6 +18,6 @@ class ProjectLayer : public BaseLayer`
`18`	`18`	`void OnRenderTargetResize(const sf::Vector2f& newSize) override;`
`19`	`19`
`20`	`20`	`private:`
`21`		`- Shared<AlgorithmManager> _algorithmManager;`
	`21`	`+ std::shared_ptr<AlgorithmManager> _algorithmManager;`
`22`	`22`	`};`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,14 +3,14 @@`
`3`	`3`
`4`	`4`	`namespace Se`
`5`	`5`	`{`
`6`		`-auto CreateApplication() -> Unique<App>`
	`6`	`+auto CreateApplication() -> std::unique_ptr<App>`
`7`	`7`	`{`
`8`		`- return CreateUnique<ProjectApp>(AppProperties::CreateFullscreen("Algorithms"));`
	`8`	`+ return std::make_unique<ProjectApp>(AppProperties::CreateFullscreen("Algorithms"));`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`ProjectApp::ProjectApp(const AppProperties& properties) :`
`12`	`12`	`App(properties),`
`13`		`- _projectLayer(CreateShared<ProjectLayer>())`
	`13`	`+ _projectLayer(std::make_shared<ProjectLayer>())`
`14`	`14`	`{`
`15`	`15`	`}`
`16`	`16`