is.h

Go to the documentation of this file.

 
#pragma once
#include <any>
#include <limits>
#include <memory>
#include <stdexcept>
#include "parse.h"
#include "types.h"
#include "unused.h"
 
namespace xtd {
  template<typename value_t>
  inline bool is(bool value) {return false;}
  template<typename value_t>
  inline bool is(decimal_t 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(int8_t value) {return false;}
  template<typename value_t>
  inline bool is(int16_t value) {return false;}
  template<typename value_t>
  inline bool is(int32_t value) {return false;}
  template<typename value_t>
  inline bool is(int64_t value) {return false;}
  template<typename value_t>
  inline bool is(llong_t value) {return false;}
  template<typename value_t>
  inline bool is(uint8_t value) {return false;}
  template<typename value_t>
  inline bool is(uint16_t value) {return false;}
  template<typename value_t>
  inline bool is(uint32_t value) {return false;}
  template<typename value_t>
  inline bool is(uint64_t value) {return false;}
  template<typename value_t>
  inline bool is(ullong_t value) {return false;}
  
  template<>
  inline bool is<bool>(bool value) {
    return true;
  }
  
  template<>
  inline bool is<decimal_t>(decimal_t 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<int8_t>(int8_t value) {
    return true;
  }
 
  template<>
  inline bool is<int16_t>(int16_t value) {
    return true;
  }
  
  template<>
  inline bool is<int32_t>(int32_t value) {
    return true;
  }
  
  template<>
  inline bool is<int64_t>(int64_t value) {
    return true;
  }
 
  template<>
  inline bool is<llong_t>(llong_t value) {
    return true;
  }
 
  template<>
  inline bool is<uint8_t>(uint8_t value) {
    return true;
  }
  
  template<>
  inline bool is<uint16_t>(uint16_t value) {
    return true;
  }
    
  template<>
  inline bool is<uint32_t>(uint32_t value) {
    return true;
  }
  
  template<>
  inline bool is<uint64_t>(uint64_t value) {
    return true;
  }
  
  template<>
  inline bool is<ullong_t>(ullong_t value) {
    return true;
  }
 
  template<typename type_t>
  bool is(std::any value) {
    try {
      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(std::shared_ptr<current_type_t>& value) {
    try {
      unused_(dynamic_pointer_cast<new_type_t>(value));
      return true;
    } catch (const std::exception&) {
      return false;
    }
    return false;
  }
}