convert_pointer.h

Go to the documentation of this file.

 
#pragma once
#include <any>
#include "static.h"
#include "types.h"
#include "invalid_cast_exception.h"
 
namespace xtd {
  class convert_pointer static_ {
  public:
    template<typename type_t>
    static const type_t& to_ref(const type_t& value) {
      return value;
    }
    
    template<typename type_t>
    static type_t& to_ref(type_t& value) {
      return value;
    }
    template<typename type_t>
    static const type_t& to_ref(const type_t* value) {
      return *value;
    }
    template<typename type_t>
    static type_t& to_ref(type_t* value) {
      return *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(), csf_);
      }
      throw invalid_cast_exception(csf_);
    }
 
    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(), csf_);
      }
      throw invalid_cast_exception(csf_);
    }
 
    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(), csf_);
      }
      throw invalid_cast_exception(csf_);
    }
 
    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(), csf_);
      }
      throw invalid_cast_exception(csf_);
    }
    
    template<typename type_t>
    static const type_t* to_ptr(const type_t* value) {
      return value;
    }
    
    template<typename type_t>
    static type_t* to_ptr(type_t* value) {
      return value;
    }
 
    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) {
      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 std::unique_ptr<new_type_t> to_unique_ptr(std::unique_ptr<current_type_t>& value) {
      try {
        //return move(value);
        return std::unique_ptr<new_type_t>(as<new_type_t>(value.release()));
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what(), csf_);
      }
      throw invalid_cast_exception(csf_);
    }
    
    template<typename new_type_t, typename current_type_t>
    static std::unique_ptr<new_type_t> to_unique_ptr(std::unique_ptr<current_type_t>&& value) {
      try {
        //return move(value);
        return std::unique_ptr<new_type_t>(as<new_type_t>(value.release()));
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what(), csf_);
      }
      throw invalid_cast_exception(csf_);
    }
    
    template<typename new_type_t, typename current_type_t>
    static std::shared_ptr<new_type_t> to_shared_ptr(const std::shared_ptr<current_type_t>& value) {
      try {
        return dynamic_pointer_cast<new_type_t>(value);
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what(), csf_);
      }
      throw invalid_cast_exception(csf_);
    }
    
    template<typename new_type_t, typename current_type_t>
    static std::shared_ptr<new_type_t> to_shared_ptr(std::shared_ptr<current_type_t>& value) {
      try {
        return dynamic_pointer_cast<new_type_t>(value);
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what(), csf_);
      }
      throw invalid_cast_exception(csf_);
    }
    
    template<typename new_type_t, typename current_type_t>
    static std::shared_ptr<new_type_t> to_shared_ptr(std::shared_ptr<current_type_t>&& value) {
      try {
        return move(value);
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what(), csf_);
      }
      throw invalid_cast_exception(csf_);
    }
  };
}