Object.h

Go to the documentation of this file.

 
#pragma once
 
#include <alib/variant>
#include <object/AnyObject.h>
 
namespace object {
 
class Object {
    ext::cow_shared_ptr < AnyObjectBase > m_data;
 
    void unify ( Object & other ) {
        if ( this->m_data.use_count ( ) > other.m_data.use_count ( ) )
            other.m_data = this->m_data;
        else
            this->m_data = other.m_data;
    }
 
    template < class Variant >
    static Object processVariant ( Variant && data ) {
        auto visitor = [] ( auto && element ) {
            return Object ( std::forward < decltype ( element ) > ( element ) );
        };
 
        return ext::visit ( visitor, std::forward < Variant > ( data ) );
    }
 
    explicit Object ( AnyObjectBase * data ) : m_data ( data ) {
    }
 
    void setData ( AnyObjectBase * data ) {
        if ( & getData ( ) == data )
            return;
 
        this->m_data = ext::cow_shared_ptr < AnyObjectBase > ( data );
    }
 
public:
    explicit Object ( const char * string ) : Object ( std::string ( string ) ) {
    }
 
    template < class Type >
    requires ( ! std::is_same_v < std::decay_t < Type >, Object > )
    // NOLINTNEXTLINE ( bugprone-forwarding-reference-overload )
    explicit Object ( Type && data ) : Object ( object::AnyObject < typename std::decay < Type >::type > ( std::forward < Type > ( data ) ) ) {
    }
 
    template < class ... Types >
    explicit Object ( ext::variant < Types ... > && data ) : Object ( processVariant ( std::move ( data ) ) ) {
    }
 
    template < class ... Types >
    explicit Object ( const ext::variant < Types ... > & data ) : Object ( processVariant ( data ) ) {
    }
 
    template < class Type >
    explicit Object ( const AnyObject < Type > & data ) : m_data ( data.clone ( ) ) {
    }
 
    template < class Type >
    explicit Object ( AnyObject < Type > & data ) : m_data ( data.clone ( ) ) {
    }
 
    template < class Type >
    explicit Object ( AnyObject < Type > && data ) : m_data ( std::move ( data ).clone ( ) ) {
    }
 
    explicit Object ( const AnyObject < object::Object > & data ) : Object ( data.getData ( ) ) {
    }
 
    explicit Object ( AnyObject < object::Object > && data ) : Object ( std::move ( data ).getData ( ) ) {
    }
 
    const AnyObjectBase & getData ( ) const {
        return * m_data;
    }
 
    AnyObjectBase & getData ( ) {
        return * m_data;
    }
 
    void setData ( const AnyObjectBase & data ) {
        setData ( data.clone ( ) );
    }
 
    void setData ( AnyObjectBase && data ) {
        setData ( std::move ( data ).clone ( ) );
    }
 
    std::strong_ordering operator <=> ( const Object & other ) const {
        if ( this->m_data.get ( ) == other.m_data.get ( ) )
            return std::strong_ordering::equal;
 
        std::strong_ordering res = ( * this->m_data ) <=> ( * other.m_data );
        if ( res == 0 )
            const_cast < Object * > ( this )->unify ( const_cast < Object & > ( other ) );
 
        return res;
    }
 
    bool operator ==( const Object & other ) const {
        if ( this->m_data.get ( ) == other.m_data.get ( ) )
            return true;
 
        bool res = ( * this->m_data ) == ( * other.m_data );
        if ( res )
            const_cast < Object * > ( this )->unify ( const_cast < Object & > ( other ) );
 
        return res;
    }
 
    friend ext::ostream & operator <<( ext::ostream & os, const Object & instance ) {
        instance.getData ( ) >> os;
        return os;
    }
 
    explicit operator std::string ( ) const {
        return m_data->operator std::string ( );
    }
 
    Object & operator ++ ( ) {
        this->getData ( ).increment ( 1 );
        return *this;
    }
 
    Object operator ++ ( int ) {
        Object res = * this;
        ++ * this;
        return res;
    }
 
    Object operator += ( unsigned by ) {
        this->getData ( ).increment ( by );
        return *this;
    }
 
    unsigned getId ( ) const {
        return this->getData ( ).getId ( );
    }
};
 
} /* namespace object */