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, class current_type>
new_type* __convert_value__(current_type* value);

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

  };
}