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
public:
/**
* @brief Contructor on nullptr
* @brief Contructor on null
*/
SharedPtr(etk::NullPtr);
/**
@ -99,7 +99,7 @@ namespace ememory {
*/
SharedPtr& operator= (const SharedPtr<EMEMORY_TYPE>& _obj);
/**
* @brief Asignement operator (asign nullptr)
* @brief Asignement operator (asign null)
* @return Reference on this
*/
SharedPtr& operator= (etk::NullPtr);
@ -125,7 +125,7 @@ namespace ememory {
*/
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
*/
bool operator==(etk::NullPtr) const;
@ -137,7 +137,7 @@ namespace ememory {
template<class EMEMORY_TYPE2>
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
*/
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;
public:
UniquePtr() :
m_pointer(nullptr),
m_deleter(nullptr) {
m_pointer(null),
m_deleter(null) {
}
UniquePtr(etk::NullPtr) :
m_pointer(nullptr),
m_deleter(nullptr) {
m_pointer(null),
m_deleter(null) {
}
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>
UniquePtr(UniquePtr<EMEM_UPTR_TYPE_2>&& _obj) :
m_pointer(nullptr),
m_deleter(nullptr) {
m_pointer(null),
m_deleter(null) {
etk::swap(_obj.m_pointer, m_pointer);
etk::swap(_obj.m_deleter, m_deleter);
}
@ -58,7 +58,7 @@ namespace ememory {
UniquePtr& operator=(UniquePtr<EMEM_UPTR_TYPE_2>& _obj){
reset();
m_pointer = _obj.m_pointer;
_obj.m_pointer = nullptr;
_obj.m_pointer = null;
return *this;
}*/
const EMEM_UPTR_TYPE& operator*() const {
@ -78,32 +78,32 @@ namespace ememory {
}
EMEM_UPTR_TYPE *release(){
EMEM_UPTR_TYPE *tmp = m_pointer;
m_pointer = nullptr;
m_pointer = null;
return tmp;
}
void reset(){
if (m_deleter != nullptr) {
if (m_deleter != null) {
m_deleter(m_pointer);
}
m_pointer = nullptr;
m_pointer = null;
}
void swap(UniquePtr &_obj){
etk::swap(_obj.m_pointer, m_pointer);
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
*/
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
*/
bool operator!=(etk::NullPtr) const {
return m_pointer != nullptr;
return m_pointer != null;
}
/*
template <class EMEM_UPTR_TYPE_2>

8
ememory/WeakPtr.hpp
View File

@ -29,7 +29,7 @@ namespace ememory {
*/
WeakPtr();
/**
* @brief nullptr contructor
* @brief null contructor
*/
WeakPtr(etk::NullPtr);
private:
@ -68,7 +68,7 @@ namespace ememory {
*/
WeakPtr<EMEMORY_TYPE>& operator= (const SharedPtr<EMEMORY_TYPE>& _obj);
/**
* @brief nullptr asignement
* @brief null asignement
* @return Reference on this
*/
WeakPtr<EMEMORY_TYPE>& operator= (etk::NullPtr);
@ -130,7 +130,7 @@ namespace ememory {
*/
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
*/
bool operator==(etk::NullPtr) const;
@ -141,7 +141,7 @@ namespace ememory {
*/
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
*/
bool operator!=(etk::NullPtr) const;

148
ememory/details/SharedPtr.hxx
View File

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

114
ememory/details/WeakPtr.hxx
View File

@ -11,24 +11,24 @@
template<typename EMEMORY_TYPE>
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr():
m_element(nullptr),
m_counter(nullptr) {
m_element(null),
m_counter(null) {
}
template<typename EMEMORY_TYPE>
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(etk::NullPtr):
m_element(nullptr),
m_counter(nullptr) {
m_element(null),
m_counter(null) {
}
template<typename EMEMORY_TYPE>
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(EMEMORY_TYPE* _element):
m_element(_element),
m_counter(nullptr) {
m_counter(null) {
EMEMORY_DBG("New weak");
if (m_element == nullptr) {
if (m_element == null) {
return;
}
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):
m_element(_obj.m_element),
m_counter(_obj.m_counter) {
if ( m_element == nullptr
|| m_counter == nullptr) {
m_element = nullptr;
m_counter = nullptr;
if ( m_element == null
|| m_counter == null) {
m_element = null;
m_counter = null;
return;
}
if (m_counter == nullptr) {
if (m_counter == null) {
return;
}
m_counter->incrementWeak();
@ -60,13 +60,13 @@ ememory::WeakPtr<EMEMORY_TYPE>& ememory::WeakPtr<EMEMORY_TYPE>::operator= (const
reset();
m_element = _obj.m_element;
m_counter = _obj.m_counter;
if ( m_element == nullptr
|| m_counter == nullptr) {
m_element = nullptr;
m_counter = nullptr;
if ( m_element == null
|| m_counter == null) {
m_element = null;
m_counter = null;
return *this;
}
if (m_counter == nullptr) {
if (m_counter == null) {
return *this;
}
m_counter->incrementWeak();
@ -83,21 +83,21 @@ template<typename EMEMORY_TYPE>
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(ememory::WeakPtr<EMEMORY_TYPE>&& _obj) {
m_element = _obj.m_element;
m_counter = _obj.m_counter;
_obj.m_element = nullptr;
_obj.m_counter = nullptr;
_obj.m_element = null;
_obj.m_counter = null;
}
template<typename EMEMORY_TYPE>
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(const ememory::SharedPtr<EMEMORY_TYPE>& _obj):
m_element(_obj.m_element),
m_counter(_obj.m_counter) {
if ( m_element == nullptr
|| m_counter == nullptr) {
m_element = nullptr;
m_counter = nullptr;
if ( m_element == null
|| m_counter == null) {
m_element = null;
m_counter = null;
return;
}
if (m_counter == nullptr) {
if (m_counter == null) {
return;
}
m_counter->incrementWeak();
@ -109,13 +109,13 @@ ememory::WeakPtr<EMEMORY_TYPE>& ememory::WeakPtr<EMEMORY_TYPE>::operator= (const
reset();
m_element = _obj.m_element;
m_counter = _obj.m_counter;
if ( m_element == nullptr
|| m_counter == nullptr) {
m_element = nullptr;
m_counter = nullptr;
if ( m_element == null
|| m_counter == null) {
m_element = null;
m_counter = null;
return *this;
}
if (m_counter == nullptr) {
if (m_counter == null) {
return *this;
}
m_counter->incrementWeak();
@ -131,13 +131,13 @@ template<class EMEMORY_TYPE2,
ememory::WeakPtr<EMEMORY_TYPE>::WeakPtr(const ememory::SharedPtr<EMEMORY_TYPE2>& _obj):
m_element((void*)_obj.get()),
m_counter(_obj.getCounter()) {
if ( m_element == nullptr
|| m_counter == nullptr) {
m_element = nullptr;
m_counter = nullptr;
if ( m_element == null
|| m_counter == null) {
m_element = null;
m_counter = null;
return;
}
if (m_counter == nullptr) {
if (m_counter == null) {
return;
}
m_counter->incrementWeak();
@ -153,13 +153,13 @@ ememory::WeakPtr<EMEMORY_TYPE>& ememory::WeakPtr<EMEMORY_TYPE>::operator= (const
reset();
m_element = (void*)_obj.get();
m_counter = _obj.getCounter();
if ( m_element == nullptr
|| m_counter == nullptr) {
m_element = nullptr;
m_counter = nullptr;
if ( m_element == null
|| m_counter == null) {
m_element = null;
m_counter = null;
return *this;
}
if (m_counter == nullptr) {
if (m_counter == null) {
return *this;
}
m_counter->incrementWeak();
@ -174,13 +174,13 @@ template<class EMEMORY_TYPE2,
WeakPtr(const WeakPtr<EMEMORY_TYPE2>& _obj):
m_element(_obj.m_element),
m_counter(_obj.getCounter()) {
if ( m_element == nullptr
|| m_counter == nullptr) {
m_element = nullptr;
m_counter = nullptr;
if ( m_element == null
|| m_counter == null) {
m_element = null;
m_counter = null;
return;
}
if (m_counter == nullptr) {
if (m_counter == null) {
return;
}
m_counter->incrementWeak();
@ -193,13 +193,13 @@ WeakPtr& operator= (const WeakPtr<EMEMORY_TYPE2>& _obj) {
reset();
m_element = _obj.m_element;
m_counter = _obj.getCounter();
if ( m_element == nullptr
|| m_counter == nullptr) {
m_element = nullptr;
m_counter = nullptr;
if ( m_element == null
|| m_counter == null) {
m_element = null;
m_counter = null;
return *this;
}
if (m_counter == nullptr) {
if (m_counter == null) {
return *this;
}
m_counter->incrementWeak();
@ -208,8 +208,8 @@ WeakPtr& operator= (const WeakPtr<EMEMORY_TYPE2>& _obj) {
*/
template<typename EMEMORY_TYPE>
void ememory::WeakPtr<EMEMORY_TYPE>::reset() {
if(m_counter == nullptr) {
m_element = nullptr; // in case ...
if(m_counter == null) {
m_element = null; // in case ...
return;
}
ememory::Counter::remove rmData = m_counter->decrementWeak();
@ -226,13 +226,13 @@ void ememory::WeakPtr<EMEMORY_TYPE>::reset() {
case ememory::Counter::remove::none:
break;
}
m_counter = nullptr;
m_element = nullptr;
m_counter = null;
m_element = null;
}
template<typename EMEMORY_TYPE>
int ememory::WeakPtr<EMEMORY_TYPE>::useCount() const {
if (m_counter == nullptr) {
if (m_counter == null) {
return 0;
}
return m_counter->getCountShared();
@ -240,7 +240,7 @@ int ememory::WeakPtr<EMEMORY_TYPE>::useCount() const {
template<typename EMEMORY_TYPE>
bool ememory::WeakPtr<EMEMORY_TYPE>::expired() const {
if (m_counter == nullptr) {
if (m_counter == null) {
return true;
}
return m_counter->getCountShared() == 0;
@ -249,7 +249,7 @@ bool ememory::WeakPtr<EMEMORY_TYPE>::expired() const {
template<typename EMEMORY_TYPE>
ememory::SharedPtr<EMEMORY_TYPE> ememory::WeakPtr<EMEMORY_TYPE>::lock() {
ememory::SharedPtr<EMEMORY_TYPE> out;
if (m_counter == nullptr) {
if (m_counter == null) {
return out;
}
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>
bool ememory::WeakPtr<EMEMORY_TYPE>::operator==(etk::NullPtr) const {
return m_counter == nullptr;
return m_counter == null;
}
template<typename EMEMORY_TYPE>
@ -278,7 +278,7 @@ bool ememory::WeakPtr<EMEMORY_TYPE>::operator!=(const ememory::WeakPtr<EMEMORY_T
template<typename EMEMORY_TYPE>
bool ememory::WeakPtr<EMEMORY_TYPE>::operator!=(etk::NullPtr) const {
return m_counter != nullptr;
return m_counter != null;
}
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");
EXPECT_EQ(data.useCount(), 1);
EXPECT_EQ(*data, "coucou");
EXPECT_EQ(data == nullptr, false);
EXPECT_EQ(data != nullptr, true);
EXPECT_EQ(data == null, false);
EXPECT_EQ(data != null, true);
data.reset();
EXPECT_EQ(data.useCount(), 0);
EXPECT_EQ(data == nullptr, true);
EXPECT_EQ(data != nullptr, false);
EXPECT_EQ(data == null, true);
EXPECT_EQ(data != null, false);
}
TEST(TestShared, createAndDestroy_2) {
ememory::SharedPtr<etk::String> data = ememory::SharedPtr<etk::String>(ETK_NEW(etk::String, "coucou"));
EXPECT_EQ(data.useCount(), 1);
EXPECT_EQ(*data, "coucou");
EXPECT_EQ(data == nullptr, false);
EXPECT_EQ(data != nullptr, true);
EXPECT_EQ(data == null, false);
EXPECT_EQ(data != null, true);
data.reset();
EXPECT_EQ(data.useCount(), 0);
EXPECT_EQ(data == nullptr, true);
EXPECT_EQ(data != nullptr, false);
EXPECT_EQ(data == null, true);
EXPECT_EQ(data != null, false);
}
TEST(TestShared, createAndDestroy_3) {
ememory::SharedPtr<etk::String> data = ememory::SharedPtr<etk::String>(new etk::String("coucou"));
EXPECT_EQ(data.useCount(), 1);
EXPECT_EQ(*data, "coucou");
EXPECT_EQ(data == nullptr, false);
EXPECT_EQ(data != nullptr, true);
EXPECT_EQ(data == null, false);
EXPECT_EQ(data != null, true);
data.reset();
EXPECT_EQ(data.useCount(), 0);
EXPECT_EQ(data == nullptr, true);
EXPECT_EQ(data != nullptr, false);
EXPECT_EQ(data == null, true);
EXPECT_EQ(data != null, false);
}
TEST(TestShared, copy) {
@ -119,9 +119,9 @@ TEST(TestShared, heritage) {
ememory::SharedPtr<heritedClass> data = ememory::makeShared<heritedClass>();
ememory::SharedPtr<basicClass> data2 = data;
ememory::SharedPtr<basicClass> data3(data);
EXPECT_NE(data, nullptr);
EXPECT_NE(data2, nullptr);
EXPECT_NE(data3, nullptr);
EXPECT_NE(data, null);
EXPECT_NE(data2, null);
EXPECT_NE(data3, null);
}

20
test/testUnique.cpp
View File

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