ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #4233 from sg-/fix-the-docs2 

[platform] Update doxygen comments
pull/4274/head
Anna Bridge 2017-05-04 15:12:54 +01:00 committed by GitHub
parent 0c2af26523 d503afc95f
commit aa80b55628
20 changed files with 173 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doxygen_options.json
View File

@ -5,8 +5,8 @@
"SEARCH_INCLUDES": "YES",
"INCLUDE_PATH": "",
"INCLUDE_FILE_PATTERNS": "",
"PREDEFINED": "DOXYGEN_ONLY \"MBED_DEPRECATED_SINCE(f, g)=\"",
"PREDEFINED": "DOXYGEN_ONLY \"MBED_DEPRECATED_SINCE(f, g)=\" \"MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, M)=\"",
"EXPAND_AS_DEFINED": "",
"SKIP_FUNCTION_MACROS": "NO",
"EXCLUDE_PATTERNS": "*/targets/* */features/FEATURE_*/* */features/mbedtls/* */features/nanostack/* */features/storage/* */features/unsupported/* */features/frameworks/* */features/filesystem/fat/* */BUILD/* */rtos/* */events/* */platform/* */cmsis/* */hal/* */features/*"
"EXCLUDE_PATTERNS": "*/tools/* */TESTS/* */targets/* */features/FEATURE_*/* */features/mbedtls/* */features/nanostack/* */features/storage/* */features/unsupported/* */features/frameworks/* */features/filesystem/fat/* */BUILD/* */rtos/* */events/* */cmsis/* */hal/* */features/*"
}

2
platform/CThunk.h
View File

@ -77,7 +77,7 @@ typedef void (*CThunkEntry)(void);
/**
* Class for created a pointer with data bound to it
*
* @Note Synchronization level: Not protected
* @note Synchronization level: Not protected
* @ingroup platform
*/
template<class T>

6
platform/CallChain.h
View File

