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 #5485 from pan-/non-copyable-warning 

Platform: Allow copy of non copyable objects
pull/5358/merge
Martin Kojtal 2017-11-16 16:14:42 +00:00 committed by GitHub
parent 1fa09fa43d 80c9f8bd2f
commit 4198695fab
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 152 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

201
platform/NonCopyable.h
View File

@ -16,153 +16,196 @@
#ifndef MBED_NONCOPYABLE_H_
#define MBED_NONCOPYABLE_H_
namespace mbed {
#if (!defined(MBED_DEBUG) && (MBED_CONF_PLATFORM_FORCE_NON_COPYABLE_ERROR == 0))
#include "mbed_toolchain.h"
#include "mbed_debug.h"
#endif
namespace mbed {
/**
* Inheriting from this class autogeneration of copy construction and copy
* assignement operations.
*
* Classes which are not value type should inherit privately from this class
* to avoid generation of invalid copy constructor or copy assignement operator
* which can lead to unoticeable programming errors.
*
* As an example consider the following signature:
*
* @code
* class Resource;
* Inheriting from this class autogeneration of copy construction and copy
* assignement operations.
*
* class Foo {
* public:
* Classes which are not value type should inherit privately from this class
* to avoid generation of invalid copy constructor or copy assignement operator
* which can lead to unoticeable programming errors.
*
* As an example consider the following signature:
*
* @code
* class Resource;
*
* class Foo {
* public:
* Foo() : _resource(new Resource()) { }
* ~Foo() { delete _resource; }
* ~Foo() { delete _resource; }
* private:
* Resource* _resource;
* }
*
*
* Foo get_foo();
*
*
* Foo foo = get_foo();
* @endcode
*
* There is a bug in this function, it returns a temporary value which will be
* byte copied into foo then destroyed. Unfortunately, internaly the Foo class
* manage a pointer to a Resource object. This pointer will be released when the
* temporary is destroyed and foo will manage a pointer to an already released
* @endcode
*
* There is a bug in this function, it returns a temporary value which will be
* byte copied into foo then destroyed. Unfortunately, internaly the Foo class
* manage a pointer to a Resource object. This pointer will be released when the
* temporary is destroyed and foo will manage a pointer to an already released
* Resource.
*
* Two issues has to be fixed in the example above:
* - Function signature has to be changed to reflect the fact that Foo
* instances cannot be copied. In that case accessor should return a
* reference to give access to objects already existing and managed.
*
* Two issues has to be fixed in the example above:
* - Function signature has to be changed to reflect the fact that Foo
* instances cannot be copied. In that case accessor should return a
* reference to give access to objects already existing and managed.
* Generator on the other hand should return a pointer to the created object.
*
* @code
*
* @code
* // return a reference to an already managed Foo instance
* Foo& get_foo();
* Foo& get_foo();
* Foo& foo = get_foo();
*
*
* // create a new Foo instance
* Foo* make_foo();
* Foo* m = make_foo();
* @endcode
*
* - Copy constructor and copy assignement operator has to be made private
* in the Foo class. It prevents unwanted copy of Foo objects. This can be
* done by declaring copy constructor and copy assignement in the private
*
* - Copy constructor and copy assignement operator has to be made private
* in the Foo class. It prevents unwanted copy of Foo objects. This can be
* done by declaring copy constructor and copy assignement in the private
* section of the Foo class.
*
* @code
* class Foo {
* public:
*
* @code
* class Foo {
* public:
* Foo() : _resource(new Resource()) { }
* ~Foo() { delete _resource; }
* ~Foo() { delete _resource; }
* private:
* // disallow copy operations
* // disallow copy operations
* Foo(const Foo&);
* Foo& operator=(const Foo&);
* // data members
* // data members
* Resource* _resource;
* }
* @endcode
*
* Another solution is to inherit privately from the NonCopyable class.
* It reduces the boiler plate needed to avoid copy operations but more
*
* Another solution is to inherit privately from the NonCopyable class.
* It reduces the boiler plate needed to avoid copy operations but more
* importantly it clarifies the programer intent and the object semantic.
*
* class Foo : private NonCopyable<Foo> {
* public:
* class Foo : private NonCopyable<Foo> {
* public:
* Foo() : _resource(new Resource()) { }
* ~Foo() { delete _resource; }
* ~Foo() { delete _resource; }
* private:
* Resource* _resource;
* }
*
* @tparam T The type that should be made non copyable. It prevent cases where
* the empty base optimization cannot be applied and therefore ensure that the
* cost of this semantic sugar is null.
*
* As an example, the empty base optimization is prohibited if one of the empty
* base class is also a base type of the first non static data member:
*
* @code
*
* @tparam T The type that should be made non copyable. It prevent cases where
* the empty base optimization cannot be applied and therefore ensure that the
* cost of this semantic sugar is null.
*
* As an example, the empty base optimization is prohibited if one of the empty
* base class is also a base type of the first non static data member:
*
* @code
* struct A { };
* struct B : A {
* struct B : A {
* int foo;
* };
* // thanks to empty base optimization, sizeof(B) == sizeof(int)
*
* struct C : A {
*
* struct C : A {
* B b;
* };
*
*
* // empty base optimization cannot be applied here because A from C and A from
* // B shall have a different address. In that case, with the alignement
* // B shall have a different address. In that case, with the alignement
* // sizeof(C) == 2* sizeof(int)
* @endcode
*
* The solution to that problem is to templatize the empty class to makes it
* unique to the type it is applied to:
*
* @code
*
* The solution to that problem is to templatize the empty class to makes it
* unique to the type it is applied to:
*
* @code
* template<typename T>
* struct A<T> { };
* struct B : A<B> {
* struct B : A<B> {
* int foo;
* };
* struct C : A<C> {
* struct C : A<C> {
* B b;
* };
*
* // empty base optimization can be applied B and C does not refer to the same
*
* // empty base optimization can be applied B and C does not refer to the same
* // kind of A. sizeof(C) == sizeof(B) == sizeof(int).
* @endcode
*
* @note Compile time errors are disabled if the develop or the release profile
* is used. To override this behavior and force compile time errors in all profile
* set the configuration parameter "platform.force-non-copyable-error" to true.
*/
template<typename T>
class NonCopyable {
class NonCopyable {
protected:
/**
/**
* Disalow construction of NonCopyable objects from outside of its hierarchy.
*/
NonCopyable() { }
/**
/**
* Disalow destruction of NonCopyable objects from outside of its hierarchy.
*/
~NonCopyable() { }
private:
#if (!defined(MBED_DEBUG) && (MBED_CONF_PLATFORM_FORCE_NON_COPYABLE_ERROR == 0))
/**
* Declare copy constructor as private, any attempt to copy construct
* NonCopyable copy constructor.
*
* A compile time warning is issued when this function is used and a runtime
* warning is printed when the copy construction of the non copyable happens.
*
* If you see this warning, your code is probably doing something unspecified.
* Copy of non copyable resources can lead to resource leak and random error.
*/
MBED_DEPRECATED("Invalid copy construction of a NonCopyable resource.")
NonCopyable(const NonCopyable&)
{
debug("Invalid copy construction of a NonCopyable resource: %s\r\n", MBED_PRETTY_FUNCTION);
}
/**
* NonCopyable copy assignment operator.
*
* A compile time warning is issued when this function is used and a runtime
* warning is printed when the copy construction of the non copyable happens.
*
* If you see this warning, your code is probably doing something unspecified.
* Copy of non copyable resources can lead to resource leak and random error.
*/
MBED_DEPRECATED("Invalid copy assignment of a NonCopyable resource.")
NonCopyable& operator=(const NonCopyable&)
{
debug("Invalid copy assignment of a NonCopyable resource: %s\r\n", MBED_PRETTY_FUNCTION);
return *this;
}
#else
private:
/**
* Declare copy constructor as private, any attempt to copy construct
* a NonCopyable will fail at compile time.
*/
NonCopyable(const NonCopyable&);
/**
* Declare copy assignement operator as private, any attempt to copy assign
* Declare copy assignement operator as private, any attempt to copy assign
* a NonCopyable will fail at compile time.
*/
NonCopyable& operator=(const NonCopyable&);
#endif
};
} // namespace mbed
} // namespace mbed
#endif /* MBED_NONCOPYABLE_H_ */

5
platform/mbed_lib.json
View File

@ -19,6 +19,11 @@
"default-serial-baud-rate": {
"help": "Default baud rate for a Serial or RawSerial instance (if not specified in the constructor)",
"value": 9600
},
"force-non-copyable-error": {
"help": "Force compile time error when a NonCopyable object is copied",
"value": false
}
},
"target_overrides": {

36
platform/mbed_toolchain.h
View File

@ -5,7 +5,7 @@
* \defgroup platform_toolchain Toolchain functions
* @{
*/
/* mbed Microcontroller Library
* Copyright (c) 2006-2013 ARM Limited
*
@ -63,7 +63,7 @@
*
* @note
* IAR does not support alignment greater than word size on the stack
*
*
* @code
* #include "mbed_toolchain.h"
*
@ -125,16 +125,16 @@
* should contain a regular function declaration to insure the function is emitted.
* A function marked weak will not be emitted if an alternative non-weak
* implementation is defined.
*
*
* @note
* Weak functions are not friendly to making code re-usable, as they can only
* be overridden once (and if they are multiply overridden the linker will emit
* no warning). You should not normally use weak symbols as part of the API to
* re-usable modules.
*
*
* @code
* #include "mbed_toolchain.h"
*
*
* MBED_WEAK void foo() {
* // a weak implementation of foo that can be overriden by a definition
* // without __weak
@ -173,9 +173,9 @@
*
* @code
* #include "mbed_toolchain.h"
*
*
* MBED_NOINLINE void foo() {
*
*
* }
* @endcode
*/
@ -195,9 +195,9 @@
*
* @code
* #include "mbed_toolchain.h"
*
*
* MBED_FORCEINLINE void foo() {
*
*
* }
* @endcode
*/
@ -216,7 +216,7 @@
*
* @code
* #include "mbed_toolchain.h"
*
*
* MBED_NORETURN void foo() {
* // must never return
* while (1) {}
@ -266,7 +266,7 @@
*
* @code
* #include "mbed_toolchain.h"
*
*
* MBED_DEPRECATED("don't foo any more, bar instead")
* void foo(int arg);
* @endcode
@ -330,6 +330,20 @@
#endif
#endif
/**
* Macro expanding to a string literal of the enclosing function name.
*
* The string returned takes into account language specificity and yield human
* readable content.
*
* As an example, if the macro is used within a C++ function then the string
* literal containing the function name will contain the complete signature of
* the function - including template parameters - and namespace qualifications.
*/
#ifndef MBED_PRETTY_FUNCTION
#define MBED_PRETTY_FUNCTION __PRETTY_FUNCTION__
#endif
#ifndef MBED_PRINTF
#if defined(__GNUC__) || defined(__CC_ARM)
#define MBED_PRINTF(format_idx, first_param_idx) __attribute__ ((__format__(__printf__, format_idx, first_param_idx)))