pointer.hpp

Go to the documentation of this file.

/*
Copyright (c) 2025 acrion innovations GmbH
Authors: Stefan Zipproth, s.zipproth@acrion.ch
 
This file is part of Cbeam, see https://github.com/acrion/cbeam and https://cbeam.org
 
Cbeam is offered under a commercial and under the AGPL license.
For commercial licensing, contact us at https://acrion.ch/sales. For AGPL licensing, see below.
 
AGPL licensing:
 
Cbeam is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
Cbeam is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
 
You should have received a copy of the GNU Affero General Public License
along with Cbeam. If not, see <https://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include <cbeam/container/stable_reference_buffer.hpp> // for cbeam::container::stable_reference_buffer
#include <cbeam/convert/string.hpp>                    // for cbeam::convert::from_string, cbeam::convert::to_string
#include <cbeam/error/runtime_error.hpp>               // for cbeam::error:runtime_error
 
#include <iosfwd> // for std::ostream
#include <memory> // for std::shared_ptr, std::allocator, std::make_shared, std::__shared_ptr_access
#include <string> // for std::operator+, std::char_traits, std::string, std::operator<<
 
namespace cbeam::memory
{
    class pointer
    {
    public:
        pointer() = default;

        pointer(void* ptr)
            : _ptr(ptr)
        {
            if (container::stable_reference_buffer::is_known(ptr))
            {
                _mem = std::make_shared<container::stable_reference_buffer>(ptr);
            }
        }

        pointer(const std::string& str_ptr)
            : pointer(convert::from_string<void*>(str_ptr))
        {
        }

        explicit pointer(const container::stable_reference_buffer& mem)
            : _ptr((void*)mem.get())
            , _mem(std::make_shared<container::stable_reference_buffer>(mem))
        {
        }

        template <typename T>
        pointer(const std::shared_ptr<T>& ptr)
            : _ptr(static_cast<void*>(ptr.get()))
            , _holder(new std::shared_ptr<T>(ptr))
        {
        }

        bool is_managed() const
        {
            return (bool)_mem;
        }

        operator void*() const
        {
            return _ptr;
        }

        pointer& operator=(const pointer& other)
        {
            if (this == &other)
            {
                return *this;
            }
 
            _ptr    = other._ptr;
            _holder = other._holder;
            if (other._mem)
            {
                _mem = std::make_shared<container::stable_reference_buffer>(*other._mem);
            }
            else
            {
                _mem.reset();
            }
 
            return *this;
        }

        explicit operator container::stable_reference_buffer() const
        {
            if (!_mem)
            {
                throw cbeam::error::runtime_error("cbeam::pointer(\"" + (std::string) * this + "\") is not an cbeam::container::stable_reference_buffer");
            }
            return *_mem;
        }

        explicit operator std::string() const
        {
            return convert::to_string(_ptr);
        }
 
    private:
        void*                                               _ptr{nullptr};
        std::shared_ptr<container::stable_reference_buffer> _mem;
        std::shared_ptr<void>                               _holder; 
    };

    inline std::ostream& operator<<(std::ostream& os, const pointer& p)
    {
        os << static_cast<std::string>(p);
        return os;
    }

    inline bool operator==(const pointer& lhs, const pointer& rhs)
    {
        return static_cast<void*>(lhs) == static_cast<void*>(rhs);
    }

    inline bool operator!=(const pointer& lhs, const pointer& rhs)
    {
        return !(lhs == rhs);
    }

    inline bool operator<(const pointer& lhs, const pointer& rhs)
    {
        return static_cast<void*>(lhs) < static_cast<void*>(rhs);
    }

    inline bool operator<=(const pointer& lhs, const pointer& rhs)
    {
        return (lhs == rhs) || (lhs < rhs);
    }

    inline bool operator>(const pointer& lhs, const pointer& rhs)
    {
        return !(lhs <= rhs);
    }

    inline bool operator>=(const pointer& lhs, const pointer& rhs)
    {
        return !(lhs < rhs);
    }
}