is.hpp

Go to the documentation of this file.

 
#pragma once
#include "any.hpp"
#include "parse.hpp"
#include "types.hpp"
#include "unused.hpp"
#include <limits>
#include <memory>
#include <stdexcept>
 
namespace xtd {
  template<typename value_t>
  inline bool is(bool value) {return false;}
  template<typename value_t>
  inline bool is(decimal value) {return false;}
  template<typename value_t>
  inline bool is(double value) {return false;}
  template<typename value_t>
  inline bool is(float value) {return false;}
  template<typename value_t>
  inline bool is(sbyte value) {return false;}
  template<typename value_t>
  inline bool is(int16 value) {return false;}
  template<typename value_t>
  inline bool is(int32 value) {return false;}
  template<typename value_t>
  inline bool is(int64 value) {return false;}
  template<typename value_t>
  inline bool is(slong value) {return false;}
  template<typename value_t>
  inline bool is(xtd::byte value) {return false;}
  template<typename value_t>
  inline bool is(uint16 value) {return false;}
  template<typename value_t>
  inline bool is(uint32 value) {return false;}
  template<typename value_t>
  inline bool is(uint64 value) {return false;}
  template<typename value_t>
  inline bool is(xtd::ulong value) {return false;}
  
  template<>
  inline bool is<bool>(bool value) {
    return true;
  }
  
  template<>
  inline bool is<decimal>(decimal value) {
    return true;
  }
  
  template<>
  inline bool is<double>(double value) {
    return true;
  }
  
  template<>
  inline bool is<float>(float value) {
    return true;
  }
  
  template<>
  inline bool is<sbyte>(sbyte value) {
    return true;
  }
  
  template<>
  inline bool is<int16>(int16 value) {
    return true;
  }
  
  template<>
  inline bool is<int32>(int32 value) {
    return true;
  }
  
  template<>
  inline bool is<int64>(int64 value) {
    return true;
  }
  
  template<>
  inline bool is<slong>(slong value) {
    return true;
  }
  
  template<>
  inline bool is<xtd::byte>(xtd::byte value) {
    return true;
  }
  
  template<>
  inline bool is<uint16>(uint16 value) {
    return true;
  }
  
  template<>
  inline bool is<uint32>(uint32 value) {
    return true;
  }
  
  template<>
  inline bool is<uint64>(uint64 value) {
    return true;
  }
  
  template<>
  inline bool is<xtd::ulong>(xtd::ulong value) {
    return true;
  }
  
  template<typename type_t>
  bool is(std::any value) {
    try {
      std::any_cast<type_t>(value);
      return true;
    } catch (const std::bad_cast&) {
      return false;
    }
  }
  
  template<>
  inline bool is<std::any>(std::any value) {
    return true;
  }
  
  template<typename type_t, typename param_t>
  bool is(const param_t* value) {
    try {
      if (value == nullptr) return false;
      return dynamic_cast<const type_t*>(value) != nullptr;
    } catch (const std::bad_cast&) {
      return false;
    }
  }
  
  template<typename type_t, typename param_t>
  bool is(const param_t& value) {
    return is<type_t>(&value);
  }
  
  template<typename type_t, typename param_t>
  bool is(param_t* value) {
    try {
      if (value == nullptr) return false;
      return dynamic_cast<type_t*>(value) != nullptr;
    } catch (const std::bad_cast&) {
      return false;
    }
  }
  
  template<typename type_t, typename param_t>
  bool is(param_t& value) {
    return is<type_t>(&value);
  }
  
  template<typename new_type_t, typename current_type_t>
  bool is(xtd::sptr<current_type_t>& value) {
    auto result = std::dynamic_pointer_cast<new_type_t>(value);
    if (result) return true;
    return false;
  }
}