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"

template<class new_type_t, class current_type_t>
new_type_t* __convert_value__(current_type_t* value);

namespace xtd {
  class convert_pointer static_ {
  public:
    
    template<class new_type_t, class 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<class new_type_t, class 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<class new_type_t, class current_type_t>
    static const new_type_t* to_ptr(const current_type_t& value) {
      return &to_ref<new_type_t>(value);
    }
    
    template<class new_type_t, class current_type_t>
    static new_type_t* to_ptr(current_type_t& value) {
      return &to_ref<new_type_t>(value);
    }
    
    template<class new_type_t, class current_type_t>
    static xtd::ptr<new_type_t> to_ptr(const xtd::ptr<current_type_t>& value) {
      return to_shared_ptr<new_type_t>(value);
    }
    
    template<class new_type_t, class current_type_t>
    static xtd::ptr<new_type_t> to_ptr(xtd::ptr<current_type_t>& value) {
      return to_shared_ptr<new_type_t>(value);
    }
    
    template<class new_type_t, class current_type_t>
    static xtd::ptr<new_type_t> to_ptr(xtd::ptr<current_type_t>&& value) {
      return to_shared_ptr<new_type_t>(std::move(value));
    }
    
    template<class new_type_t, class 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) {
        xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
      }
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
    }
    
    template<class new_type_t, class 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) {
        xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
      }
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
    }
    
    template<class new_type_t, class current_type_t>
    static const new_type_t& to_ref(const current_type_t* value) {
      if (value == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_null);
      try {
        return dynamic_cast<const new_type_t&>(*value);
      } catch (const std::exception& e) {
        xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
      }
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
    }
    
    template<class new_type_t, class current_type_t>
    static new_type_t& to_ref(current_type_t* value) {
      if (value == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_null);
      try {
        return dynamic_cast<new_type_t&>(*value);
      } catch (const std::exception& e) {
        xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
      }
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
    }
    
    template<class new_type_t, class current_type_t>
    static xtd::sptr<new_type_t> to_shared_ptr(const xtd::sptr<current_type_t>& value) {
      try {
        [[maybe_unused]] auto result = dynamic_cast<new_type_t&>(*value.get());
      } catch (const std::exception& e) {
        xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
      }
      return std::dynamic_pointer_cast<new_type_t>(value.pointer());
    }
    
    template<class new_type_t, class current_type_t>
    static xtd::sptr<new_type_t> to_shared_ptr(xtd::sptr<current_type_t>& value) {
      try {
        [[maybe_unused]] auto& result = dynamic_cast<new_type_t&>(*value.get());
      } catch (const std::exception& e) {
        xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
      }
      return std::dynamic_pointer_cast<new_type_t>(value.pointer());
    }
    
    template<class new_type_t, class current_type_t>
    static xtd::sptr<new_type_t> to_shared_ptr(xtd::sptr<current_type_t>&& value) {
      try {
        [[maybe_unused]] auto& result = dynamic_cast<new_type_t&>(*value.get());
      } catch (const std::exception& e) {
        xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
      }
      //return std::move(value);
      return std::dynamic_pointer_cast<new_type_t>(std::move(value.pointer()));
    }
    
    template<class new_type_t, class current_type_t>
    static xtd::sptr<new_type_t> to_sptr(const xtd::sptr<current_type_t>& value) {
      return to_shared_ptr<new_type_t>(value);
    }
    
    template<class new_type_t, class current_type_t>
    static xtd::sptr<new_type_t> to_sptr(xtd::sptr<current_type_t>& value) {
      return to_shared_ptr<new_type_t>(value);
    }
    
    template<class new_type_t, class current_type_t>
    static xtd::sptr<new_type_t> to_sptr(xtd::sptr<current_type_t>&& value) {
      return to_shared_ptr<new_type_t>(std::move(value));
    }
    
    template<class new_type_t, class 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);
        xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
      }
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
    }
    
    template<class new_type_t, class 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);
        xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
      }
      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
    }
    
    template<class new_type_t, class current_type_t>
    static xtd::uptr<new_type_t> to_uptr(xtd::uptr<current_type_t>& value) {
      return to_unique_ptr<new_type_t>(value);
    }
    
    template<class new_type_t, class current_type_t>
    static xtd::uptr<new_type_t> to_uptr(xtd::uptr<current_type_t>&& value) {
      return to_unique_ptr<new_type_t>(std::move(value));
    }

  };
}