@ -27,7 +27,7 @@ namespace mbed {
* sequence using CallChain::call(). Used mostly by the interrupt chaining code,
* but can be used for other purposes.
*
* @Note Synchronization level: Not protected
* @note Synchronization level: Not protected
*
* Example:
* @code
@ -114,8 +114,8 @@ public:
/** Add a function at the beginning of the chain
*
* @param tptr pointer to the object to call the member function on
* @param mptr pointer to the member function to be called
* @param obj pointer to the object to call the member function on
* @param method pointer to the member function to be called
*
* @returns
* The function object created for 'tptr' and 'mptr'

369
platform/Callback.h
View File

@ -58,6 +58,12 @@ namespace detail {
};
}
#define MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, M) \
typename detail::enable_if< \
detail::is_type<M, &F::operator()>::value && \
sizeof(F) <= sizeof(uintptr_t) \
>::type = detail::nil()
/** Callback class based on template specialization
*
* @note Synchronization level: Not protected
@ -160,50 +166,38 @@ public:
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(F f, typename detail::enable_if<
detail::is_type<R (F::*)(), &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)())) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(const F f, typename detail::enable_if<
detail::is_type<R (F::*)() const, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)() const)) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)() volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)() volatile)) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(const volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)() const volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)() const volatile)) {
generate(f);
}
@ -404,7 +398,7 @@ public:
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -412,16 +406,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(F f, typename detail::enable_if<
detail::is_type<R (F::*)(), &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)())) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -429,16 +420,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(const F f, typename detail::enable_if<
detail::is_type<R (F::*)() const, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)() const)) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -446,16 +434,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)() volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)() volatile)) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -463,10 +448,7 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(const volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)() const volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)() const volatile)) {
this->~Callback();
new (this) Callback(f);
}
@ -571,6 +553,8 @@ public:
/** Static thunk for passing as C-style function
* @param func Callback to call passed as void pointer
* @return the value as determined by func which is of
* type and determined by the signiture of func
*/
static R thunk(void *func) {
return static_cast<Callback*>(func)->call();
@ -756,50 +740,38 @@ public:
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0), &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0))) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(const F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0) const, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0) const)) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0) volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0) volatile)) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(const volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0) const volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0) const volatile)) {
generate(f);
}
@ -1000,7 +972,7 @@ public:
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -1008,16 +980,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0), &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0))) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -1025,16 +994,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(const F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0) const, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0) const)) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -1042,16 +1008,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0) volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0) volatile)) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -1059,10 +1022,7 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(const volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0) const volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0) const volatile)) {
this->~Callback();
new (this) Callback(f);
}
@ -1167,6 +1127,9 @@ public:
/** Static thunk for passing as C-style function
* @param func Callback to call passed as void pointer
* @param a0 An argument to be called with function func
* @return the value as determined by func which is of
* type and determined by the signiture of func
*/
static R thunk(void *func, A0 a0) {
return static_cast<Callback*>(func)->call(a0);
@ -1352,50 +1315,38 @@ public:
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1), &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1))) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(const F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1) const, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1) const)) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1) volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1) volatile)) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(const volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1) const volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1) const volatile)) {
generate(f);
}
@ -1596,7 +1547,7 @@ public:
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -1604,16 +1555,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1), &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1))) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -1621,16 +1569,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(const F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1) const, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1) const)) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -1638,16 +1583,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1) volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1) volatile)) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -1655,10 +1597,7 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(const volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1) const volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1) const volatile)) {
this->~Callback();
new (this) Callback(f);
}
@ -1763,6 +1702,10 @@ public:
/** Static thunk for passing as C-style function
* @param func Callback to call passed as void pointer
* @param a0 An argument to be called with function func
* @param a1 An argument to be called with function func
* @return the value as determined by func which is of
* type and determined by the signiture of func
*/
static R thunk(void *func, A0 a0, A1 a1) {
return static_cast<Callback*>(func)->call(a0, a1);
@ -1948,50 +1891,38 @@ public:
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2), &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2))) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(const F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2) const, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2) const)) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2) volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2) volatile)) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(const volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2) const volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2) const volatile)) {
generate(f);
}
@ -2192,7 +2123,7 @@ public:
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -2200,16 +2131,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2), &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2))) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -2217,16 +2145,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(const F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2) const, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2) const)) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -2234,16 +2159,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2) volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2) volatile)) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -2251,10 +2173,7 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(const volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2) const volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2) const volatile)) {
this->~Callback();
new (this) Callback(f);
}
@ -2359,6 +2278,11 @@ public:
/** Static thunk for passing as C-style function
* @param func Callback to call passed as void pointer
* @param a0 An argument to be called with function func
* @param a1 An argument to be called with function func
* @param a2 An argument to be called with function func
* @return the value as determined by func which is of
* type and determined by the signiture of func
*/
static R thunk(void *func, A0 a0, A1 a1, A2 a2) {
return static_cast<Callback*>(func)->call(a0, a1, a2);
@ -2544,50 +2468,38 @@ public:
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3), &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3))) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(const F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3) const, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3) const)) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3) volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3) volatile)) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(const volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3) const volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3) const volatile)) {
generate(f);
}
@ -2788,7 +2700,7 @@ public:
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -2796,16 +2708,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3), &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3))) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -2813,16 +2722,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(const F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3) const, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3) const)) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -2830,16 +2736,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3) volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3) volatile)) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -2847,10 +2750,7 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(const volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3) const volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3) const volatile)) {
this->~Callback();
new (this) Callback(f);
}
@ -2955,6 +2855,12 @@ public:
/** Static thunk for passing as C-style function
* @param func Callback to call passed as void pointer
* @param a0 An argument to be called with function func
* @param a1 An argument to be called with function func
* @param a2 An argument to be called with function func
* @param a3 An argument to be called with function func
* @return the value as determined by func which is of
* type and determined by the signiture of func
*/
static R thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3) {
return static_cast<Callback*>(func)->call(a0, a1, a2, a3);
@ -3140,50 +3046,38 @@ public:
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3, A4), &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4))) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(const F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3, A4) const, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4) const)) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3, A4) volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4) volatile)) {
generate(f);
}
/** Create a Callback with a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
*/
template <typename F>
Callback(const volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3, A4) const volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
Callback(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4) const volatile)) {
generate(f);
}
@ -3384,7 +3278,7 @@ public:
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -3392,16 +3286,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3, A4), &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4))) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -3409,16 +3300,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(const F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3, A4) const, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(const F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4) const)) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -3426,16 +3314,13 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3, A4) volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4) volatile)) {
this->~Callback();
new (this) Callback(f);
}
/** Attach a function object
* @param func Function object to attach
* @param f Function object to attach
* @note The function object is limited to a single word of storage
* @deprecated
* Replaced by simple assignment 'Callback cb = func'
@ -3443,10 +3328,7 @@ public:
template <typename F>
MBED_DEPRECATED_SINCE("mbed-os-5.4",
"Replaced by simple assignment 'Callback cb = func")
void attach(const volatile F f, typename detail::enable_if<
detail::is_type<R (F::*)(A0, A1, A2, A3, A4) const volatile, &F::operator()>::value &&
sizeof(F) <= sizeof(uintptr_t)
>::type = detail::nil()) {
void attach(const volatile F f, MBED_ENABLE_IF_CALLBACK_COMPATIBLE(F, R (F::*)(A0, A1, A2, A3, A4) const volatile)) {
this->~Callback();
new (this) Callback(f);
}
@ -3551,6 +3433,13 @@ public:
/** Static thunk for passing as C-style function
* @param func Callback to call passed as void pointer
* @param a0 An argument to be called with function func
* @param a1 An argument to be called with function func
* @param a2 An argument to be called with function func
* @param a3 An argument to be called with function func
* @param a4 An argument to be called with function func
* @return the value as determined by func which is of
* type and determined by the signiture of func
*/
static R thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
return static_cast<Callback*>(func)->call(a0, a1, a2, a3, a4);

