GithubHelp home page GithubHelp logo

thibfrgsgmz / fixed-containers Goto Github PK

View Code? Open in Web Editor NEW

This project forked from teslamotors/fixed-containers

0.0 0.0 0.0 797 KB

C++ Fixed Containers

License: MIT License

C++ 98.00% CMake 0.49% Starlark 1.50%

fixed-containers's Introduction

C++ Fixed Containers

License Standard Ubuntu Ubuntu (clang) Windows CodeQL

Header-only C++20 library that provides containers with the following properties:

  • Fixed-capacity, declared at compile-time, no dynamic allocations
  • constexpr - can be used at both compile-time and runtime (including mutation)
  • containers retain the properties of T (e.g. if T is trivially copyable, then so is FixedVector)
  • no pointers stored (data layout is purely self-referential and can be serialized directly)
  • instances can be used as non-type template parameters

Features

  • The following table shows the available fixed containers and their equivalent std-containers. The fixed-container types have identical APIs to their std:: equivalents, so you can refer to the traditional C++ docs for how to use them.

    fixed-container std-container equivalent
    FixedVector std::vector
    FixedDeque std::deque
    FixedList std::list
    FixedQueue std::queue
    FixedStack std::stack
    FixedCircularDeque std::deque API with Circular Buffer semantics
    FixedCircularQueue std::queue API with Circular Buffer semantics
    FixedString std::string
    FixedMap std::map
    FixedSet std::set
    FixedUnorderedMap std::unordered_map
    FixedUnorderedSet std::unordered_set
    EnumMap std::map for enum keys only
    EnumSet std::set for enum keys only
    EnumArray std::array but with typed accessors

  • StringLiteral - Compile-time null-terminated literal string.

  • Rich enums - enum & class hybrid.

Rich enum features

  • Rich enums behave like an enum (compile-time known values, can be used in switch-statements, template parameters as well as EnumMap/EnumSet etc).
  • Can have member functions and fields.
  • Readily available count(), to_string().
  • Conversion from string, ordinal.
  • Implicit std::optional-like semantics.
  • Avoid the need for error-prone sentinel values like UNKNOWN, UNINITIALIZED, COUNT etc.
  • Avoid Undefined Behavior from uninitialized state. Default constructor can be disabled altogether.
  • EnumAdapter<T> can adapt any enum-like class to the rich enum API.
static_assert(fixed_containers::rich_enums::is_rich_enum<Color>);  // Type-trait `concept`
inline constexpr const Color& COLOR = Color::RED();                // Note the parens
static_assert("RED" == COLOR.to_string());                         // auto-provided member
static_assert(COLOR.is_primary());                                 // Custom member
static_assert(COLOR == Color::value_of("RED").value());            // auto-provided
static_assert(4 == Color::count());                                // auto-provided

More examples can be found here.

Examples

  • FixedVector

    constexpr auto v1 = []()
{
    FixedVector<int, 11> v{};
    v.push_back(0);
    v.emplace_back(1);
    v.push_back(2);
    return v;
}();
static_assert(v1[0] == 0);
static_assert(v1[1] == 1);
static_assert(v1[2] == 2);
static_assert(v1.size() == 3);
static_assert(v1.capacity() == 11);

  • FixedList

    constexpr auto v1 = []()
{
    FixedList<int, 11> v{};
    v.push_back(0);
    v.emplace_back(1);
    v.push_front(2);
    return v;
}();
static_assert(*v1.begin() == 2);
static_assert(v1.size() == 3);
static_assert(v1.max_size() == 11);

  • FixedDeque

    constexpr auto v1 = []()
{
    FixedDeque<int, 11> v{};
    v.push_back(0);
    v.emplace_back(1);
    v.push_front(2);
    return v;
}();
static_assert(v1[0] == 2);
static_assert(v1[1] == 0);
static_assert(v1[2] == 1);
static_assert(v1.size() == 3);
static_assert(v1.max_size() == 11);

  • FixedQueue

    constexpr auto s1 = []()
{
    FixedQueue<int, 3> v1{};
    v1.push(77);
    v1.push(88);
    v1.push(99);
    return v1;
}();

