BlackMATov/flat.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/flat.hpp.git synced 2025-12-15 02:12:23 +07:00
Code Issues Packages Projects Releases Wiki Activity

add set and map ctors

Browse Source
This commit is contained in:
Matvey Cherevko
2019-05-04 10:17:52 +07:00
parent f894776576
commit 33fd5f964a
4 changed files with 256 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
flat_map.hpp
View File

@@ -9,8 +9,11 @@
#include <vector>
#include <memory>
#include <utility>
#include <iterator>
#include <algorithm>
#include <functional>
#include <type_traits>
#include <initializer_list>
namespace flat_hpp
{
@@ -40,5 +43,84 @@ namespace flat_hpp
using const_iterator = typename data_type::const_iterator;
using reverse_iterator = typename data_type::reverse_iterator;
using const_reverse_iterator = typename data_type::const_reverse_iterator;
static_assert(
std::is_same<typename allocator_type::value_type, value_type>::value,
"Allocator::value_type must be same type as value_type");
public:
explicit flat_map(
const Allocator& a)
: data_(a) {}
explicit flat_map(
const Compare& c = Compare(),
const Allocator& a = Allocator())
: data_(a)
, compare_(c) {}
template < typename InputIter >
flat_map(
InputIter first,
InputIter last,
const Allocator& a)
: data_(a) {
insert(first, last);
}
template < typename InputIter >
flat_map(
InputIter first,
InputIter last,
const Compare& c = Compare(),
const Allocator& a = Allocator())
: data_(a)
, compare_(c) {
insert(first, last);
}
flat_map(
std::initializer_list<value_type> il,
const Allocator& a)
: data_(a) {
insert(il.begin(), il.end());
}
flat_map(
std::initializer_list<value_type> il,
const Compare& c = Compare(),
const Allocator& a = Allocator())
: data_(a)
, compare_(c) {
insert(il.begin(), il.end());
}
iterator begin() noexcept { return data_.begin(); }
const_iterator begin() const noexcept { return data_.begin(); }
iterator end() noexcept { return data_.end(); }
const_iterator end() const noexcept { return data_.end(); }
reverse_iterator rbegin() noexcept { return data_.rbegin(); }
const_reverse_iterator rbegin() const noexcept { return data_.rbegin(); }
reverse_iterator rend() noexcept { return data_.rend(); }
const_reverse_iterator rend() const noexcept { return data_.rend(); }
std::pair<iterator, bool> insert(value_type&& value) {
//TODO(BlackMat): implme
return std::make_pair(end(), false);
}
std::pair<iterator, bool> insert(const value_type& value) {
//TODO(BlackMat): implme
return std::make_pair(end(), false);
}
template < typename InputIter >
void insert(InputIter first, InputIter last) {
for ( auto iter = first; iter != last; ++iter ) {
insert(*iter);
}
}
private:
data_type data_;
key_compare compare_;
};
}

51
flat_map_tests.cpp
View File

