safe_typecode.h

Go to the documentation of this file.

/*********************************************************************************************
(c) 2005-2014 Copyright, Real-Time Innovations, Inc.  All rights reserved.
RTI grants Licensee a license to use, modify, compile, and create derivative works
of the Software.  Licensee has the right to distribute object form only for use with RTI
products.  The Software is provided "as is", with no warranty of any type, including
any warranty for fitness for any purpose. RTI is under no obligation to maintain or
support the Software.  RTI shall not be liable for any incidental or consequential
damages arising out of the use or inability to use the software.
**********************************************************************************************/

#ifndef RTIREFLEX_SAFE_TYPECODE_H
#define RTIREFLEX_SAFE_TYPECODE_H

#include <tuple>
#include <vector>
#include <array>
#include <string>
#include <iostream>
#include <boost/type_traits.hpp>

#include <ndds/ndds_cpp.h>
#include "reflex/dllexport.h"

namespace reflex {

  namespace detail {
      REFLEX_DLL_EXPORT const char *get_readable_ex_code(DDS_ExceptionCode_t ex);
      REFLEX_DLL_EXPORT void check_exception_code(const char * message, DDS_ExceptionCode_t ex);
  }

  template <class T>
  class SafeTypeCode
  {
    DDS_TypeCodeFactory * factory_;
    DDS_TypeCode * typecode_;
    bool is_shared_;

  public:

    explicit SafeTypeCode(DDS_TypeCode * tc)
      : factory_(DDS_TypeCodeFactory::get_instance()),
        typecode_(tc),
        is_shared_(false)
    { }

    explicit SafeTypeCode(const DDS_TypeCode * tc)
      : factory_(DDS_TypeCodeFactory::get_instance()),
        typecode_(const_cast<DDS_TypeCode *>(tc)),
        is_shared_(true)
    { }

    SafeTypeCode(DDS_TypeCodeFactory * fact,
                 DDS_TypeCode * tc)
      : factory_(fact),
        typecode_(tc),
        is_shared_(false)
    { }

    SafeTypeCode(DDS_TypeCodeFactory * fact,
                 const DDS_TypeCode * tc)
      : factory_(fact),
        typecode_(const_cast<DDS_TypeCode *>(tc)),
        is_shared_(true)
    { }

    SafeTypeCode(const SafeTypeCode & safetc)
      : factory_(safetc.factory_)
    {
      if (safetc.is_shared_)
      {
        typecode_ = safetc.typecode_;
        is_shared_ = true;
      }
      else
      {
        DDS_ExceptionCode_t ex = DDS_NO_EXCEPTION_CODE;
        typecode_ = factory_->clone_tc(safetc.typecode_, ex);
        is_shared_ = false;
        detail::check_exception_code(
          "SafeTypeCode::SafeTypeCode: Unable to clone typecode, error = ",
          ex);
      }
    }

    SafeTypeCode & operator = (const SafeTypeCode & rhs)
    {
      SafeTypeCode(rhs).swap(*this);
      return *this;
    }

#ifdef REFLEX_HAS_RVALUE_REF

    SafeTypeCode(SafeTypeCode && src) 
      : factory_(src.factory_),
        typecode_(src.typecode_),
        is_shared_(src.is_shared_)
    {
      src.factory_ = 0;
      src.typecode_ = 0;
    }

    SafeTypeCode & operator = (SafeTypeCode && src)
    {
      this->swap(src);
      return *this;
    }

#endif

    ~SafeTypeCode()
    {
        DDS_ExceptionCode_t ex = DDS_NO_EXCEPTION_CODE;
        if (factory_ && typecode_ && !is_shared_)
        {
          factory_->delete_tc(typecode_, ex);

          if (ex != DDS_NO_EXCEPTION_CODE)
          {
            std::cerr << "~SafeTypeCode: Unable to delete typecode, error = "
                      << detail::get_readable_ex_code(ex) 
                      << std::endl;
            // Do not throw.
          }
        }
    }

    DDS_TypeCode * get()
    {
      return typecode_;
    }

    const DDS_TypeCode * get() const
    {
      return typecode_;
    }

    DDS_TypeCode * release()
    {
      is_shared_ = true;
      return typecode_;
    }

    void swap(SafeTypeCode & stc) throw()
    {
      std::swap(factory_, stc.factory_);
      std::swap(typecode_, stc.typecode_);
      std::swap(is_shared_, stc.is_shared_);
    }
  };

  template <class T>
  void swap(SafeTypeCode<T> & lhs, SafeTypeCode<T> & rhs) throw()
  {
    lhs.swap(rhs);
  }


} // namespace reflex


#endif // RTIREFLEX_SAFE_TYPECODE_H