2
platform/CircularBuffer.h
View File

@ -23,7 +23,7 @@ namespace mbed {
/** Templated Circular buffer class
*
* @Note Synchronization level: Interrupt safe
* @note Synchronization level: Interrupt safe
* @ingroup platform
*/
template<typename T, uint32_t BufferSize, typename CounterType = uint32_t>

3
platform/DirHandle.h
View File

@ -38,7 +38,7 @@ namespace mbed {
* reflect this.
*
* @note to create a directory, @see Dir
* @Note Synchronization level: Set by subclass
* @note Synchronization level: Set by subclass
* @ingroup platform
*/
class DirHandle {
@ -47,7 +47,6 @@ public:
/** Read the next directory entry
*
* @param path The buffer to read the null terminated path name in to
* @param ent The directory entry to fill out
* @return 1 on reading a filename, 0 at end of directory, negative error on failure
*/

2
platform/FileLike.h
View File

@ -28,7 +28,7 @@ namespace mbed {
* A file-like object is one that can be opened with fopen by
* fopen("/name", mode).
*
* @Note Synchronization level: Set by subclass
* @note Synchronization level: Set by subclass
* @ingroup platform
*/
class FileLike : public FileHandle, public FileBase {

4
platform/FileSystemLike.h
View File

@ -31,7 +31,7 @@ namespace mbed {
* Implementations must define at least open (the default definitions
* of the rest of the functions just return error values).
*
* @Note Synchronization level: Set by subclass
* @note Synchronization level: Set by subclass
* @ingroup platform
*/
class FileSystemLike : public FileBase {
@ -69,7 +69,7 @@ public:
/** Remove a file from the filesystem.
*
* @param filename the name of the file to remove.
* @param returns 0 on success, -1 on failure.
* @returns 0 on success, -1 on failure.
*/
virtual int remove(const char *filename) { (void) filename; return -1; };

2
platform/LocalFileSystem.h
View File

@ -67,7 +67,7 @@ protected:
* mbed Microcontroller. Once created, the standard C file access functions are used to open,
* read and write files.
*
* @Note Synchronization level: Thread safe
* @note Synchronization level: Thread safe
*
* Example:
* @code

6
platform/SingletonPtr.h
View File

@ -59,13 +59,13 @@ inline static void singleton_unlock(void)
/** Utility class for creating an using a singleton
*
* @Note Synchronization level: Thread safe
* @note Synchronization level: Thread safe
*
* @Note: This class must only be used in a static context -
* @note: This class must only be used in a static context -
* this class must never be allocated or created on the
* stack.
*
* @Note: This class is lazily initialized on first use.
* @note: This class is lazily initialized on first use.
* This class is a POD type so if it is not used it will
* be garbage collected.
* @ingroup platform

2
platform/Stream.h
View File

@ -32,7 +32,7 @@ extern char* mbed_gets(char *s, int size, FILE *_file);
/** File stream
*
* @Note Synchronization level: Set by subclass
* @note Synchronization level: Set by subclass
* @ingroup platform
*/
class Stream : public FileLike {

2
platform/Transaction.h
View File

@ -37,7 +37,7 @@ typedef struct {
/** Transaction class defines a transaction.
*
* @Note Synchronization level: Not protected
* @note Synchronization level: Not protected
* @ingroup platform
*/
template<typename Class>

2
platform/mbed_application.h
View File

@ -21,7 +21,7 @@
#include<stdint.h>
#define MBED_APPLICATION_SUPPORT (defined(__CORTEX_M3) || defined(__CORTEX_M4) || defined(__CORTEX_M7))
#define MBED_APPLICATION_SUPPORT defined(__CORTEX_M3) || defined(__CORTEX_M4) || defined(__CORTEX_M7)
#if MBED_APPLICATION_SUPPORT
#ifdef __cplusplus
extern "C" {

22
platform/mbed_critical.h
View File

@ -33,7 +33,7 @@ extern "C" {
/** Determine the current interrupts enabled state
*
* This function can be called to determine whether or not interrupts are currently enabled.
* \note
* @note
* NOTE:
* This function works for both cortex-A and cortex-M, although the underlyng implementation
* differs.
@ -44,7 +44,7 @@ bool core_util_are_interrupts_enabled(void);
/** Mark the start of a critical section
*
* This function should be called to mark the start of a critical section of code.
* \note
* @note
* NOTES:
* 1) The use of this style of critical section is targetted at C based implementations.
* 2) These critical sections can be nested.
@ -57,7 +57,7 @@ void core_util_critical_section_enter(void);
/** Mark the end of a critical section
*
* This function should be called to mark the end of a critical section of code.
* \note
* @note
* NOTES:
* 1) The use of this style of critical section is targetted at C based implementations.
* 2) These critical sections can be nested.
@ -82,7 +82,7 @@ void core_util_critical_section_exit(void);
* @param[in,out] expectedCurrentValue A pointer to some location holding the
* expected current value of the data being set atomically.
* The computed 'desiredValue' should be a function of this current value.
* @Note: This is an in-out parameter. In the
* @note: This is an in-out parameter. In the
* failure case of atomic_cas (where the
* destination isn't set), the pointee of expectedCurrentValue is
* updated with the current value.
@ -105,7 +105,7 @@ void core_util_critical_section_exit(void);
* return true
* }
*
* @Note: In the failure case (where the destination isn't set), the value
* @note: In the failure case (where the destination isn't set), the value
* pointed to by expectedCurrentValue is still updated with the current value.
* This property helps writing concise code for the following incr:
*
@ -135,7 +135,7 @@ bool core_util_atomic_cas_u8(uint8_t *ptr, uint8_t *expectedCurrentValue, uint8_
* @param[in,out] expectedCurrentValue A pointer to some location holding the
* expected current value of the data being set atomically.
* The computed 'desiredValue' should be a function of this current value.
* @Note: This is an in-out parameter. In the
* @note: This is an in-out parameter. In the
* failure case of atomic_cas (where the
* destination isn't set), the pointee of expectedCurrentValue is
* updated with the current value.
@ -158,7 +158,7 @@ bool core_util_atomic_cas_u8(uint8_t *ptr, uint8_t *expectedCurrentValue, uint8_
* return true
* }
*
* @Note: In the failure case (where the destination isn't set), the value
* @note: In the failure case (where the destination isn't set), the value
* pointed to by expectedCurrentValue is still updated with the current value.
* This property helps writing concise code for the following incr:
*
@ -188,7 +188,7 @@ bool core_util_atomic_cas_u16(uint16_t *ptr, uint16_t *expectedCurrentValue, uin
* @param[in,out] expectedCurrentValue A pointer to some location holding the
* expected current value of the data being set atomically.
* The computed 'desiredValue' should be a function of this current value.
* @Note: This is an in-out parameter. In the
* @note: This is an in-out parameter. In the
* failure case of atomic_cas (where the
* destination isn't set), the pointee of expectedCurrentValue is
* updated with the current value.
@ -211,7 +211,7 @@ bool core_util_atomic_cas_u16(uint16_t *ptr, uint16_t *expectedCurrentValue, uin
* return true
* }
*
* @Note: In the failure case (where the destination isn't set), the value
* @note: In the failure case (where the destination isn't set), the value
* pointed to by expectedCurrentValue is still updated with the current value.
* This property helps writing concise code for the following incr:
*
@ -241,7 +241,7 @@ bool core_util_atomic_cas_u32(uint32_t *ptr, uint32_t *expectedCurrentValue, uin
* @param[in,out] expectedCurrentValue A pointer to some location holding the
* expected current value of the data being set atomically.
* The computed 'desiredValue' should be a function of this current value.
* @Note: This is an in-out parameter. In the
* @note: This is an in-out parameter. In the
* failure case of atomic_cas (where the
* destination isn't set), the pointee of expectedCurrentValue is
* updated with the current value.
@ -264,7 +264,7 @@ bool core_util_atomic_cas_u32(uint32_t *ptr, uint32_t *expectedCurrentValue, uin
* return true
* }
*
* @Note: In the failure case (where the destination isn't set), the value
* @note: In the failure case (where the destination isn't set), the value
* pointed to by expectedCurrentValue is still updated with the current value.
* This property helps writing concise code for the following incr:
*

2
platform/mbed_error.h
View File

@ -53,7 +53,7 @@
* if(x >= 5) {
* error("expected x to be less than 5, but got %d", x);
* }
* #endcode
* @endcode
*/
#ifdef __cplusplus

4
platform/mbed_interface.h
View File

@ -115,14 +115,14 @@ void mbed_die(void);
/** Print out an error message. This is typically called when
* hanlding a crash.
*
* @Note Synchronization level: Interrupt safe
* @note Synchronization level: Interrupt safe
*/
void mbed_error_printf(const char* format, ...);
/** Print out an error message. Similar to mbed_error_printf
* but uses a va_list.
*
* @Note Synchronization level: Interrupt safe
* @note Synchronization level: Interrupt safe
*/
void mbed_error_vfprintf(const char * format, va_list arg);

14
platform/mbed_mem_trace.h
View File

@ -80,7 +80,7 @@ void *mbed_mem_trace_malloc(void *res, size_t size, void *caller);
* @param res the result of running 'realloc'.
* @param ptr the 'ptr' argument given to 'realloc'.
* @param size the 'size' argument given to 'realloc'.
*
* @param caller the caller of the memory operation.
* @return 'res' (the first argument).
*/
void *mbed_mem_trace_realloc(void *res, void *ptr, size_t size, void *caller);
@ -88,10 +88,10 @@ void *mbed_mem_trace_realloc(void *res, void *ptr, size_t size, void *caller);
/**
* Trace a call to 'calloc'.
* @param res the result of running 'calloc'.
* @param nmemb the 'nmemb' argument given to 'calloc'.
* @param num the 'nmemb' argument given to 'calloc'.
* @param size the 'size' argument given to 'calloc'.
* @param caller the caller of the memory operation.
* @Return 'res' (the first argument).
* @return 'res' (the first argument).
*/
void *mbed_mem_trace_calloc(void *res, size_t num, size_t size, void *caller);
@ -108,13 +108,13 @@ void mbed_mem_trace_free(void *ptr, void *caller);
*
* The default callback outputs trace data using 'printf', in a format that's
* easily parsable by an external tool. For each memory operation, the callback
* outputs a line that begins with '#<op>:<0xresult>;<0xcaller>-':
* outputs a line that begins with "#<op>:<0xresult>;<0xcaller>-":
*
* - 'op' identifies the memory operation ('m' for 'malloc', 'r' for 'realloc',
* 'c' for 'calloc' and 'f' for 'free').
* - 'result' (base 16) is the result of the memor operation. This is always NULL
* for 'free', since 'free' doesn't return anything.
* -'caller' (base 16) is the caller of the memory operation. Note that the value
* - 'caller' (base 16) is the caller of the memory operation. Note that the value
* of 'caller' might be unreliable.
*
* The rest of the output depends on the operation being traced:
@ -126,9 +126,9 @@ void mbed_mem_trace_free(void *ptr, void *caller);
*
* Examples:
*
* - '#m:0x20003240;0x600d-50' encodes a 'malloc' that returned 0x20003240, was called
* - "#m:0x20003240;0x600d-50" encodes a 'malloc' that returned 0x20003240, was called
* by the instruction at 0x600D with a the 'size' argument equal to 50.
* - '#f:0x0;0x602f-0x20003240' encodes a 'free' that was called by the instruction at
* - "#f:0x0;0x602f-0x20003240" encodes a 'free' that was called by the instruction at
* 0x602f with the 'ptr' argument equal to 0x20003240.
*/
void mbed_mem_trace_default_callback(uint8_t op, void *res, void *caller, ...);

4
platform/mbed_rtc_time.h
View File

@ -61,7 +61,7 @@ extern "C" {
*
* @param t Number of seconds since January 1, 1970 (the UNIX timestamp)
*
* @Note Synchronization level: Thread safe
* @note Synchronization level: Thread safe
*
* Example:
* @code
@ -76,7 +76,7 @@ void set_time(time_t t);
/** Attach an external RTC to be used for the C time functions
*
* @Note Synchronization level: Thread safe
* @note Synchronization level: Thread safe
*
* @param read_rtc pointer to function which returns current UNIX timestamp
* @param write_rtc pointer to function which sets current UNIX timestamp, can be NULL

1
platform/mbed_wait_api.h
View File

@ -41,6 +41,7 @@ extern "C" {
* wait(0.5);
* }
* }
* @endcode
*/
/** Waits for a number of seconds, with microsecond resolution (within

2
platform/toolchain.h
View File

@ -24,3 +24,5 @@
#include "platform/mbed_toolchain.h"
#endif
/** @}*/