static_assert(s1.front() == 77);
static_assert(s1.back() == 99);
static_assert(s1.size() == 3);

  • FixedStack

    constexpr auto s1 = []()
{
    FixedStack<int, 3> v1{};
    int my_int = 77;
    v1.push(my_int);
    v1.push(99);
    return v1;
}();

static_assert(s1.top() == 99);
static_assert(s1.size() == 2);

  • FixedCircularDeque

    constexpr auto v1 = []()
{
    FixedCircularDeque<int, 3> v{};
    v.push_back(2);
    v.emplace_back(3);
    v.push_front(1);
    v.emplace_front(0);
    v.push_back(4);
    return v;
}();

static_assert(v1[0] == 1);
static_assert(v1[1] == 2);
static_assert(v1[2] == 4);
static_assert(v1.size() == 3);

  • FixedCircularQueue

    constexpr auto s1 = []()
{
    FixedCircularQueue<int, 3> v1{};
    v1.push(55);
    v1.push(66);
    v1.push(77);
    v1.push(88);
    v1.push(99);
    return v1;
}();

static_assert(s1.front() == 77);
static_assert(s1.back() == 99);
static_assert(s1.size() == 3);

  • FixedString

    constexpr auto v1 = []()
{
    FixedString<11> v{"012"};
    v.at(1) = 'b';

    return v;
}();

static_assert(v1.at(0) == '0');
static_assert(v1.at(1) == 'b');
static_assert(v1.at(2) == '2');
static_assert(v1.size() == 3);

  • FixedMap

    constexpr auto m1 = []()
{
    FixedMap<int, int, 11> m{};
    m.insert({2, 20});
    m[4] = 40;
    return m;
}();
static_assert(!m1.contains(1));
static_assert(m1.contains(2));
static_assert(m1.at(4) == 40);
static_assert(m1.size() == 2);
static_assert(m1.max_size() == 11);

  • FixedSet

    constexpr auto s1 = []()
{
    FixedSet<int, 11> s{};
    s.insert(2);
    s.insert(4);
    return s;
}();
static_assert(!s1.contains(1));
static_assert(s1.contains(2));
static_assert(s1.size() == 2);
static_assert(s1.max_size() == 11);

  • FixedUnorderedMap

    constexpr auto m1 = []()
{
    FixedUnorderedMap<int, int, 11> m{};
    m.insert({2, 20});
    m[4] = 40;
    return m;
}();
static_assert(!m1.contains(1));
static_assert(m1.contains(2));
static_assert(m1.at(4) == 40);
static_assert(m1.size() == 2);
static_assert(m1.max_size() == 11);

  • FixedUnorderedSet

    constexpr auto s1 = []()
{
    FixedUnorderedSet<int, 11> s{};
    s.insert(2);
    s.insert(4);
    return s;
}();
static_assert(!s1.contains(1));
static_assert(s1.contains(2));
static_assert(s1.size() == 2);
static_assert(s1.max_size() == 11);

  • EnumMap

    enum class Color { RED, YELLOW, BLUE};

constexpr auto m1 = []()
{
    EnumMap<Color, int> m{};
    m.insert({Color::RED, 20});
    m[Color::YELLOW] = 40;
    return m;
}();
static_assert(!m1.contains(Color::BLUE));
static_assert(m1.contains(Color::RED));
static_assert(m1.at(Color::YELLOW) == 40);
static_assert(m1.size() == 2);

// Ensures all keys are specified, at compile-time
constexpr auto m2 = EnumMap<Color, int>::create_with_all_entries({
    {Color::RED, 42},
    {Color::YELLOW, 7},
    {Color::BLUE, 6},
});

  • EnumSet

    enum class Color { RED, YELLOW, BLUE};

