external.hpp

Go to the documentation of this file.

// Copyright 2023 Proyectos y Sistemas de Mantenimiento SL (eProsima).
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#ifndef _FASTCDR_XCDR_EXTERNAL_HPP_
#define _FASTCDR_XCDR_EXTERNAL_HPP_
 
#include <memory>
 
#include "../exceptions/LockedExternalAccessException.hpp"
 
namespace eprosima {
namespace fastcdr {
 
template<class T>
class external
{
public:
 
    using type = T;
 
    external() = default;
 
    external(
            T* pointer,
            bool locked = false) noexcept
        : pointer_ {pointer}
        , locked_ {locked}
    {
    }
 
    external(
            std::shared_ptr<T> pointer) noexcept
        : pointer_ {pointer}
    {
    }
 
    external(
            const external<T>& other) noexcept
        : locked_ {other.locked_}
    {
        if (locked_)
        {
            pointer_ = std::make_shared<T>(*other.pointer_);
        }
        else
        {
            pointer_ = other.pointer_;
        }
    }
 
    external<T>& operator =(
            const external<T>& other)
    {
        if (locked_)
        {
            throw exception::LockedExternalAccessException(
                      exception::LockedExternalAccessException::LOCKED_EXTERNAL_ACCESS_MESSAGE_DEFAULT);
        }
 
        if (!other.pointer_)
        {
            pointer_.reset();
        }
        else if (other.locked_)
        {
            if (!pointer_)
            {
                pointer_ = std::make_shared<T>(*other.pointer_);
            }
            else
            {
                *pointer_ = *other.pointer_;
            }
        }
        else
        {
            pointer_ = other.pointer_;
        }
 
        return *this;
    }
 
    ~external() = default;
 
    T& operator *() noexcept
    {
        return *pointer_;
    }
 
    const T& operator *() const noexcept
    {
        return *pointer_;
    }
 
    T* get() noexcept
    {
        return pointer_.get();
    }
 
    const T* get() const noexcept
    {
        return pointer_.get();
    }
 
    std::shared_ptr<T> get_shared_ptr() noexcept
    {
        return pointer_;
    }
 
    T* operator ->() noexcept
    {
        return pointer_.get();
    }
 
    const T* operator ->() const noexcept
    {
        return pointer_.get();
    }
 
    bool operator ==(
            const external<T>& other) const
    {
        return pointer_.get() == other.pointer_.get();
    }
 
    bool operator !=(
            const external<T>& other) const
    {
        return !(*this == other);
    }
 
    operator bool() const noexcept
    {
        return nullptr != pointer_.get();
    }
 
    bool is_locked() const noexcept
    {
        return locked_;
    }
 
    void lock() noexcept
    {
        locked_ = true;
    }
 
private:
 
    std::shared_ptr<T> pointer_;
 
    bool locked_ {false};
 
};
 
} // namespace fastcdr
} // namespace eprosima
 
#endif //_FASTCDR_XCDR_EXTERNAL_HPP_