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<class value_t>
  inline bool is(bool value) {return false;}
  template<class value_t>
  inline bool is(char value) {return false;}
  template<class value_t>
  inline bool is(char16 value) {return false;}
  template<class value_t>
  inline bool is(char32 value) {return false;}
  template<class value_t>
  inline bool is(char8 value) {return false;}
  template<class value_t>
  inline bool is(wchar value) {return false;}
  template<class value_t>
  inline bool is(decimal value) {return false;}
  template<class value_t>
  inline bool is(double value) {return false;}
  template<class value_t>
  inline bool is(float value) {return false;}
  template<class value_t>
  inline bool is(sbyte value) {return false;}
  template<class value_t>
  inline bool is(int16 value) {return false;}
  template<class value_t>
  inline bool is(int32 value) {return false;}
  template<class value_t>
  inline bool is(int64 value) {return false;}
  template<class value_t>
  inline bool is(slong value) {return false;}
  template<class value_t>
  inline bool is(xtd::byte value) {return false;}
  template<class value_t>
  inline bool is(uint16 value) {return false;}
  template<class value_t>
  inline bool is(uint32 value) {return false;}
  template<class value_t>
  inline bool is(uint64 value) {return false;}
  template<class value_t>
  inline bool is(xtd::ulong value) {return false;}
  
  template<>
  inline bool is<bool>(bool value) {
    return true;
  }
  inline bool is<bool>(bool value) {…}
  
  template<>
  inline bool is<char>(char value) {
    return true;
  }
  inline bool is<char>(char value) {…}
  
  template<>
  inline bool is<char16>(char16 value) {
    return true;
  }
  inline bool is<char16>(char16 value) {…}
  
  template<>
  inline bool is<char32>(char32 value) {
    return true;
  }
  inline bool is<char32>(char32 value) {…}
  
  template<>
  inline bool is<char8>(char8 value) {
    return true;
  }
  inline bool is<char8>(char8 value) {…}

  template<>
  inline bool is<wchar>(wchar value) {
    return true;
  }
  inline bool is<wchar>(wchar value) {…}

  template<>
  inline bool is<decimal>(decimal value) {
    return true;
  }
  inline bool is<decimal>(decimal value) {…}
  
  template<>
  inline bool is<double>(double value) {
    return true;
  }
  inline bool is<double>(double value) {…}
  
  template<>
  inline bool is<float>(float value) {
    return true;
  }
  inline bool is<float>(float value) {…}
  
  template<>
  inline bool is<sbyte>(sbyte value) {
    return true;
  }
  inline bool is<sbyte>(sbyte value) {…}
  
  template<>
  inline bool is<int16>(int16 value) {
    return true;
  }
  inline bool is<int16>(int16 value) {…}
  
  template<>
  inline bool is<int32>(int32 value) {
    return true;
  }
  inline bool is<int32>(int32 value) {…}
  
  template<>
  inline bool is<int64>(int64 value) {
    return true;
  }
  inline bool is<int64>(int64 value) {…}
  
  template<>
  inline bool is<slong>(slong value) {
    return true;
  }
  inline bool is<slong>(slong value) {…}
  
  template<>
  inline bool is<xtd::byte>(xtd::byte value) {
    return true;
  }
  inline bool is<xtd::byte>(xtd::byte value) {…}
  
  template<>
  inline bool is<uint16>(uint16 value) {
    return true;
  }
  inline bool is<uint16>(uint16 value) {…}
  
  template<>
  inline bool is<uint32>(uint32 value) {
    return true;
  }
  inline bool is<uint32>(uint32 value) {…}
  
  template<>
  inline bool is<uint64>(uint64 value) {
    return true;
  }
  inline bool is<uint64>(uint64 value) {…}
  
  template<>
  inline bool is<xtd::ulong>(xtd::ulong value) {
    return true;
  }
  inline bool is<xtd::ulong>(xtd::ulong value) {…}
  
  template<class type_t>
  bool is(xtd::any value) {
    try {
      xtd::any_cast<type_t>(value);
      return true;
    } catch (const std::bad_cast&) {
      return false;
    }
  }
  bool is(xtd::any value) {…}
  
  template<>
  inline bool is<xtd::any>(xtd::any value) {
    return true;
  }
  inline bool is<xtd::any>(xtd::any value) {…}
  
  template<class type_t, class 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;
    }
  }
  bool is(const param_t* value) {…}
  
  template<class type_t, class param_t>
  bool is(const param_t& value) {
    return is<type_t>(&value);
  }
  bool is(const param_t& value) {…}
  
  template<class type_t, class 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;
    }
  }
  bool is(param_t* value) {…}
  
  template<class type_t, class param_t>
  bool is(param_t& value) {
    return is<type_t>(&value);
  }
  bool is(param_t& value) {…}
  
  template<class new_type_t, class current_type_t>
  bool is(xtd::sptr<current_type_t>& value) {
    auto result = std::dynamic_pointer_cast<new_type_t>(value.pointer());
    if (result) return true;
    return false;
  }
  bool is(xtd::sptr<current_type_t>& value) {…}
}