constexpr auto s1 = []()
{
    EnumSet<Color> s{};
    s.insert(Color::RED);
    s.insert(Color::YELLOW);
    return s;
}();
static_assert(!s1.contains(Color::BLUE));
static_assert(s1.contains(Color::RED));
static_assert(s1.size() == 2);

constexpr auto s2 = EnumSet<Color>::all(); // full set
constexpr auto s3 = EnumSet<Color>::none(); // empty set
constexpr auto s4 = EnumSet<Color>::complement_of(s2); // empty set

  • EnumArray

    constexpr EnumArray<TestEnum1, int> s1{{TestEnum1::ONE, 10}, {TestEnum1::FOUR, 40}};
static_assert(4 == s1.max_size());
static_assert(s1.at(TestEnum1::ONE) == 10);
static_assert(s1.at(TestEnum1::TWO) == 0);
static_assert(s1.at(TestEnum1::THREE) == 0);
static_assert(s1.at(TestEnum1::FOUR) == 40);

  • StringLiteral

    static constexpr const char* s = "blah"; // strlen==4, sizeof==8
static constexpr const char s[5] = "blah";  // strlen==4, sizeof==5 (null terminator)
static constexpr StringLiteral s = "blah";  // constexpr .size()==4

  • Using instances as non-type template parameters

    // Similarly to simple types like ints/enums and std::array,
// fixed_container instances can be used as template parameters
template <FixedVector<int, 5> /*MY_VEC*/>
constexpr void fixed_vector_instance_can_be_used_as_a_template_parameter()
{
}

void test()
{
    static constexpr FixedVector<int, 5> VEC1{};
    fixed_vector_instance_can_be_used_as_a_template_parameter<VEC1>();
}

Integration

cmake

find_package(fixed_containers CONFIG REQUIRED)
target_link_libraries(<your_binary> fixed_containers::fixed_containers)

bazel

Use the following in your WORKSPACE file:

http_archive(
    name = "fixed_containers",
    urls = ["https://github.com/teslamotors/fixed-containers/archive/<commit>.tar.gz"],
    strip_prefix = "fixed-containers-<commit>",
)

load("@fixed_containers//:fixed_containers_deps.bzl", "fixed_containers_deps")
fixed_containers_deps()

Then use in your targets like this:

cc_test(
    name = "test",
    srcs = ["test.cpp"],
    deps = [
        "@fixed_containers//:fixed_vector",
        "@fixed_containers//:enum_map",
        "@fixed_containers//:enum_set",
    ],
    copts = ["-std=c++20"],
)

Alternative

Since this is a header-only library, you can also:

  • Add the include/ folder to your includes
  • Get the dependencies. For example, with vcpkg:
vcpkg install magic-enum range-v3

Running the tests

cmake

  1. Build with the vcpkg toolchain file
mkdir build && cd build
cmake .. -DCMAKE_C_COMPILER=/bin/clang-13 -DCMAKE_CXX_COMPILER=/bin/clang++-13 -DCMAKE_TOOLCHAIN_FILE=/path/to/vcpkg/scripts/buildsystems/vcpkg.cmake
cmake --build .
  1. Run tests
ctest -C Debug

bazel

clang

  1. Build separately (optional)
CC=clang++-13 bazel build --config=clang ...
  1. Run tests
CC=clang++-13 bazel test --config=clang :all_tests

gcc

  1. Build separately (optional)
CC=g++-11 bazel build ...
  1. Run tests
CC=g++-11 bazel test :all_tests

Tested Compilers

  • Clang 13
  • GCC 11
  • MSVC++ 14.29 / Visual Studio 2019

Licensed under the MIT License

fixed-containers's People

Contributors

alexkaratarakis avatar quuxplusone avatar bobobalink avatar abeimler avatar sgauvin avatar fschopp avatar nolanholden avatar seven332 avatar toge avatar

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.