TNullable.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// STL includes
#include <algorithm>
 
 
namespace istd
{
 
 
template <class T>
class TNullable
{
public:
       TNullable();
       TNullable(const T& value);
       TNullable(T&& value);
       ~TNullable();
 
       bool IsValid() const;
 
       bool IsNull() const;
 
       bool HasValue() const;
 
       const T* GetPtr() const;
       T* GetPtr();
 
       T& GetValue();
       const T& GetValue() const;
 
       void Reset();
 
       T& Emplace();
 
       void SetNull();
 
       // operators
       TNullable& operator=(const T& value);
       TNullable& operator=(T&& value);
 
       // STL-compatibility methods
       // access operators
       const T* operator->() const;
       T* operator->();
       const T& operator*() const &;
       T& operator*() &;
       const T&& operator*() const &&;
       T&& operator*() &&;
 
       // set operators
       TNullable& operator=( std::nullptr_t );
       TNullable& operator=(const TNullable& other);
 
       explicit operator bool() const;
       bool has_value() const;
 
       // value access
       T& value() &;
       const T& value() const &;
       T&& value() &&;
       const T&& value() const &&;
       T value_or(const T& default_value) const;
 
       void swap(TNullable& other );
       void reset();
       T& emplace();
       T& emplace(T&& value)&&;
 
       //Compare two TNullable objects
       bool operator==(const TNullable& other) const;
       bool operator!=(const TNullable& other) const;
 
       //Compare a TNullable object with a nullptr
       bool operator==(std::nullptr_t) const;
       bool operator!=(std::nullptr_t) const;
 
