Types.h

Go to the documentation of this file.

 
#ifndef KIDS_TYPES_H
#define KIDS_TYPES_H
 
#include <complex>
// #include "generate/version.h"
 
namespace PROJECT_NS {
 
// Forward declarations
class Param;
class Node;
class DataSet;
 
// Enumeration for data types
enum kids_dtype {
    kids_void_type,     
    kids_bool_type,     
    kids_int_type,      
    kids_real_type,     
    kids_complex_type,  
    kids_str_type,      
    kids_param_type,    
    kids_dataset_type   
};
 
// Alias declarations for data types
using kids_void    = void;                  
using kids_bool    = bool;                  
using kids_int     = int;                   
using kids_bint    = int;                   
using kids_real    = double;                
using kids_complex = std::complex<double>;  
using kids_str     = std::string;           
using kids_param   = Param;                 
using kids_dataset = DataSet;               
 
// Casts a value from one type to another
template <class Tto, class Tfrom = void>
inline Tto cast(Tfrom value) {
    return static_cast<Tto>(value);
}
 
template <class Tto>
inline Tto cast_from_complex(kids_complex value) {
    return static_cast<Tto>(real(value));
}
 
template <>
inline kids_complex cast_from_complex(kids_complex value) {
    return value;
}
 
// Specialization for casting complex numbers to another type
template <class Tto>
inline Tto cast(kids_complex value) {
    return cast_from_complex<Tto>(value);
}
 
// Casts a value at a specific memory location to another type
template <class Tto, class Tfrom>
inline Tto cast_at(void* data, int index = 0) {
    return cast<Tto>(*((Tfrom*) data + index));
}
 
template <typename T>
kids_dtype as_enum();
 
template <typename T>
std::string as_str();
 
// Macro for defining utility functions for type binding
#define DEFINE_BIND_UTILS_FOR(T)     \
    template <>                      \
    inline kids_dtype as_enum<T>() { \
        return T##_type;             \
    }                                \
    template <>                      \
    inline std::string as_str<T>() { \
        return #T;                   \
    }
 
// Define utility functions for each data type
DEFINE_BIND_UTILS_FOR(kids_void);
DEFINE_BIND_UTILS_FOR(kids_int);
DEFINE_BIND_UTILS_FOR(kids_bool);
DEFINE_BIND_UTILS_FOR(kids_real);
DEFINE_BIND_UTILS_FOR(kids_complex);
DEFINE_BIND_UTILS_FOR(kids_str);
DEFINE_BIND_UTILS_FOR(kids_param);
DEFINE_BIND_UTILS_FOR(kids_dataset);
 
};  // namespace PROJECT_NS
 
#endif  // KIDS_TYPES_H