@@ -8,15 +8,30 @@
#include "catch.hpp"
#include "flat_map.hpp"
namespace flat = flat_hpp;
using namespace flat_hpp;
namespace
{
template < typename T >
class dummy_allocator {
public:
using value_type = T;
T* allocate(std::size_t n) {
(void)n;
return nullptr;
}
void deallocate(T* p, std::size_t n) {
(void)p;
(void)n;
}
};
}
TEST_CASE("flat_map") {
{
using map_t = flat::flat_map<int, unsigned>;
using map_t = flat_map<int, unsigned>;
static_assert(
std::is_same<map_t::key_type, int>::value,
@@ -49,4 +64,36 @@ TEST_CASE("flat_map") {
std::is_same<map_t::const_pointer, const std::pair<const int, unsigned>*>::value,
"unit test static error");
}
{
using alloc_t = dummy_allocator<
std::pair<const int,unsigned>>;
using map_t = flat_map<
int,
unsigned,
std::less<int>,
alloc_t>;
{
auto s0 = map_t();
auto s1 = map_t(alloc_t());
auto s2 = map_t(std::less<int>());
auto s3 = map_t(std::less<int>(), alloc_t());
}
{
std::vector<std::pair<const int,unsigned>> v;
auto s0 = map_t(v.cbegin(), v.cend());
auto s1 = map_t(v.cbegin(), v.cend(), alloc_t());
auto s2 = map_t(v.cbegin(), v.cend(), std::less<int>());
auto s3 = map_t(v.cbegin(), v.cend(), std::less<int>(), alloc_t());
}
{
auto s0 = map_t({{0,1}, {1,2}});
auto s1 = map_t({{0,1}, {1,2}}, alloc_t());
auto s2 = map_t({{0,1}, {1,2}}, std::less<int>());
auto s3 = map_t({{0,1}, {1,2}}, std::less<int>(), alloc_t());
}
}
}

82
flat_set.hpp
View File

@@ -9,8 +9,11 @@
#include <vector>
#include <memory>
#include <utility>
#include <iterator>
#include <algorithm>
#include <functional>
#include <type_traits>
#include <initializer_list>
namespace flat_hpp
{
@@ -39,5 +42,84 @@ namespace flat_hpp
using const_iterator = typename data_type::const_iterator;
using reverse_iterator = typename data_type::reverse_iterator;
using const_reverse_iterator = typename data_type::const_reverse_iterator;
static_assert(
std::is_same<typename allocator_type::value_type, value_type>::value,
"Allocator::value_type must be same type as value_type");
public:
explicit flat_set(
const Allocator& a)
: data_(a) {}
explicit flat_set(
const Compare& c = Compare(),
const Allocator& a = Allocator())
: data_(a)
, compare_(c) {}
template < typename InputIter >
flat_set(
InputIter first,
InputIter last,
const Allocator& a)
: data_(a) {
insert(first, last);
}
template < typename InputIter >
flat_set(
InputIter first,
InputIter last,
const Compare& c = Compare(),
const Allocator& a = Allocator())
: data_(a)
, compare_(c) {
insert(first, last);
}
flat_set(
std::initializer_list<value_type> il,
const Allocator& a)
: data_(a) {
insert(il.begin(), il.end());
}
flat_set(
std::initializer_list<value_type> il,
const Compare& c = Compare(),
const Allocator& a = Allocator())
: data_(a)
, compare_(c) {
insert(il.begin(), il.end());
}
iterator begin() noexcept { return data_.begin(); }
const_iterator begin() const noexcept { return data_.begin(); }
iterator end() noexcept { return data_.end(); }
const_iterator end() const noexcept { return data_.end(); }
reverse_iterator rbegin() noexcept { return data_.rbegin(); }
const_reverse_iterator rbegin() const noexcept { return data_.rbegin(); }
reverse_iterator rend() noexcept { return data_.rend(); }
const_reverse_iterator rend() const noexcept { return data_.rend(); }
std::pair<iterator, bool> insert(value_type&& value) {
//TODO(BlackMat): implme
return std::make_pair(end(), false);
}
std::pair<iterator, bool> insert(const value_type& value) {
//TODO(BlackMat): implme
return std::make_pair(end(), false);
}
template < typename InputIter >
void insert(InputIter first, InputIter last) {
for ( auto iter = first; iter != last; ++iter ) {
insert(*iter);
}
}
private:
data_type data_;
key_compare compare_;
};
}

45
flat_set_tests.cpp
View File

@@ -8,15 +8,30 @@
#include "catch.hpp"
#include "flat_set.hpp"
namespace flat = flat_hpp;
using namespace flat_hpp;
namespace
{
template < typename T >
class dummy_allocator {
public:
using value_type = T;
T* allocate(std::size_t n) {
(void)n;
return nullptr;
}
void deallocate(T* p, std::size_t n) {
(void)p;
(void)n;
}
};
}
TEST_CASE("flat_set") {
{
using set_t = flat::flat_set<int>;
using set_t = flat_set<int>;
static_assert(
std::is_same<set_t::key_type, int>::value,
@@ -46,4 +61,30 @@ TEST_CASE("flat_set") {
std::is_same<set_t::const_pointer, const int*>::value,
"unit test static error");
}
{
using alloc_t = dummy_allocator<int>;
using set_t = flat_set<int, std::less<int>, alloc_t>;
{
auto s0 = set_t();
auto s1 = set_t(alloc_t());
auto s2 = set_t(std::less<int>());
auto s3 = set_t(std::less<int>(), alloc_t());
}
{
std::vector<int> v;
auto s0 = set_t(v.cbegin(), v.cend());
auto s1 = set_t(v.cbegin(), v.cend(), alloc_t());
auto s2 = set_t(v.cbegin(), v.cend(), std::less<int>());
auto s3 = set_t(v.cbegin(), v.cend(), std::less<int>(), alloc_t());
}
{
auto s0 = set_t({0,1,2});
auto s1 = set_t({0,1,2}, alloc_t());
auto s2 = set_t({0,1,2}, std::less<int>());
auto s3 = set_t({0,1,2}, std::less<int>(), alloc_t());
}
}
}