src/hpp/dds/core/Reference.hpp

Go to the documentation of this file.

#ifndef OMG_DDS_CORE_REFERENCE_HPP_
#define OMG_DDS_CORE_REFERENCE_HPP_

/* Copyright 2010, Object Management Group, Inc.
 * Copyright 2010, PrismTech, Inc.
 * Copyright 2010, Real-Time Innovations, Inc.
 * All rights reserved.
 *
 * 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.
 */

#include <dds/core/corefwd.hpp>
#include <dds/core/Exception.hpp>
#include <dds/core/refmacros.hpp>
#include <dds/core/types.hpp>

//TODO: Move required parts in the "detail" namespace

namespace dds { namespace core {


template <typename DELEGATE>
class Reference
{
public:
    DECLARE_TYPE_TRAITS(DELEGATE)

protected:
    Reference() : impl_() {
       OMG_DDS_LOG("MM", "Reference()");
    }

    Reference(const Reference& ref) : impl_(ref.delegate()) {
        OMG_DDS_LOG("MM", "Reference(const Reference& ref)");
    }

    template <typename D>
    Reference(const Reference<D>& ref)
    {
        OMG_DDS_STATIC_ASSERT((dds::core::is_base_of<DELEGATE_T,  D>::value));
        OMG_DDS_LOG("MM", "Reference(const Reference<D>& ref)");
        impl_ = ref.delegate();
    }

    template <typename R>
    Reference(const R& that) {
        OMG_DDS_STATIC_ASSERT((dds::core::is_base_of<DELEGATE_T, typename R::DELEGATE_T>::value));
        impl_ = that.delegate();
    }

    explicit Reference(DELEGATE_T* p) : impl_(p) {
        OMG_DDS_LOG("MM", "Reference(DELEGATE_T* p)");
    }

    Reference(const DELEGATE_REF_T& ref) : impl_(ref) {
        OMG_DDS_LOG("MM", "Reference(const DELEGATE_REF_T& ref)");
    }

public:
    ~Reference() {
        OMG_DDS_LOG("MM", "~Reference()");
    }

public:
    operator DELEGATE_REF_T() const {
        return impl_;
    }

    template <typename R>
    bool operator==(const R& ref) const {
        return this->delegate() == ref.delegate();
    }

    template <typename R>
    bool operator!=(const R& ref) const {
        return this->delegate() != ref.delegate();
    }

    template <typename D>
    Reference& operator=(const Reference<D>& that) {
        OMG_DDS_STATIC_ASSERT((dds::core::is_base_of<DELEGATE_T, D>::value));
        if (this != (Reference*)&that) {
            *this = Reference<DELEGATE_T>(that);
        }
        return *this;
    }

    template <typename R>
    Reference& operator=(const R& rhs) {
        OMG_DDS_STATIC_ASSERT((dds::core::is_base_of< DELEGATE_T, typename R::DELEGATE_T>::value));
        if (this != (Reference*)&rhs)
            *this = Reference<DELEGATE_T>(rhs);
        return *this;
    }

    Reference&
    operator=(const null_type) {
        DELEGATE_REF_T tmp;
        impl_ = tmp;
        return *this;
    }

    bool is_nil() const {
        return this->delegate().get() == 0;
    }

    bool
    operator==(const null_type) const {
        return this->is_nil();
    }

    bool operator!=(const null_type nil) const {
        return !(this->is_nil());
    }

private:
    // -- disallow dynamic allocation for reference types
    void* operator new(size_t);



public:
    const DELEGATE_REF_T& delegate() const {
        return impl_;
    }

    DELEGATE_REF_T& delegate() {
        return impl_;
    }

    DELEGATE* operator->() {
        return impl_.get();
    }

    const DELEGATE* operator->() const {
        return impl_.get();
    }

protected:
    DELEGATE_REF_T impl_;
};


} } /* namespace dds / namespace core */

#endif /* OMG_DDS_CORE_REFERENCE_HPP_ */