* Optimise clearing by adding `nullptr` overload. This overload means
`Callback(NULL)` or `Callback(0)` will no longer work; users must
use `Callback(nullptr)` or `Callback()`.
* Optimise clearing by not clearing storage - increases code size of
comparison, but that is extremely rare.
* Reduce ROM used by trivial functors - share copy/destroy code.
* Config option to force trivial functors - major ROM saving by
eliminating the "operations" table.
* Config option to eliminate comparison altogether - minor ROM saving by
eliminating zero padding.
* Conform more to `std::function` API.
Use tag dispatch to better handle both NetworkInterface and NetworkStack
pointers.
The previous design was intended to avoid ambiguities when presented
with a scenario like
class MyDevice : public NetworkInterface, public NetworkStack {
};
TCPSocket(&MyDevice);
// Need NetworkStack *: use NetworkInterface::get_stack or
// cast to NetworkStack?
But the previous solution didn't actually work as intended. The overload
pair
nsapi_create_stack(NetworkStack *);
// versus
template <class IF>
nsapi_create_stack(IF *);
would only select the first form if passed an exact match -
`NetworkStack *`. If passed a derived class pointer, like `MyDevice *`,
it would select the template.
This meant that an ambiguity for MyDevice was at least avoided, but
in the wrong direction, potentially increasing code size.
But in other cases, the system just didn't work at all - you couldn't
pass a `MyStack *` pointer, unless you cast it to `NetworkStack *`.
Quite a few bits of test code do this.
Add a small bit of tag dispatch to prioritise the cast whenever the
supplied pointer is convertible to `NetworkStack *`.
New members are added to the network interface
-getaddrinfo
-getaddrinfo_async
gethostbyname is unchanged but gethostbyname_async result param now contains results od DNS records found.
Test cases for sync/async added added to DNS test folder.
The nsapi_dns tests were cross-class tests anyway, going through nsapi_dns and UDPSocket. Now they also include EthernetInterface and only mock the NetworkStack, which makes them the most cross-class module test we could think of in netsocket module.
Earlier all unittests ended up having all flags in common from all unittest targets.
This is now improved by using googletest provided mechanism to set build time compile options
All cmake files have been modified to reflect changes (when needed)
Could not figure out a syntax for {0x00, 0x00, ..., 0x00} intitializer list yet,
so those needs to be setup by updating C/CXX flags.
GoogleTest allows you to check whether certain function throws errors.
For example:
ASSERT_ANY_THROW(mbed::HeapBlockDevice one(3050, 100));
or
ASSERT_NO_THROW(bd.init());
As MBED_ERROR is now only function that can throw errors, there is
no need to check the type of thrown object.
MBED_DEPRECATE macros is added to string-based APIs.
New, non-string-based APIs are added in their place.
Wiced binaries rebuilt
Any existing stubs or mocks are adjusted to compile and run with the newly added non-string based functions.
Protocols like mdns requires IPv6 link local address to be advertised in its
records (AAAA record). LWIP::Interface::bringup() API is creating IPv6 link
local address;But as of now there is no API exposed by mbed-os to get the
IPv6 link local address.
This new API is required to deliver mDNS library support on mbed-os for Cypress
platforms. Unit tested it by invoking get_ipv6_link_local_address with a simple
application.
- Changed the process into static method
- used the singletonptr for creating the low power ticker instance
- Added the mbed stub into cmake build for cellularnonipsocket,loramacrypto
Reimplement atomic code in inline assembly. This can improve
optimisation, and avoids potential architectural problems with using
LDREX/STREX intrinsics.
API further extended:
* Bitwise operations (fetch_and/fetch_or/fetch_xor)
* fetch_add and fetch_sub (like incr/decr, but returning old value -
aligning with C++11)
* compare_exchange_weak
* Explicit memory order specification
* Basic freestanding template overloads for C++
This gives our existing C implementation essentially all the functionality
needed by C++11.
An actual Atomic<T> template based upon these C functions could follow.
When using NetworkInterface::get_default_instance() application gets handle
to CellularInterface which is actually CellularContext derived from CellularInterface.
Application needs also handle to CellularDevice to open other interfaces.
Ari Parkkila
Martin Kojtal
Arto Kinnunen
Kimmo Vaisanen
Kevin Bracey
Anna Bridge
Michal Paszta
Antti Kauppila
Tymoteusz Bloch
Seppo Takalo
Jayasankar Nara
Balaji
Dominika Maziec
Dominika Maziec
Rajkumar Kanagaraj
Teppo Järvelin
Veijo Pesonen