atria-soft/ememory
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] update nullptr in null (specific etk)

Browse Source
This commit is contained in:
Edouard DUPIN 2018-06-19 22:15:52 +02:00
parent b872ff3646
commit 43685d778f
8 changed files with 179 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ememory/SharedPtr.hpp
View File

@ -65,7 +65,7 @@ namespace ememory {
#endif #endif
public: public:
/** /**
* @brief Contructor on nullptr * @brief Contructor on null
*/ */
SharedPtr(etk::NullPtr); SharedPtr(etk::NullPtr);
/** /**
@ -99,7 +99,7 @@ namespace ememory {
*/ */
SharedPtr& operator= (const SharedPtr<EMEMORY_TYPE>& _obj); SharedPtr& operator= (const SharedPtr<EMEMORY_TYPE>& _obj);
/** /**
* @brief Asignement operator (asign nullptr) * @brief Asignement operator (asign null)
* @return Reference on this * @return Reference on this
*/ */
SharedPtr& operator= (etk::NullPtr); SharedPtr& operator= (etk::NullPtr);
@ -125,7 +125,7 @@ namespace ememory {
*/ */
int64_t useCount() const; int64_t useCount() const;
/** /**
* @brief Check if the SharedPtr have an internal data (not nullptr) * @brief Check if the SharedPtr have an internal data (not null)
* @return true The pointer is not asigned, false otherwise * @return true The pointer is not asigned, false otherwise
*/ */
bool operator==(etk::NullPtr) const; bool operator==(etk::NullPtr) const;
@ -137,7 +137,7 @@ namespace ememory {
template<class EMEMORY_TYPE2> template<class EMEMORY_TYPE2>
bool operator==(const SharedPtr<EMEMORY_TYPE2>& _obj) const; bool operator==(const SharedPtr<EMEMORY_TYPE2>& _obj) const;
/** /**
* @brief Check if the SharedPtr have NOT an internal data (nullptr) * @brief Check if the SharedPtr have NOT an internal data (null)
* @return true The pointer is asigned, false otherwise * @return true The pointer is asigned, false otherwise
*/ */
bool operator!=(etk::NullPtr) const; bool operator!=(etk::NullPtr) const;

28
ememory/UniquePtr.hpp
View File

@ -19,13 +19,13 @@ namespace ememory {
UniquePtr &operator=(UniquePtr<EMEM_UPTR_TYPE_2> &) = delete; UniquePtr &operator=(UniquePtr<EMEM_UPTR_TYPE_2> &) = delete;
public: public:
UniquePtr() : UniquePtr() :
m_pointer(nullptr), m_pointer(null),
m_deleter(nullptr) { m_deleter(null) {
} }
UniquePtr(etk::NullPtr) : UniquePtr(etk::NullPtr) :
m_pointer(nullptr), m_pointer(null),
m_deleter(nullptr) { m_deleter(null) {
} }
explicit UniquePtr(EMEM_UPTR_TYPE* _obj, deleterCall&& _deleter = [](void* _data) { ETK_DELETE(EMEM_UPTR_TYPE, _data);}) : explicit UniquePtr(EMEM_UPTR_TYPE* _obj, deleterCall&& _deleter = [](void* _data) { ETK_DELETE(EMEM_UPTR_TYPE, _data);}) :
@ -35,8 +35,8 @@ namespace ememory {
} }
template <class EMEM_UPTR_TYPE_2> template <class EMEM_UPTR_TYPE_2>
UniquePtr(UniquePtr<EMEM_UPTR_TYPE_2>&& _obj) : UniquePtr(UniquePtr<EMEM_UPTR_TYPE_2>&& _obj) :
m_pointer(nullptr), m_pointer(null),
m_deleter(nullptr) { m_deleter(null) {
etk::swap(_obj.m_pointer, m_pointer); etk::swap(_obj.m_pointer, m_pointer);
etk::swap(_obj.m_deleter, m_deleter); etk::swap(_obj.m_deleter, m_deleter);
} }
@ -58,7 +58,7 @@ namespace ememory {
UniquePtr& operator=(UniquePtr<EMEM_UPTR_TYPE_2>& _obj){ UniquePtr& operator=(UniquePtr<EMEM_UPTR_TYPE_2>& _obj){
reset(); reset();
m_pointer = _obj.m_pointer; m_pointer = _obj.m_pointer;
_obj.m_pointer = nullptr; _obj.m_pointer = null;
return *this; return *this;
}*/ }*/
const EMEM_UPTR_TYPE& operator*() const { const EMEM_UPTR_TYPE& operator*() const {
@ -78,32 +78,32 @@ namespace ememory {
} }
EMEM_UPTR_TYPE *release(){ EMEM_UPTR_TYPE *release(){
EMEM_UPTR_TYPE *tmp = m_pointer; EMEM_UPTR_TYPE *tmp = m_pointer;
m_pointer = nullptr; m_pointer = null;
return tmp; return tmp;
} }
void reset(){ void reset(){
if (m_deleter != nullptr) { if (m_deleter != null) {
m_deleter(m_pointer); m_deleter(m_pointer);
} }
m_pointer = nullptr; m_pointer = null;
} }
void swap(UniquePtr &_obj){ void swap(UniquePtr &_obj){
etk::swap(_obj.m_pointer, m_pointer); etk::swap(_obj.m_pointer, m_pointer);
etk::swap(_obj.m_deleter, m_deleter); etk::swap(_obj.m_deleter, m_deleter);
} }
/** /**
* @brief Check if the UniquePtr have an internal data (not nullptr) * @brief Check if the UniquePtr have an internal data (not null)
* @return true The pointer is not asigned, false otherwise * @return true The pointer is not asigned, false otherwise
*/ */
bool operator==(etk::NullPtr) const { bool operator==(etk::NullPtr) const {
return m_pointer == nullptr; return m_pointer == null;
} }
/** /**
* @brief Check if the UniquePtr have not an internal data (equal nullptr) * @brief Check if the UniquePtr have not an internal data (equal null)
* @return true The pointer is asigned, false otherwise * @return true The pointer is asigned, false otherwise
*/ */
bool operator!=(etk::NullPtr) const { bool operator!=(etk::NullPtr) const {
return m_pointer != nullptr; return m_pointer != null;
} }
/* /*
template <class EMEM_UPTR_TYPE_2> template <class EMEM_UPTR_TYPE_2>

8
ememory/WeakPtr.hpp
View File

@ -29,7 +29,7 @@ namespace ememory {
*/ */
WeakPtr(); WeakPtr();
/** /**
* @brief nullptr contructor * @brief null contructor
*/ */
WeakPtr(etk::NullPtr); WeakPtr(etk::NullPtr);
private: private:
@ -68,7 +68,7 @@ namespace ememory {
*/ */
WeakPtr<EMEMORY_TYPE>& operator= (const SharedPtr<EMEMORY_TYPE>& _obj); WeakPtr<EMEMORY_TYPE>& operator= (const SharedPtr<EMEMORY_TYPE>& _obj);
/** /**
* @brief nullptr asignement * @brief null asignement
* @return Reference on this * @return Reference on this
*/ */
WeakPtr<EMEMORY_TYPE>& operator= (etk::NullPtr); WeakPtr<EMEMORY_TYPE>& operator= (etk::NullPtr);
@ -130,7 +130,7 @@ namespace ememory {
*/ */
bool operator==(const WeakPtr& _obj); bool operator==(const WeakPtr& _obj);
/** /**
* @brief Check if the WeakPtr have an internal data (not nullptr) * @brief Check if the WeakPtr have an internal data (not null)
* @return true The pointer is not asigned, false otherwise * @return true The pointer is not asigned, false otherwise
*/ */
bool operator==(etk::NullPtr) const; bool operator==(etk::NullPtr) const;
@ -141,7 +141,7 @@ namespace ememory {
*/ */
bool operator!=(const WeakPtr& _obj); bool operator!=(const WeakPtr& _obj);
/** /**
* @brief Check if the SharedPtr have NOT an internal data (nullptr) * @brief Check if the SharedPtr have NOT an internal data (null)
* @return true The pointer is asigned, false otherwise * @return true The pointer is asigned, false otherwise
*/ */
bool operator!=(etk::NullPtr) const; bool operator!=(etk::NullPtr) const;

148
ememory/details/SharedPtr.hxx
View File

@ -15,17 +15,17 @@ template<class EMEMORY_TYPE2,
, int>::type> , int>::type>
ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(EMEMORY_TYPE2* _element, deleterCall&& _deleter): ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(EMEMORY_TYPE2* _element, deleterCall&& _deleter):
m_element(_element), m_element(_element),
m_counter(nullptr), m_counter(null),
m_deleter(_deleter) { m_deleter(_deleter) {
EMEMORY_DBG("Create shared"); EMEMORY_DBG("Create shared");
if (m_element == nullptr) { if (m_element == null) {
return; return;
} }
EMEMORY_DBG("Check if the user use the memory allocator or personal system..."); EMEMORY_DBG("Check if the user use the memory allocator or personal system...");
ETK_MEM_CHECK_POINTER(_element); ETK_MEM_CHECK_POINTER(_element);
EMEMORY_DBG(" ==> get previous pointer"); EMEMORY_DBG(" ==> get previous pointer");
m_counter = m_element->weakFromThis().getCounter(); m_counter = m_element->weakFromThis().getCounter();
if (m_counter != nullptr) { if (m_counter != null) {
m_counter->incrementShared(); m_counter->incrementShared();
} }
return; return;
@ -40,10 +40,10 @@ template<class EMEMORY_TYPE2,
, int>::type> , int>::type>
ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(EMEMORY_TYPE2* _element, deleterCall&& _deleter): ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(EMEMORY_TYPE2* _element, deleterCall&& _deleter):
m_element(_element), m_element(_element),
m_counter(nullptr), m_counter(null),
m_deleter(_deleter) { m_deleter(_deleter) {
EMEMORY_DBG("Create shared"); EMEMORY_DBG("Create shared");
if (m_element == nullptr) { if (m_element == null) {
return; return;
} }
EMEMORY_DBG("Check if the user use the memory allocator or personal system..."); EMEMORY_DBG("Check if the user use the memory allocator or personal system...");
@ -53,16 +53,16 @@ ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(EMEMORY_TYPE2* _element, deleterCall
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(): ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr():
m_element(nullptr), m_element(null),
m_counter(nullptr), m_counter(null),
m_deleter(createDeleter()) { m_deleter(createDeleter()) {
EMEMORY_DBG("Create shared"); EMEMORY_DBG("Create shared");
} }
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(etk::NullPtr): ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(etk::NullPtr):
m_element(nullptr), m_element(null),
m_counter(nullptr), m_counter(null),
m_deleter(createDeleter()) { m_deleter(createDeleter()) {
EMEMORY_DBG("Create shared"); EMEMORY_DBG("Create shared");
} }
@ -73,8 +73,8 @@ ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(EMEMORY_TYPE* _obj, ememory::Counter
m_counter(_counter), m_counter(_counter),
m_deleter(createDeleter()) { m_deleter(createDeleter()) {
EMEMORY_DBG("Create shared (from a cast)"); EMEMORY_DBG("Create shared (from a cast)");
if (_obj == nullptr) { if (_obj == null) {
m_counter = nullptr; m_counter = null;
return; return;
} }
m_counter->incrementShared(); m_counter->incrementShared();
@ -91,14 +91,14 @@ ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(const ememory::SharedPtr<EMEMORY_TYP
m_element(_obj.m_element), m_element(_obj.m_element),
m_counter(_obj.m_counter), m_counter(_obj.m_counter),
m_deleter(_obj.m_deleter) { m_deleter(_obj.m_deleter) {
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
m_deleter = nullptr; m_deleter = null;
return; return;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return; return;
} }
m_counter->incrementShared(); m_counter->incrementShared();
@ -110,14 +110,14 @@ ememory::SharedPtr<EMEMORY_TYPE>& ememory::SharedPtr<EMEMORY_TYPE>::operator= (c
m_element = _obj.m_element; m_element = _obj.m_element;
m_counter = _obj.m_counter; m_counter = _obj.m_counter;
m_deleter = _obj.m_deleter; m_deleter = _obj.m_deleter;
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
m_deleter = nullptr; m_deleter = null;
return *this; return *this;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return *this; return *this;
} }
m_counter->incrementShared(); m_counter->incrementShared();
@ -137,9 +137,9 @@ ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(ememory::SharedPtr<EMEMORY_TYPE>&& _
m_element = _obj.m_element; m_element = _obj.m_element;
m_counter = _obj.m_counter; m_counter = _obj.m_counter;
m_deleter = _obj.m_deleter; m_deleter = _obj.m_deleter;
_obj.m_element = nullptr; _obj.m_element = null;
_obj.m_counter = nullptr; _obj.m_counter = null;
_obj.m_deleter = nullptr; _obj.m_deleter = null;
} }
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
@ -150,13 +150,13 @@ ememory::SharedPtr<EMEMORY_TYPE>::SharedPtr(const ememory::SharedPtr<EMEMORY_TYP
m_element(const_cast<EMEMORY_TYPE2*>(_obj.get())), m_element(const_cast<EMEMORY_TYPE2*>(_obj.get())),
m_counter(const_cast<ememory::Counter*>(_obj.getCounter())), m_counter(const_cast<ememory::Counter*>(_obj.getCounter())),
m_deleter(createDeleter()) { m_deleter(createDeleter()) {
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
return; return;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return; return;
} }
m_counter->incrementShared(); m_counter->incrementShared();
@ -171,13 +171,13 @@ ememory::SharedPtr<EMEMORY_TYPE>& ememory::SharedPtr<EMEMORY_TYPE>::operator= (c
m_element = const_cast<EMEMORY_TYPE2*>(_obj.get()); m_element = const_cast<EMEMORY_TYPE2*>(_obj.get());
m_counter = const_cast<ememory::Counter*>(_obj.getCounter()); m_counter = const_cast<ememory::Counter*>(_obj.getCounter());
m_deleter = createDeleter(); m_deleter = createDeleter();
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
return *this; return *this;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return *this; return *this;
} }
m_counter->incrementShared(); m_counter->incrementShared();
@ -186,9 +186,9 @@ ememory::SharedPtr<EMEMORY_TYPE>& ememory::SharedPtr<EMEMORY_TYPE>::operator= (c
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
void ememory::SharedPtr<EMEMORY_TYPE>::reset() { void ememory::SharedPtr<EMEMORY_TYPE>::reset() {
if(m_counter == nullptr) { if(m_counter == null) {
m_element = nullptr; // in case ... m_element = null; // in case ...
m_deleter = nullptr; m_deleter = null;
return; return;
} }
EMEMORY_DBG("reset sharedPtr (start)"); EMEMORY_DBG("reset sharedPtr (start)");
@ -196,8 +196,8 @@ void ememory::SharedPtr<EMEMORY_TYPE>::reset() {
switch(rmData) { switch(rmData) {
case ememory::Counter::remove::all: case ememory::Counter::remove::all:
ETK_DELETE(ememory::Counter, m_counter); ETK_DELETE(ememory::Counter, m_counter);
if (m_deleter != nullptr) { if (m_deleter != null) {
if (m_element != nullptr) { if (m_element != null) {
m_deleter((void*)m_element); m_deleter((void*)m_element);
} }
} else { } else {
@ -205,8 +205,8 @@ void ememory::SharedPtr<EMEMORY_TYPE>::reset() {
} }
break; break;
case ememory::Counter::remove::data: case ememory::Counter::remove::data:
if (m_deleter != nullptr) { if (m_deleter != null) {
if (m_element != nullptr) { if (m_element != null) {
m_deleter((void*)m_element); m_deleter((void*)m_element);
} }
} else { } else {
@ -219,15 +219,15 @@ void ememory::SharedPtr<EMEMORY_TYPE>::reset() {
case ememory::Counter::remove::none: case ememory::Counter::remove::none:
break; break;
} }
m_deleter = nullptr; m_deleter = null;
m_counter = nullptr; m_counter = null;
m_element = nullptr; m_element = null;
EMEMORY_DBG("reset sharedPtr (stop)"); EMEMORY_DBG("reset sharedPtr (stop)");
} }
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
int64_t ememory::SharedPtr<EMEMORY_TYPE>::useCount() const { int64_t ememory::SharedPtr<EMEMORY_TYPE>::useCount() const {
if (m_counter == nullptr) { if (m_counter == null) {
return 0; return 0;
} }
return m_counter->getCountShared(); return m_counter->getCountShared();
@ -235,7 +235,7 @@ int64_t ememory::SharedPtr<EMEMORY_TYPE>::useCount() const {
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
bool ememory::SharedPtr<EMEMORY_TYPE>::operator==(etk::NullPtr) const { bool ememory::SharedPtr<EMEMORY_TYPE>::operator==(etk::NullPtr) const {
return m_counter == nullptr; return m_counter == null;
} }
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
@ -246,7 +246,7 @@ bool ememory::SharedPtr<EMEMORY_TYPE>::operator==(const SharedPtr<EMEMORY_TYPE2>
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
bool ememory::SharedPtr<EMEMORY_TYPE>::operator!=(etk::NullPtr) const { bool ememory::SharedPtr<EMEMORY_TYPE>::operator!=(etk::NullPtr) const {
return m_counter != nullptr; return m_counter != null;
} }
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
@ -331,13 +331,13 @@ namespace ememory {
SharedPtr(void* _element); SharedPtr(void* _element);
public: public:
SharedPtr(etk::NullPtr): SharedPtr(etk::NullPtr):
m_element(nullptr), m_element(null),
m_counter(nullptr) { m_counter(null) {
EMEMORY_DBG("Create shared<void>"); EMEMORY_DBG("Create shared<void>");
} }
SharedPtr(): SharedPtr():
m_element(nullptr), m_element(null),
m_counter(nullptr) { m_counter(null) {
EMEMORY_DBG("Create shared<void>"); EMEMORY_DBG("Create shared<void>");
} }
~SharedPtr() { ~SharedPtr() {
@ -348,8 +348,8 @@ namespace ememory {
m_element(_obj), m_element(_obj),
m_counter(_counter) { m_counter(_counter) {
EMEMORY_DBG("Create shared (from a cast)"); EMEMORY_DBG("Create shared (from a cast)");
if (_obj == nullptr) { if (_obj == null) {
m_counter = nullptr; m_counter = null;
return; return;
} }
m_counter->incrementShared(); m_counter->incrementShared();
@ -361,20 +361,20 @@ namespace ememory {
SharedPtr(SharedPtr<void>&& _obj) { SharedPtr(SharedPtr<void>&& _obj) {
m_element = _obj.m_element; m_element = _obj.m_element;
m_counter = _obj.m_counter; m_counter = _obj.m_counter;
_obj.m_element = nullptr; _obj.m_element = null;
_obj.m_counter = nullptr; _obj.m_counter = null;
} }
template<class EMEMORY_TYPE2> template<class EMEMORY_TYPE2>
SharedPtr(const SharedPtr<EMEMORY_TYPE2>& _obj): SharedPtr(const SharedPtr<EMEMORY_TYPE2>& _obj):
m_element((void*)_obj.get()), m_element((void*)_obj.get()),
m_counter(_obj.getCounter()) { m_counter(_obj.getCounter()) {
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
return; return;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return; return;
} }
m_counter->incrementShared(); m_counter->incrementShared();
@ -384,13 +384,13 @@ namespace ememory {
reset(); reset();
m_element = (void*)_obj.get(); m_element = (void*)_obj.get();
m_counter = _obj.getCounter(); m_counter = _obj.getCounter();
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
return *this; return *this;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return *this; return *this;
} }
m_counter->incrementShared(); m_counter->incrementShared();
@ -398,8 +398,8 @@ namespace ememory {
} }
public: public:
void reset() { void reset() {
if(m_counter == nullptr) { if(m_counter == null) {
m_element = nullptr; // in case ... m_element = null; // in case ...
return; return;
} }
EMEMORY_DBG("reset sharedPtr (start)"); EMEMORY_DBG("reset sharedPtr (start)");
@ -418,25 +418,25 @@ namespace ememory {
case ememory::Counter::remove::none: case ememory::Counter::remove::none:
break; break;
} }
m_counter = nullptr; m_counter = null;
m_element = nullptr; m_element = null;
EMEMORY_DBG("reset sharedPtr (stop)"); EMEMORY_DBG("reset sharedPtr (stop)");
} }
int64_t useCount() const { int64_t useCount() const {
if (m_counter == nullptr) { if (m_counter == null) {
return 0; return 0;
} }
return m_counter->getCountShared(); return m_counter->getCountShared();
} }
bool operator==(etk::NullPtr) const { bool operator==(etk::NullPtr) const {
return m_counter == nullptr; return m_counter == null;
} }
template<class EMEMORY_TYPE2> template<class EMEMORY_TYPE2>
bool operator==(const SharedPtr<EMEMORY_TYPE2>& _obj) const { bool operator==(const SharedPtr<EMEMORY_TYPE2>& _obj) const {
return m_counter == _obj.m_counter; return m_counter == _obj.m_counter;
} }
bool operator!=(etk::NullPtr) const { bool operator!=(etk::NullPtr) const {
return m_counter != nullptr; return m_counter != null;
} }
template<class EMEMORY_TYPE2> template<class EMEMORY_TYPE2>
bool operator!=(const SharedPtr<EMEMORY_TYPE2>& _obj) const { bool operator!=(const SharedPtr<EMEMORY_TYPE2>& _obj) const {

114
ememory/details/WeakPtr.hxx
View File

@ -11,24 +11,24 @@
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(): ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr():
m_element(nullptr), m_element(null),
m_counter(nullptr) { m_counter(null) {
} }
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(etk::NullPtr): ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(etk::NullPtr):
m_element(nullptr), m_element(null),
m_counter(nullptr) { m_counter(null) {
} }
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(EMEMORY_TYPE* _element): ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(EMEMORY_TYPE* _element):
m_element(_element), m_element(_element),
m_counter(nullptr) { m_counter(null) {
EMEMORY_DBG("New weak"); EMEMORY_DBG("New weak");
if (m_element == nullptr) { if (m_element == null) {
return; return;
} }
m_counter = ETK_NEW(ememory::Counter, true); m_counter = ETK_NEW(ememory::Counter, true);
@ -43,13 +43,13 @@ template<typename EMEMORY_TYPE>
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(const ememory::WeakPtr<EMEMORY_TYPE>& _obj): ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(const ememory::WeakPtr<EMEMORY_TYPE>& _obj):
m_element(_obj.m_element), m_element(_obj.m_element),
m_counter(_obj.m_counter) { m_counter(_obj.m_counter) {
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
return; return;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return; return;
} }
m_counter->incrementWeak(); m_counter->incrementWeak();
@ -60,13 +60,13 @@ ememory::WeakPtr<EMEMORY_TYPE>& ememory::WeakPtr<EMEMORY_TYPE>::operator= (const
reset(); reset();
m_element = _obj.m_element; m_element = _obj.m_element;
m_counter = _obj.m_counter; m_counter = _obj.m_counter;
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
return *this; return *this;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return *this; return *this;
} }
m_counter->incrementWeak(); m_counter->incrementWeak();
@ -83,21 +83,21 @@ template<typename EMEMORY_TYPE>
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(ememory::WeakPtr<EMEMORY_TYPE>&& _obj) { ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(ememory::WeakPtr<EMEMORY_TYPE>&& _obj) {
m_element = _obj.m_element; m_element = _obj.m_element;
m_counter = _obj.m_counter; m_counter = _obj.m_counter;
_obj.m_element = nullptr; _obj.m_element = null;
_obj.m_counter = nullptr; _obj.m_counter = null;
} }
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(const ememory::SharedPtr<EMEMORY_TYPE>& _obj): ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(const ememory::SharedPtr<EMEMORY_TYPE>& _obj):
m_element(_obj.m_element), m_element(_obj.m_element),
m_counter(_obj.m_counter) { m_counter(_obj.m_counter) {
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
return; return;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return; return;
} }
m_counter->incrementWeak(); m_counter->incrementWeak();
@ -109,13 +109,13 @@ ememory::WeakPtr<EMEMORY_TYPE>& ememory::WeakPtr<EMEMORY_TYPE>::operator= (const
reset(); reset();
m_element = _obj.m_element; m_element = _obj.m_element;
m_counter = _obj.m_counter; m_counter = _obj.m_counter;
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
return *this; return *this;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return *this; return *this;
} }
m_counter->incrementWeak(); m_counter->incrementWeak();
@ -131,13 +131,13 @@ template<class EMEMORY_TYPE2,
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(const ememory::SharedPtr<EMEMORY_TYPE2>& _obj): ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(const ememory::SharedPtr<EMEMORY_TYPE2>& _obj):
m_element((void*)_obj.get()), m_element((void*)_obj.get()),
m_counter(_obj.getCounter()) { m_counter(_obj.getCounter()) {
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
return; return;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return; return;
} }
m_counter->incrementWeak(); m_counter->incrementWeak();
@ -153,13 +153,13 @@ ememory::WeakPtr<EMEMORY_TYPE>& ememory::WeakPtr<EMEMORY_TYPE>::operator= (const
reset(); reset();
m_element = (void*)_obj.get(); m_element = (void*)_obj.get();
m_counter = _obj.getCounter(); m_counter = _obj.getCounter();
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
return *this; return *this;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return *this; return *this;
} }
m_counter->incrementWeak(); m_counter->incrementWeak();
@ -174,13 +174,13 @@ template<class EMEMORY_TYPE2,
WeakPtr(const WeakPtr<EMEMORY_TYPE2>& _obj): WeakPtr(const WeakPtr<EMEMORY_TYPE2>& _obj):
m_element(_obj.m_element), m_element(_obj.m_element),
m_counter(_obj.getCounter()) { m_counter(_obj.getCounter()) {
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
return; return;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return; return;
} }
m_counter->incrementWeak(); m_counter->incrementWeak();
@ -193,13 +193,13 @@ WeakPtr& operator= (const WeakPtr<EMEMORY_TYPE2>& _obj) {
reset(); reset();
m_element = _obj.m_element; m_element = _obj.m_element;
m_counter = _obj.getCounter(); m_counter = _obj.getCounter();
if ( m_element == nullptr if ( m_element == null
|| m_counter == nullptr) { || m_counter == null) {
m_element = nullptr; m_element = null;
m_counter = nullptr; m_counter = null;
return *this; return *this;
} }
if (m_counter == nullptr) { if (m_counter == null) {
return *this; return *this;
} }
m_counter->incrementWeak(); m_counter->incrementWeak();
@ -208,8 +208,8 @@ WeakPtr& operator= (const WeakPtr<EMEMORY_TYPE2>& _obj) {
*/ */
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
void ememory::WeakPtr<EMEMORY_TYPE>::reset() { void ememory::WeakPtr<EMEMORY_TYPE>::reset() {
if(m_counter == nullptr) { if(m_counter == null) {
m_element = nullptr; // in case ... m_element = null; // in case ...
return; return;
} }
ememory::Counter::remove rmData = m_counter->decrementWeak(); ememory::Counter::remove rmData = m_counter->decrementWeak();
@ -226,13 +226,13 @@ void ememory::WeakPtr<EMEMORY_TYPE>::reset() {
case ememory::Counter::remove::none: case ememory::Counter::remove::none:
break; break;
} }
m_counter = nullptr; m_counter = null;
m_element = nullptr; m_element = null;
} }
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
int ememory::WeakPtr<EMEMORY_TYPE>::useCount() const { int ememory::WeakPtr<EMEMORY_TYPE>::useCount() const {
if (m_counter == nullptr) { if (m_counter == null) {
return 0; return 0;
} }
return m_counter->getCountShared(); return m_counter->getCountShared();
@ -240,7 +240,7 @@ int ememory::WeakPtr<EMEMORY_TYPE>::useCount() const {
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
bool ememory::WeakPtr<EMEMORY_TYPE>::expired() const { bool ememory::WeakPtr<EMEMORY_TYPE>::expired() const {
if (m_counter == nullptr) { if (m_counter == null) {
return true; return true;
} }
return m_counter->getCountShared() == 0; return m_counter->getCountShared() == 0;
@ -249,7 +249,7 @@ bool ememory::WeakPtr<EMEMORY_TYPE>::expired() const {
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
ememory::SharedPtr<EMEMORY_TYPE> ememory::WeakPtr<EMEMORY_TYPE>::lock() { ememory::SharedPtr<EMEMORY_TYPE> ememory::WeakPtr<EMEMORY_TYPE>::lock() {
ememory::SharedPtr<EMEMORY_TYPE> out; ememory::SharedPtr<EMEMORY_TYPE> out;
if (m_counter == nullptr) { if (m_counter == null) {
return out; return out;
} }
int64_t count = m_counter->incrementShared(true); int64_t count = m_counter->incrementShared(true);
@ -268,7 +268,7 @@ bool ememory::WeakPtr<EMEMORY_TYPE>::operator==(const ememory::WeakPtr<EMEMORY_T
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
bool ememory::WeakPtr<EMEMORY_TYPE>::operator==(etk::NullPtr) const { bool ememory::WeakPtr<EMEMORY_TYPE>::operator==(etk::NullPtr) const {
return m_counter == nullptr; return m_counter == null;
} }
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
@ -278,7 +278,7 @@ bool ememory::WeakPtr<EMEMORY_TYPE>::operator!=(const ememory::WeakPtr<EMEMORY_T
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>
bool ememory::WeakPtr<EMEMORY_TYPE>::operator!=(etk::NullPtr) const { bool ememory::WeakPtr<EMEMORY_TYPE>::operator!=(etk::NullPtr) const {
return m_counter != nullptr; return m_counter != null;
} }
template<typename EMEMORY_TYPE> template<typename EMEMORY_TYPE>

30
test/testShared.cpp
View File

@ -14,36 +14,36 @@ TEST(TestShared, createAndDestroy) {
ememory::SharedPtr<etk::String> data = ememory::makeShared<etk::String>("coucou"); ememory::SharedPtr<etk::String> data = ememory::makeShared<etk::String>("coucou");
EXPECT_EQ(data.useCount(), 1); EXPECT_EQ(data.useCount(), 1);
EXPECT_EQ(*data, "coucou"); EXPECT_EQ(*data, "coucou");
EXPECT_EQ(data == nullptr, false); EXPECT_EQ(data == null, false);
EXPECT_EQ(data != nullptr, true); EXPECT_EQ(data != null, true);
data.reset(); data.reset();
EXPECT_EQ(data.useCount(), 0); EXPECT_EQ(data.useCount(), 0);
EXPECT_EQ(data == nullptr, true); EXPECT_EQ(data == null, true);
EXPECT_EQ(data != nullptr, false); EXPECT_EQ(data != null, false);
} }
TEST(TestShared, createAndDestroy_2) { TEST(TestShared, createAndDestroy_2) {
ememory::SharedPtr<etk::String> data = ememory::SharedPtr<etk::String>(ETK_NEW(etk::String, "coucou")); ememory::SharedPtr<etk::String> data = ememory::SharedPtr<etk::String>(ETK_NEW(etk::String, "coucou"));
EXPECT_EQ(data.useCount(), 1); EXPECT_EQ(data.useCount(), 1);
EXPECT_EQ(*data, "coucou"); EXPECT_EQ(*data, "coucou");
EXPECT_EQ(data == nullptr, false); EXPECT_EQ(data == null, false);
EXPECT_EQ(data != nullptr, true); EXPECT_EQ(data != null, true);
data.reset(); data.reset();
EXPECT_EQ(data.useCount(), 0); EXPECT_EQ(data.useCount(), 0);
EXPECT_EQ(data == nullptr, true); EXPECT_EQ(data == null, true);
EXPECT_EQ(data != nullptr, false); EXPECT_EQ(data != null, false);
} }
TEST(TestShared, createAndDestroy_3) { TEST(TestShared, createAndDestroy_3) {
ememory::SharedPtr<etk::String> data = ememory::SharedPtr<etk::String>(new etk::String("coucou")); ememory::SharedPtr<etk::String> data = ememory::SharedPtr<etk::String>(new etk::String("coucou"));
EXPECT_EQ(data.useCount(), 1); EXPECT_EQ(data.useCount(), 1);
EXPECT_EQ(*data, "coucou"); EXPECT_EQ(*data, "coucou");
EXPECT_EQ(data == nullptr, false); EXPECT_EQ(data == null, false);
EXPECT_EQ(data != nullptr, true); EXPECT_EQ(data != null, true);
data.reset(); data.reset();
EXPECT_EQ(data.useCount(), 0); EXPECT_EQ(data.useCount(), 0);
EXPECT_EQ(data == nullptr, true); EXPECT_EQ(data == null, true);
EXPECT_EQ(data != nullptr, false); EXPECT_EQ(data != null, false);
} }
TEST(TestShared, copy) { TEST(TestShared, copy) {
@ -119,9 +119,9 @@ TEST(TestShared, heritage) {
ememory::SharedPtr<heritedClass> data = ememory::makeShared<heritedClass>(); ememory::SharedPtr<heritedClass> data = ememory::makeShared<heritedClass>();
ememory::SharedPtr<basicClass> data2 = data; ememory::SharedPtr<basicClass> data2 = data;
ememory::SharedPtr<basicClass> data3(data); ememory::SharedPtr<basicClass> data3(data);
EXPECT_NE(data, nullptr); EXPECT_NE(data, null);
EXPECT_NE(data2, nullptr); EXPECT_NE(data2, null);
EXPECT_NE(data3, nullptr); EXPECT_NE(data3, null);
} }

20
test/testUnique.cpp
View File

@ -13,22 +13,22 @@
TEST(TestEmemoryUniquePtr, Creation_1) { TEST(TestEmemoryUniquePtr, Creation_1) {
ememory::UniquePtr<uint32_t> testData; ememory::UniquePtr<uint32_t> testData;
EXPECT_EQ(testData.get(), nullptr); EXPECT_EQ(testData.get(), null);
} }
TEST(TestEmemoryUniquePtr, Creation_2) { TEST(TestEmemoryUniquePtr, Creation_2) {
ememory::UniquePtr<uint32_t> testData(new uint32_t(55)); ememory::UniquePtr<uint32_t> testData(new uint32_t(55));
EXPECT_NE(testData.get(), nullptr); EXPECT_NE(testData.get(), null);
EXPECT_EQ(*testData.get(), 55); EXPECT_EQ(*testData.get(), 55);
} }
TEST(TestEmemoryUniquePtr, Creation_3) { TEST(TestEmemoryUniquePtr, Creation_3) {
ememory::UniquePtr<uint32_t> testData(ETK_NEW(uint32_t, 55)); ememory::UniquePtr<uint32_t> testData(ETK_NEW(uint32_t, 55));
EXPECT_NE(testData.get(), nullptr); EXPECT_NE(testData.get(), null);
EXPECT_EQ(*testData.get(), 55); EXPECT_EQ(*testData.get(), 55);
} }
TEST(TestEmemoryUniquePtr, Creation_4) { TEST(TestEmemoryUniquePtr, Creation_4) {
ememory::UniquePtr<uint32_t> testData = ememory::makeUniquePtr<uint32_t>(456789); ememory::UniquePtr<uint32_t> testData = ememory::makeUniquePtr<uint32_t>(456789);
EXPECT_NE(testData.get(), nullptr); EXPECT_NE(testData.get(), null);
EXPECT_EQ(*testData.get(), 456789); EXPECT_EQ(*testData.get(), 456789);
} }
@ -51,26 +51,26 @@ TEST(TestEmemoryUniquePtr, reset) {
memset(vals, 0, sizeof(vals)); memset(vals, 0, sizeof(vals));
EXPECT_EQ(vals[1], 0); EXPECT_EQ(vals[1], 0);
ememory::UniquePtr<testCreateAndDestroy> testData = ememory::makeUniquePtr<testCreateAndDestroy>(1); ememory::UniquePtr<testCreateAndDestroy> testData = ememory::makeUniquePtr<testCreateAndDestroy>(1);
EXPECT_NE(testData.get(), nullptr); EXPECT_NE(testData.get(), null);
EXPECT_EQ(vals[1], 1); EXPECT_EQ(vals[1], 1);
testData.reset(); testData.reset();
EXPECT_EQ(testData.get(), nullptr); EXPECT_EQ(testData.get(), null);
EXPECT_EQ(vals[1], -1); EXPECT_EQ(vals[1], -1);
} }
TEST(TestEmemoryUniquePtr, reset_2) { TEST(TestEmemoryUniquePtr, reset_2) {
memset(vals, 0, sizeof(vals)); memset(vals, 0, sizeof(vals));
EXPECT_EQ(vals[1], 0); EXPECT_EQ(vals[1], 0);
ememory::UniquePtr<testCreateAndDestroy> testData = ememory::makeUniquePtr<testCreateAndDestroy>(1); ememory::UniquePtr<testCreateAndDestroy> testData = ememory::makeUniquePtr<testCreateAndDestroy>(1);
EXPECT_NE(testData.get(), nullptr); EXPECT_NE(testData.get(), null);
EXPECT_EQ(vals[1], 1); EXPECT_EQ(vals[1], 1);
testData = nullptr; testData = null;
EXPECT_EQ(testData.get(), nullptr); EXPECT_EQ(testData.get(), null);
EXPECT_EQ(vals[1], -1); EXPECT_EQ(vals[1], -1);
} }
TEST(TestEmemoryUniquePtr, overwrite) { TEST(TestEmemoryUniquePtr, overwrite) {
memset(vals, 0, sizeof(vals)); memset(vals, 0, sizeof(vals));
ememory::UniquePtr<testCreateAndDestroy> testData = ememory::makeUniquePtr<testCreateAndDestroy>(1); ememory::UniquePtr<testCreateAndDestroy> testData = ememory::makeUniquePtr<testCreateAndDestroy>(1);
EXPECT_NE(testData.get(), nullptr); EXPECT_NE(testData.get(), null);
EXPECT_EQ(vals[1], 1); EXPECT_EQ(vals[1], 1);
EXPECT_EQ(vals[2], 0); EXPECT_EQ(vals[2], 0);
testData = ememory::makeUniquePtr<testCreateAndDestroy>(2); testData = ememory::makeUniquePtr<testCreateAndDestroy>(2);

2
test/testWeak.cpp
View File

@ -37,7 +37,7 @@ TEST(TestWeak, retrive) {
EXPECT_EQ(dataRetrive.useCount(), 0); EXPECT_EQ(dataRetrive.useCount(), 0);
EXPECT_EQ(dataWeak.useCount(), 0); EXPECT_EQ(dataWeak.useCount(), 0);
dataRetrive = dataWeak.lock(); dataRetrive = dataWeak.lock();
EXPECT_EQ(dataRetrive == nullptr, true); EXPECT_EQ(dataRetrive == null, true);
EXPECT_EQ(dataRetrive.useCount(), 0); EXPECT_EQ(dataRetrive.useCount(), 0);
EXPECT_EQ(dataWeak.useCount(), 0); EXPECT_EQ(dataWeak.useCount(), 0);
} }