convert_pointer.hpp

Go to the documentation of this file.

 
#pragma once
#include "any.hpp"
#include "argument_null_exception.hpp"
#include "invalid_cast_exception.hpp"
#include "static.hpp"
#include "types.hpp"
#include "unused.hpp"
 
template<typename new_type_t, typename current_type_t>
new_type_t* __convert_value__(current_type_t* value);
 
namespace xtd {
  class convert_pointer static_ {
  public:
    
    template<typename new_type_t, typename current_type_t>
    static const new_type_t* to_ptr(const current_type_t* value) {
      if (value == nullptr) return nullptr;
      return &to_ref<new_type_t>(*value);
    }
    
    template<typename new_type_t, typename current_type_t>
    static new_type_t* to_ptr(current_type_t* value) {
      if (value == nullptr) return nullptr;
      return &to_ref<new_type_t>(*value);
    }
    
    template<typename new_type_t, typename current_type_t>
    static const new_type_t* to_ptr(const current_type_t& value) {
      return &to_ref<new_type_t>(value);
    }
    
    template<typename new_type_t, typename current_type_t>
    static new_type_t* to_ptr(current_type_t& value) {
      return &to_ref<new_type_t>(value);
    }
        
    template<typename new_type_t, typename current_type_t>
    static const new_type_t& to_ref(const current_type_t& value) {
      try {
        return dynamic_cast<const new_type_t&>(value);
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what());
      }
      throw invalid_cast_exception {};
    }
    
    template<typename new_type_t, typename current_type_t>
    static new_type_t& to_ref(current_type_t& value) {
      try {
        return dynamic_cast<new_type_t&>(value);
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what());
      }
      throw invalid_cast_exception {};
    }
    
    template<typename new_type_t, typename current_type_t>
    static const new_type_t& to_ref(const current_type_t* value) {
      if (value == nullptr) throw argument_null_exception {};
      try {
        return dynamic_cast<const new_type_t&>(*value);
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what());
      }
      throw invalid_cast_exception {};
    }
    
    template<typename new_type_t, typename current_type_t>
    static new_type_t& to_ref(current_type_t* value) {
      if (value == nullptr) throw argument_null_exception {};
      try {
        return dynamic_cast<new_type_t&>(*value);
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what());
      }
      throw invalid_cast_exception {};
    }
    
    template<typename new_type_t, typename current_type_t>
    static xtd::uptr<new_type_t> to_unique_ptr(xtd::uptr<current_type_t>& value) {
      auto ptr = value.release();
      try {
        return xtd::uptr<new_type_t>(__convert_value__<new_type_t>(ptr));
      } catch (const std::exception& e) {
        value = xtd::uptr<current_type_t>(ptr);
        throw invalid_cast_exception(e.what());
      }
      throw invalid_cast_exception {};
    }
    
    template<typename new_type_t, typename current_type_t>
    static xtd::uptr<new_type_t> to_unique_ptr(xtd::uptr<current_type_t>&& value) {
      auto ptr = value.release();
      try {
        return xtd::uptr<new_type_t>(__convert_value__<new_type_t>(ptr));
      } catch (const std::exception& e) {
        value = xtd::uptr<current_type_t>(ptr);
        throw invalid_cast_exception(e.what());
      }
      throw invalid_cast_exception {};
    }
    
    template<typename new_type_t, typename current_type_t>
    static xtd::sptr<new_type_t> to_shared_ptr(const xtd::sptr<current_type_t>& value) {
      try {
        unused_(dynamic_cast<new_type_t&>(*value.get()));
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what());
      }
      return std::dynamic_pointer_cast<new_type_t>(value);
    }
    
    template<typename new_type_t, typename current_type_t>
    static xtd::sptr<new_type_t> to_shared_ptr(xtd::sptr<current_type_t>& value) {
      try {
        unused_(dynamic_cast<new_type_t&>(*value.get()));
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what());
      }
      return std::dynamic_pointer_cast<new_type_t>(value);
    }
    
    template<typename new_type_t, typename current_type_t>
    static xtd::sptr<new_type_t> to_shared_ptr(xtd::sptr<current_type_t>&& value) {
      try {
        unused_(dynamic_cast<new_type_t&>(*value.get()));
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what());
      }
      //return std::move(value);
      return std::dynamic_pointer_cast<new_type_t>(std::move(value));
    }
  };
}