coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-06-26 20:38:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'feature/message_router_registry' into development

Browse Source
This commit is contained in:
John Wellbelove 2021-03-06 12:59:11 +00:00
commit 0b580490ff
2 changed files with 248 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

198
include/etl/message_router_registry.h
View File

@ -37,6 +37,7 @@ SOFTWARE.
#include "flat_map.h"
#include "exception.h"
#include "error_handler.h"
#include "iterator.h"
#undef ETL_FILE
#define ETL_FILE ETL_MESSAGE_ROUTER_REGISTRY
@ -74,8 +75,203 @@ namespace etl
//***************************************************************************
class imessage_router_registry
{
private:
typedef etl::iflat_map<etl::message_router_id_t, etl::imessage_router*> IRegistry;
public:
class const_iterator;
//********************************************
/// Iterator
//********************************************
class iterator : etl::iterator<ETL_OR_STD::forward_iterator_tag, etl::imessage_router*>
{
public:
friend class imessage_router_registry;
friend class const_iterator;
//********************************************
iterator()
{
}
//********************************************
iterator(const iterator& other)
: itr(other.itr)
{
}
//********************************************
iterator& operator =(const iterator& other)
{
itr = other.itr;
}
//********************************************
etl::imessage_router* operator *()
{
return itr->second;
}
//********************************************
const etl::imessage_router* operator *() const
{
return itr->second;
}
//********************************************
iterator& operator ++()
{
++itr;
return *this;
}
//********************************************
iterator operator ++(int)
{
iterator temp(*this);
++itr;
return temp;
}
//********************************************
friend bool operator ==(const iterator& lhs, const iterator& rhs)
{
return lhs.itr == rhs.itr;
}
//********************************************
friend bool operator !=(const iterator& lhs, const iterator& rhs)
{
return !(lhs == rhs);
}
private:
//********************************************
iterator(typename IRegistry::iterator itr_)
: itr(itr_)
{
}
typename IRegistry::iterator itr;
};
//********************************************
/// Const Iterator
//********************************************
class const_iterator : etl::iterator<ETL_OR_STD::forward_iterator_tag, const etl::imessage_router*>
{
public:
friend class imessage_router_registry;
//********************************************
const_iterator()
{
}
//********************************************
const_iterator(const typename imessage_router_registry::iterator& other)
: itr(other.itr)
{
}
//********************************************
const_iterator(const const_iterator& other)
: itr(other.itr)
{
}
//********************************************
const_iterator& operator =(const const_iterator& other)
{
itr = other.itr;
}
//********************************************
const etl::imessage_router* operator *() const
{
return itr->second;
}
//********************************************
const_iterator& operator ++()
{
++itr;
return *this;
}
//********************************************
const_iterator operator ++(int)
{
const_iterator temp(*this);
++itr;
return temp;
}
//********************************************
friend bool operator ==(const const_iterator& lhs, const const_iterator& rhs)
{
return lhs.itr == rhs.itr;
}
//********************************************
friend bool operator !=(const const_iterator& lhs, const const_iterator& rhs)
{
return !(lhs == rhs);
}
private:
//********************************************
const_iterator(typename IRegistry::const_iterator itr_)
: itr(itr_)
{
}
typename IRegistry::const_iterator itr;
};
//********************************************
/// Get the beginning of the registry.
//********************************************
iterator begin()
{
return iterator(registry.begin());
}
const_iterator begin() const
{
return const_iterator(registry.cbegin());
}
const_iterator cbegin() const
{
return const_iterator(registry.cbegin());
}
//********************************************
/// Get the end of the registry.
//********************************************
iterator end()
{
return iterator(registry.end());
}
const_iterator end() const
{
return const_iterator(registry.cend());
}
const_iterator cend() const
{
return const_iterator(registry.cend());
}
//********************************************
/// Registers a router.
/// If the registry is full then an ETL assert is called.
@ -219,8 +415,6 @@ namespace etl
protected:
typedef etl::iflat_map<etl::message_router_id_t, etl::imessage_router*> IRegistry;
//********************************************
// Constructor.
//********************************************

64
test/test_message_router_registry.cpp
View File

@ -30,7 +30,7 @@ SOFTWARE.
#include "etl/message_router.h"
#include "etl/message_router_registry.h"
#include "etl/array.h"
#include "etl/vector.h"
//***************************************************************************
// The set of messages.
@ -180,9 +180,8 @@ namespace
//*************************************************************************
TEST(test_iterator_construction)
{
etl::array<etl::imessage_router*, Registry_Size> routers{ &router1, &router2, &router3, &router4 };
etl::message_router_registry<Registry_Size> registry(routers.begin(), routers.end());
etl::imessage_router* routers[] = { &router1, &router2, &router3, &router4 };
etl::message_router_registry<Registry_Size> registry(std::begin(routers), std::end(routers));
CHECK(!registry.empty());
CHECK(registry.full());
@ -194,11 +193,10 @@ namespace
//*************************************************************************
TEST(test_iterator_construction_excess)
{
etl::array<etl::imessage_router*, Registry_Size + 1U> routers{ &router1, &router2, &router3, &router4, &router5 };
etl::imessage_router* routers[] = { &router1, &router2, &router3, &router4, &router5 };
etl::message_router_registry<Registry_Size> registry;
CHECK_THROW((registry.add(routers.begin(), routers.end())), etl::message_router_registry_full);
CHECK_THROW((registry.add(std::begin(routers), std::end(routers))), etl::message_router_registry_full);
CHECK(!registry.empty());
CHECK(registry.full());
@ -207,6 +205,7 @@ namespace
CHECK_EQUAL(Registry_Size, registry.max_size());
}
#if ETL_USING_STL
//*************************************************************************
TEST(test_initializer_list_construction)
{
@ -230,11 +229,13 @@ namespace
CHECK_EQUAL(1U, registry.available());
CHECK_EQUAL(Registry_Size, registry.max_size());
}
#endif
//*************************************************************************
TEST(test_copy_construction)
{
etl::message_router_registry<Registry_Size> registry = { &router1, &router2, &router3, &router4 };
etl::imessage_router* routers[] = { &router1, &router2, &router3, &router4 };
etl::message_router_registry<Registry_Size> registry(std::begin(routers), std::end(routers));
etl::message_router_registry<Registry_Size> registry2(registry);
CHECK(!registry2.empty());
@ -247,7 +248,8 @@ namespace
//*************************************************************************
TEST(test_assignment)
{
etl::message_router_registry<Registry_Size> registry = { &router1, &router2, &router3, &router4 };
etl::imessage_router* routers[] = { &router1, &router2, &router3, &router4 };
etl::message_router_registry<Registry_Size> registry(std::begin(routers), std::end(routers));
etl::message_router_registry<Registry_Size> registry2;
registry2 = registry;
@ -262,7 +264,8 @@ namespace
//*************************************************************************
TEST(test_registery_contains)
{
etl::message_router_registry<Registry_Size> registry = { &router1, &router2, &router3 };
etl::imessage_router* routers[] = { &router1, &router2, &router3 };
etl::message_router_registry<Registry_Size> registry(std::begin(routers), std::end(routers));
CHECK(registry.contains(ROUTER1));
CHECK(registry.contains(ROUTER2));
@ -283,7 +286,8 @@ namespace
//*************************************************************************
TEST(test_get_message_router)
{
etl::message_router_registry<Registry_Size> registry = { &router1, &router2, &router3 };
etl::imessage_router* routers[] = { &router1, &router2, &router3 };
etl::message_router_registry<Registry_Size> registry(std::begin(routers), std::end(routers));
CHECK_EQUAL(&router1, registry.get(ROUTER1));
CHECK_EQUAL(&router2, registry.get(ROUTER2));
@ -294,7 +298,8 @@ namespace
//*************************************************************************
TEST(test_unregister_message_router)
{
etl::message_router_registry<Registry_Size> registry = { &router1, &router2, &router3, &router4 };
etl::imessage_router* routers[] = { &router1, &router2, &router3, &router4 };
etl::message_router_registry<Registry_Size> registry(std::begin(routers), std::end(routers));
registry.remove(ROUTER3);
@ -305,5 +310,40 @@ namespace
CHECK_EQUAL(nullptr, registry.get(ROUTER3));
CHECK_EQUAL(&router4, registry.get(ROUTER4));
}
//*************************************************************************
TEST(test_iterators)
{
etl::imessage_router* routers[] = { &router1, &router2, &router3, &router4 };
etl::message_router_registry<Registry_Size> registry(std::begin(routers), std::end(routers));
etl::message_router_registry<Registry_Size>::iterator bitr = registry.begin();
etl::message_router_registry<Registry_Size>::const_iterator cbitr = registry.begin();
etl::message_router_registry<Registry_Size>::const_iterator cbitr2 = registry.cbegin();
etl::message_router_registry<Registry_Size>::iterator eitr = registry.end();
etl::message_router_registry<Registry_Size>::const_iterator ceitr = registry.end();
etl::message_router_registry<Registry_Size>::const_iterator ceitr2 = registry.cend();
CHECK_EQUAL(&router1, *bitr++);
CHECK_EQUAL(&router1, *cbitr++);
CHECK_EQUAL(&router1, *cbitr2++);
CHECK_EQUAL(&router2, *bitr++);
CHECK_EQUAL(&router2, *cbitr++);
CHECK_EQUAL(&router2, *cbitr2++);
CHECK_EQUAL(&router3, *bitr++);
CHECK_EQUAL(&router3, *cbitr++);
CHECK_EQUAL(&router3, *cbitr2++);
CHECK_EQUAL(&router4, *bitr++);
CHECK_EQUAL(&router4, *cbitr++);
CHECK_EQUAL(&router4, *cbitr2++);
CHECK(bitr == eitr);
CHECK(cbitr == ceitr);
CHECK(cbitr2 == ceitr2);
}
};
}