       //Compare a TNullable object with a value
       bool operator==(const T& value) const;
       bool operator!=(const T& value) const;
 
private:
       bool m_hasValue;
       bool m_isNull;
       bool m_isValid;
       T* m_dataPtr;
};
 
 
// public methods
 
template <class T>
TNullable<T>::TNullable()
       :m_hasValue(false),
       m_isNull(false),
       m_isValid(false),
       m_dataPtr(nullptr)
{
}
 
 
template<class T>
inline TNullable<T>::TNullable(const T& value)
       :m_hasValue(true),
       m_isNull(false),
       m_isValid(true)
{
       m_dataPtr = new T;
       *m_dataPtr = value;
}
 
 
template<class T>
inline TNullable<T>::TNullable(T&& value)
       :m_hasValue(true),
       m_isNull(false),
       m_isValid(true)
{
       m_dataPtr = new T;
       *m_dataPtr = std::move(value);
}
 
 
template <class T>
TNullable<T>::~TNullable()
{
       if (m_dataPtr != nullptr){
              delete m_dataPtr;
       }
}
 
 
template<class T>
inline bool TNullable<T>::IsValid() const
{
       return m_isValid;
}
 
 
template<class T>
bool TNullable<T>::IsNull() const
{
       return m_isNull;
}
 
 
template<class T>
bool TNullable<T>::HasValue() const
{
       return m_hasValue;
}
 
 
template<class T>
const T* TNullable<T>::GetPtr() const
{
       return m_dataPtr;
}
 
 
template<class T>
T* TNullable<T>::GetPtr()
{
       return m_dataPtr;
}
 
 
template<class T>
T& TNullable<T>::GetValue()
{
       Q_ASSERT_X(!m_isNull && m_hasValue, __func__, "Access to uninitialized data");
 
       return *m_dataPtr;
}
 
 
template<class T>
const T& TNullable<T>::GetValue() const
{
       Q_ASSERT_X(!m_isNull && m_hasValue, __func__, "Access to uninitialized data");
 
       return *m_dataPtr;
}
 
template<class T>
void TNullable<T>::Reset()
{
       if (m_dataPtr != nullptr){
              delete m_dataPtr;
       }
 
       m_isNull = false;
       m_hasValue = false;
       m_isValid = false;
       m_dataPtr = nullptr;
}
 
template<class T>
T& TNullable<T>::Emplace()
{
       m_isNull = false;
       m_hasValue = true;
       m_isValid = true;
       if (m_dataPtr != nullptr){
              delete m_dataPtr;
       }
 
       m_dataPtr = new T;
 
       return *m_dataPtr;
}
 
 
template<class T>
inline void TNullable<T>::SetNull()
{
       Reset();
       m_isNull = true;
       m_isValid = true;
}
 
 
// operators
 
template<class T>
TNullable<T>& TNullable<T>::operator=(const T& value)
{
       m_hasValue = true;
       m_isNull = false;
       m_isValid = true;
       if (m_dataPtr != nullptr){
              delete m_dataPtr;
       }
 
       m_dataPtr = new T;
       *m_dataPtr = value;
 
       return *this;
}
 
 
template<class T>
TNullable<T>& TNullable<T>::operator=(T&& value)
{
       m_hasValue = true;
       m_isNull = false;
       m_isValid = true;
       if (m_dataPtr != nullptr){
              delete m_dataPtr;
       }
 
       m_dataPtr = new T;
       *m_dataPtr = std::move(value);
 
       return *this;
}
 
 
// STL-compatibility methods
// access operators
 
template<class T>
const T* TNullable<T>::operator->() const
{
       Q_ASSERT_X(!m_isNull && m_hasValue, __func__, "Access to uninitialized data");
 
       return m_dataPtr;
}
 
 
template<class T>
T* TNullable<T>::operator->()
{
       Q_ASSERT_X(!m_isNull && m_hasValue, __func__, "Access to uninitialized data");
 
       return m_dataPtr;
}
 
 
template<class T>
const T& TNullable<T>::operator*() const &
{
       Q_ASSERT_X(!m_isNull && m_hasValue, __func__, "Access to uninitialized data");
 
       return *m_dataPtr;
}
 
 
template<class T>
T& TNullable<T>::operator*() &
{
       Q_ASSERT_X(!m_isNull && m_hasValue, __func__, "Access to uninitialized data");
 
       return *m_dataPtr;
}
 
 
template<class T>
const T&& TNullable<T>::operator*() const &&
{
       Q_ASSERT_X(!m_isNull && m_hasValue, __func__, "Access to uninitialized data");
 
       return std::move(*m_dataPtr);
}
 
 
template<class T>
T&& TNullable<T>::operator*() &&
{
       Q_ASSERT_X(!m_isNull && m_hasValue, __func__, "Access to uninitialized data");
 
       return std::move(*m_dataPtr);
}
 
 
template<class T>
TNullable<T>& TNullable<T>::operator=( std::nullptr_t )
{
       Reset();
       m_isNull = true;
       m_isValid = true;
 
       return *this;
}
 
 
template<class T>
TNullable<T>& TNullable<T>::operator=(const TNullable& other)
{
       if (m_dataPtr != nullptr){
              delete m_dataPtr;
              m_dataPtr = nullptr;
       }
       if (other.m_dataPtr != nullptr){
              m_dataPtr = new T;
              *m_dataPtr = *other.m_dataPtr;
       }
 
       m_hasValue = other.m_hasValue;
       m_isNull = other.m_isNull;
       m_isValid = other.m_isValid;
 
       return *this;
}
 
 
template<class T>
TNullable<T>::operator bool() const
{
       return m_hasValue;
}
 
 
template<class T>
bool TNullable<T>::has_value() const
{
       return m_hasValue;
}
 
 
template<class T>
T& TNullable<T>::value() &
{
       Q_ASSERT_X(!m_isNull && m_hasValue, __func__, "Access to uninitialized data");
 
       return *m_dataPtr;
}
 
 
template<class T>
const T& TNullable<T>::value() const &
{
       Q_ASSERT_X(!m_isNull && m_hasValue, __func__, "Access to uninitialized data");
 
       return *m_dataPtr;
}
 
 
template<class T>
T&& TNullable<T>::value() &&
{
       Q_ASSERT_X(!m_isNull && m_hasValue, __func__, "Access to uninitialized data");
 
       return std::move(*m_dataPtr);
}
 
 
template<class T>
const T&& TNullable<T>::value() const &&
{
       Q_ASSERT_X(!m_isNull && m_hasValue, __func__, "Access to uninitialized data");
 
       return std::move(*m_dataPtr);
}
 
 
template<class T>
T TNullable<T>::value_or(const T& default_value) const
{
       if (m_hasValue && !m_isNull){
              return *m_dataPtr;
       }
 
       return default_value;
}
 
 
template<class T>
void TNullable<T>::swap(TNullable& other )
{
       std::swap(m_dataPtr, other.m_dataPtr);
       std::swap(m_hasValue, other.m_hasValue);
       std::swap(m_isNull, other.m_isNull);
       std::swap(m_isValid, other.m_isValid);
}
 
 
template<class T>
void TNullable<T>::reset()
{
       Reset();
}
 
 
template<class T>
T& TNullable<T>::emplace()
{
       return Emplace();
}
 
 
template<class T>
T& TNullable<T>::emplace(T&& value)&&
{
       m_dataPtr = std::move(value);
       m_hasValue = true;
       m_isNull = false;
       m_isValid = true;
 
       return *m_dataPtr;
}
 
 
template<class T>
bool TNullable<T>::operator==(const TNullable& other) const
{
       bool retVal = m_hasValue == other.m_hasValue && m_isNull == other.m_isNull && m_isValid == other.m_isValid;
 
       if (retVal && (m_dataPtr != nullptr && other.m_dataPtr != nullptr)){
              retVal = *m_dataPtr == *other.m_dataPtr;
       }
 
       return retVal;
}
 
 
template<class T>
bool TNullable<T>::operator!=(const TNullable& other) const
{
       return (!operator==(other));
}
 
 
template<class T>
bool TNullable<T>::operator==(std::nullptr_t) const
{
       return m_dataPtr == nullptr;
}
 
 
template<class T>
bool TNullable<T>::operator!=(std::nullptr_t) const
{
       return m_dataPtr != nullptr;
}
 
 
template<class T>
bool TNullable<T>::operator==(const T& value) const
{
       if (!m_hasValue || m_isNull){
              Q_ASSERT_X(false, __func__, "Comnpare with uninitialized data");
 
              return false;
       }
 
       return *m_dataPtr == value;
}
 
 
template<class T>
bool TNullable<T>::operator!=(const T& value) const
{
       if (!m_hasValue || m_isNull){
              Q_ASSERT_X(false, __func__, "Comnpare with uninitialized data");
 
              return false;
       }
 
       return *m_dataPtr != value;
}
 
 
} // namespace istd