Deukhoofd
/
Arbutils
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Change namespace name so it's a lot less verbose.
continuous-integration/drone/push Build is passing Details

This commit is contained in:
Deukhoofd 2020-05-26 17:21:08 +02:00
parent 2ae108517d
commit 3dc96de34b
Signed by: Deukhoofd
GPG Key ID: ADF2E9256009EDCE
10 changed files with 35 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Collections/Dictionary.hpp
View File

@ -4,7 +4,7 @@
#include <unordered_map> #include <unordered_map>
#include "../Assert.hpp" #include "../Assert.hpp"
namespace Arbutils::Collections { namespace ArbUt::Collections {
template <class KeyT, class ValueT> class Dictionary { template <class KeyT, class ValueT> class Dictionary {
private: private:
std::unordered_map<KeyT, ValueT> _map; std::unordered_map<KeyT, ValueT> _map;

2
src/Collections/List.hpp
View File

@ -5,7 +5,7 @@
#include <stdexcept> #include <stdexcept>
#include <vector> #include <vector>
namespace Arbutils::Collections { namespace ArbUt::Collections {
template <class ValueT> class List { template <class ValueT> class List {
private: private:
std::vector<ValueT> _vector; std::vector<ValueT> _vector;

4
src/ConstString.cpp
View File

@ -1,5 +1,5 @@
#include "ConstString.hpp" #include "ConstString.hpp"
Arbutils::__ConstStringCharHolder* Arbutils::CaseInsensitiveConstString::__emptyString = ArbUt::__ConstStringCharHolder* ArbUt::CaseInsensitiveConstString::__emptyString =
new __ConstStringCharHolder("", 0); new __ConstStringCharHolder("", 0);
Arbutils::__ConstStringCharHolder* Arbutils::ConstString::__emptyString = new __ConstStringCharHolder("", 0); ArbUt::__ConstStringCharHolder* ArbUt::ConstString::__emptyString = new __ConstStringCharHolder("", 0);

18
src/ConstString.hpp
View File

@ -8,7 +8,7 @@
#include <string> #include <string>
#include "__ConstStringCore.hpp" #include "__ConstStringCore.hpp"
namespace Arbutils { namespace ArbUt {
class __ConstStringCharHolder { class __ConstStringCharHolder {
char* _value; char* _value;
std::atomic<size_t> _references; std::atomic<size_t> _references;
@ -39,12 +39,12 @@ ConstStringCore(
return (*input) ? static_cast<uint32_t>((*input)) + 33 * Hash(input + 1) : 5381; return (*input) ? static_cast<uint32_t>((*input)) + 33 * Hash(input + 1) : 5381;
};) };)
inline constexpr Arbutils::ConstString_Literal inline constexpr ArbUt::ConstString_Literal
operator"" _const(const char* c, size_t l) { operator"" _const(const char* c, size_t l) {
return Arbutils::ConstString_Literal(c, l); return ArbUt::ConstString_Literal(c, l);
} }
inline constexpr Arbutils::ConstString_Literal operator"" _c(const char* c, size_t l) { inline constexpr ArbUt::ConstString_Literal operator"" _c(const char* c, size_t l) {
return Arbutils::ConstString_Literal(c, l); return ArbUt::ConstString_Literal(c, l);
} }
ConstStringCore( ConstStringCore(
@ -55,11 +55,11 @@ ConstStringCore(
return charToLower(*input) ? static_cast<uint32_t>(charToLower(*input)) + 33 * Hash(input + 1) : 5381; return charToLower(*input) ? static_cast<uint32_t>(charToLower(*input)) + 33 * Hash(input + 1) : 5381;
};); };);
inline constexpr Arbutils::CaseInsensitiveConstString_Literal operator"" _const_nocase(const char* c, size_t l) { inline constexpr ArbUt::CaseInsensitiveConstString_Literal operator"" _const_nocase(const char* c, size_t l) {
return Arbutils::CaseInsensitiveConstString_Literal(c, l); return ArbUt::CaseInsensitiveConstString_Literal(c, l);
} }
inline constexpr Arbutils::CaseInsensitiveConstString_Literal operator"" _cnc(const char* c, size_t l) { inline constexpr ArbUt::CaseInsensitiveConstString_Literal operator"" _cnc(const char* c, size_t l) {
return Arbutils::CaseInsensitiveConstString_Literal(c, l); return ArbUt::CaseInsensitiveConstString_Literal(c, l);
} }
#endif // ARBUTILS_CONSTSTRING_HPP #endif // ARBUTILS_CONSTSTRING_HPP

2
src/Random.hpp
View File

@ -7,7 +7,7 @@
#include "../extern/pcg_random.hpp" #include "../extern/pcg_random.hpp"
#include "Assert.hpp" #include "Assert.hpp"
namespace Arbutils { namespace ArbUt {
template <class RandomT> class BaseRandom { template <class RandomT> class BaseRandom {
private: private:

10
src/__ConstStringCore.hpp
View File

@ -8,7 +8,7 @@
#endif #endif
#define ConstStringCore(name, hashFunction) \ #define ConstStringCore(name, hashFunction) \
namespace Arbutils { \ namespace ArbUt { \
class name { \ class name { \
private: \ private: \
__ConstStringCharHolder* _str; \ __ConstStringCharHolder* _str; \
@ -112,11 +112,11 @@
} \ } \
\ \
namespace std { \ namespace std { \
template <> struct hash<Arbutils::name> { \ template <> struct hash<ArbUt::name> { \
constexpr std::size_t operator()(Arbutils::name const& s) const noexcept { return s.GetHash(); } \ constexpr std::size_t operator()(ArbUt::name const& s) const noexcept { return s.GetHash(); } \
}; \ }; \
template <> struct hash<Arbutils::name##_Literal> { \ template <> struct hash<ArbUt::name##_Literal> { \
constexpr std::size_t operator()(Arbutils::name##_Literal const& s) const noexcept { return s.GetHash(); } \ constexpr std::size_t operator()(ArbUt::name##_Literal const& s) const noexcept { return s.GetHash(); } \
}; \ }; \
} }

16
tests/ConstStringTests.cpp
View File

@ -5,7 +5,7 @@
#include "../src/ConstString.hpp" #include "../src/ConstString.hpp"
TEST_CASE("Use const string in unordered_map", "[Utilities]") { TEST_CASE("Use const string in unordered_map", "[Utilities]") {
std::unordered_map<Arbutils::ConstString, int32_t> map; std::unordered_map<ArbUt::ConstString, int32_t> map;
map.insert({"foo"_c, 1}); map.insert({"foo"_c, 1});
map.insert({"bar"_c, 5}); map.insert({"bar"_c, 5});
@ -14,7 +14,7 @@ TEST_CASE("Use const string in unordered_map", "[Utilities]") {
} }
TEST_CASE("Use const string in switch case", "[Utilities]") { TEST_CASE("Use const string in switch case", "[Utilities]") {
auto val = Arbutils::ConstString("foobar"); auto val = ArbUt::ConstString("foobar");
switch (val) { switch (val) {
case "foo"_c: FAIL(); break; case "foo"_c: FAIL(); break;
case "bar"_c: FAIL(); break; case "bar"_c: FAIL(); break;
@ -24,7 +24,7 @@ TEST_CASE("Use const string in switch case", "[Utilities]") {
} }
TEST_CASE("Use insensitive const string in unordered_map", "[Utilities]") { TEST_CASE("Use insensitive const string in unordered_map", "[Utilities]") {
std::unordered_map<Arbutils::CaseInsensitiveConstString, int32_t> map; std::unordered_map<ArbUt::CaseInsensitiveConstString, int32_t> map;
map.insert({"foO"_cnc, 1}); map.insert({"foO"_cnc, 1});
map.insert({"bAR"_cnc, 5}); map.insert({"bAR"_cnc, 5});
@ -33,7 +33,7 @@ TEST_CASE("Use insensitive const string in unordered_map", "[Utilities]") {
} }
TEST_CASE("Use case insensitive const string in switch case", "[Utilities]") { TEST_CASE("Use case insensitive const string in switch case", "[Utilities]") {
auto val = Arbutils::CaseInsensitiveConstString("foobar"); auto val = ArbUt::CaseInsensitiveConstString("foobar");
switch (val) { switch (val) {
case "foo"_cnc: FAIL(); break; case "foo"_cnc: FAIL(); break;
case "bar"_cnc: FAIL(); break; case "bar"_cnc: FAIL(); break;
@ -45,7 +45,7 @@ TEST_CASE("Use case insensitive const string in switch case", "[Utilities]") {
#ifndef WINDOWS #ifndef WINDOWS
__attribute__((optnone)) __attribute__((optnone))
#endif #endif
static Arbutils::CaseInsensitiveConstString static ArbUt::CaseInsensitiveConstString
TestCreateConstString() { TestCreateConstString() {
char originalVal[7]; char originalVal[7];
originalVal[0] = 'f'; originalVal[0] = 'f';
@ -55,17 +55,17 @@ TestCreateConstString() {
originalVal[4] = 'a'; originalVal[4] = 'a';
originalVal[5] = 'r'; originalVal[5] = 'r';
originalVal[6] = '\0'; originalVal[6] = '\0';
return Arbutils::CaseInsensitiveConstString(originalVal); return ArbUt::CaseInsensitiveConstString(originalVal);
} }
TEST_CASE("Out of scope char* doesn't lose reference", "[Utilities]") { TEST_CASE("Out of scope char* doesn't lose reference", "[Utilities]") {
Arbutils::CaseInsensitiveConstString val = TestCreateConstString(); ArbUt::CaseInsensitiveConstString val = TestCreateConstString();
INFO(val.c_str()); INFO(val.c_str());
REQUIRE(strcmp(val.c_str(), "foobar") == 0); REQUIRE(strcmp(val.c_str(), "foobar") == 0);
} }
TEST_CASE("Literal conststring to non literal, then use", "[Utilities]") { TEST_CASE("Literal conststring to non literal, then use", "[Utilities]") {
Arbutils::CaseInsensitiveConstString val; ArbUt::CaseInsensitiveConstString val;
{ val = "foobar"_cnc; } { val = "foobar"_cnc; }
INFO(val.c_str()); INFO(val.c_str());
REQUIRE(strcmp(val.c_str(), "foobar") == 0); REQUIRE(strcmp(val.c_str(), "foobar") == 0);

2
tests/DictionaryTests.cpp
View File

@ -1,7 +1,7 @@
#ifdef TESTS_BUILD #ifdef TESTS_BUILD
#include "../extern/catch.hpp" #include "../extern/catch.hpp"
#include "../src/Collections/Dictionary.hpp" #include "../src/Collections/Dictionary.hpp"
using namespace Arbutils::Collections; using namespace ArbUt::Collections;
TEST_CASE("Create Dictionary, insert values", "[Utilities]") { TEST_CASE("Create Dictionary, insert values", "[Utilities]") {
auto dic = Dictionary<int, int>(5); auto dic = Dictionary<int, int>(5);

2
tests/ListTests.cpp
View File

@ -1,7 +1,7 @@
#ifdef TESTS_BUILD #ifdef TESTS_BUILD
#include "../extern/catch.hpp" #include "../extern/catch.hpp"
#include "../src/Collections/List.hpp" #include "../src/Collections/List.hpp"
using namespace Arbutils::Collections; using namespace ArbUt::Collections;
TEST_CASE("Create List, insert values", "[Utilities]") { TEST_CASE("Create List, insert values", "[Utilities]") {
auto ls = List<int>(); auto ls = List<int>();

12
tests/RandomTests.cpp
View File

@ -5,7 +5,7 @@
#include "../src/Random.hpp" #include "../src/Random.hpp"
TEST_CASE("Random ints", "[Utilities]") { TEST_CASE("Random ints", "[Utilities]") {
auto rand = Arbutils::Random(10); auto rand = ArbUt::Random(10);
CHECK(rand.Get() == 1234817989); CHECK(rand.Get() == 1234817989);
CHECK(rand.Get() == 1171957426); CHECK(rand.Get() == 1171957426);
CHECK(rand.Get() == 275100647); CHECK(rand.Get() == 275100647);
@ -19,7 +19,7 @@ TEST_CASE("Random ints", "[Utilities]") {
} }
TEST_CASE("Random ints with limit", "[Utilities]") { TEST_CASE("Random ints with limit", "[Utilities]") {
auto rand = Arbutils::Random(10); auto rand = ArbUt::Random(10);
CHECK(rand.Get(10) == 2); CHECK(rand.Get(10) == 2);
CHECK(rand.Get(10) == 2); CHECK(rand.Get(10) == 2);
CHECK(rand.Get(10) == 0); CHECK(rand.Get(10) == 0);
@ -43,7 +43,7 @@ TEST_CASE("Random ints with limit", "[Utilities]") {
} }
TEST_CASE("Random ints with upper and bottom", "[Utilities]") { TEST_CASE("Random ints with upper and bottom", "[Utilities]") {
auto rand = Arbutils::Random(10); auto rand = ArbUt::Random(10);
CHECK(rand.Get(10, 30) == 15); CHECK(rand.Get(10, 30) == 15);
CHECK(rand.Get(10, 30) == 15); CHECK(rand.Get(10, 30) == 15);
CHECK(rand.Get(10, 30) == 11); CHECK(rand.Get(10, 30) == 11);
@ -57,7 +57,7 @@ TEST_CASE("Random ints with upper and bottom", "[Utilities]") {
} }
TEST_CASE("Random distribution (max 0, min 1)", "[Utilities]") { TEST_CASE("Random distribution (max 0, min 1)", "[Utilities]") {
auto rand = Arbutils::Random(10); auto rand = ArbUt::Random(10);
const int size = 100000; const int size = 100000;
int arr[size]; int arr[size];
for (size_t i = 0; i < size; i++) { for (size_t i = 0; i < size; i++) {
@ -70,7 +70,7 @@ TEST_CASE("Random distribution (max 0, min 1)", "[Utilities]") {
} }
TEST_CASE("Random distribution (max 0, min 2)", "[Utilities]") { TEST_CASE("Random distribution (max 0, min 2)", "[Utilities]") {
auto rand = Arbutils::Random(10); auto rand = ArbUt::Random(10);
const int size = 100000; const int size = 100000;
int arr[size]; int arr[size];
for (size_t i = 0; i < size; i++) { for (size_t i = 0; i < size; i++) {
@ -92,7 +92,7 @@ TEST_CASE("Random distribution (max 0, min 2)", "[Utilities]") {
} }
TEST_CASE("Random distribution (max 0, min 3)", "[Utilities]") { TEST_CASE("Random distribution (max 0, min 3)", "[Utilities]") {
auto rand = Arbutils::Random(10); auto rand = ArbUt::Random(10);
const size_t size = 100000; const size_t size = 100000;
int arr[size]; int arr[size];
for (size_t i = 0; i < size; i++) { for (size_t i = 0; i < size; i++) {