convert_pointer.h

Go to the documentation of this file.

 
#pragma once
#include "any.h"
#include "argument_null_exception.h"
#include "invalid_cast_exception.h"
#include "static.h"
#include "types.h"
#include "unused.h"
 
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 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 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) {
      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 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) {
      if (value == nullptr) throw argument_null_exception {csf_};
      return *value;
    }
    template<typename type_t>
    static type_t& to_ref(type_t* value) { // value parameter can't be const by design.
      if (value == nullptr) throw argument_null_exception {csf_};
      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) {
      if (value == nullptr) throw argument_null_exception {csf_};
      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) {
      if (value == nullptr) throw argument_null_exception {csf_};
      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 std::unique_ptr<new_type_t> to_unique_ptr(std::unique_ptr<current_type_t>& value) {
      auto ptr = value.release();
      try {
        return std::unique_ptr<new_type_t>(__convert_value__<new_type_t>(ptr));
      } catch (const std::exception& e) {
        value = std::unique_ptr<current_type_t>(ptr);
        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) {
      auto ptr = value.release();
      try {
        return std::unique_ptr<new_type_t>(__convert_value__<new_type_t>(ptr));
      } catch (const std::exception& e) {
        value = std::unique_ptr<current_type_t>(ptr);
        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 {
        unused_(dynamic_cast<new_type_t&>(*value.get()));
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what(), csf_);
      }
      return std::dynamic_pointer_cast<new_type_t>(value);
    }
    
    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 {
        unused_(dynamic_cast<new_type_t&>(*value.get()));
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what(), csf_);
      }
      return std::dynamic_pointer_cast<new_type_t>(value);
    }
    
    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 {
        unused_(dynamic_cast<new_type_t&>(*value.get()));
      } catch (const std::exception& e) {
        throw invalid_cast_exception(e.what(), csf_);
      }
      //return std::move(value);
      return std::dynamic_pointer_cast<new_type_t>(std::move(value));
    }
  };
}