helics  2.8.1
Classes | Namespaces | Typedefs | Enumerations | Functions | Variables
helicsTypes.hpp File Reference
#include "../core/core-data.hpp"
#include "helics_cxx_export.h"
#include <complex>
#include <limits>
#include <string>
#include <typeinfo>
#include <utility>
#include <vector>

Go to the source code of this file.

Classes

class  helics::identifier_id_t< BaseType, ID, invalidValue >
 
struct  std::hash< helics::identifier_id_t< BaseType, ID, invalidValue > >
 
class  helics::NamedPoint
 

Namespaces

 helics
 the main namespace for the helics co-simulation library User functions will be in the helics namespace with internal functions possible in a lower level namespace
 

Typedefs

using helics::identifier_type = std::uint32_t
 specify the underlying type used in the identifiers
 
using helics::publication_id_t = identifier_id_t< identifier_type, identifiers::publication, invalid_id_value >
 
using helics::input_id_t = identifier_id_t< identifier_type, identifiers::input, invalid_id_value >
 
using helics::query_id_t = identifier_id_t< identifier_type, identifiers::query, invalid_id_value >
 
template<typename T >
using helics::remove_cv_ref = std::remove_cv_t< std::remove_reference_t< T > >
 Helper template to remove const volatile references.
 
template<typename X >
using helics::typeCategory = std::conditional_t< helicsType< remove_cv_ref< X > >() !=data_type::helics_custom, std::integral_constant< int, primaryType >, std::conditional_t< isConvertableType< remove_cv_ref< X > >(), std::integral_constant< int, convertibleType >, std::integral_constant< int, nonConvertibleType > >>
 

Enumerations

enum  helics::identifiers : char {
  publication, input, filter, endpoint,
  query
}
 
enum  helics::interface_visibility { local, global }
 
enum  helics::data_type : int {
  helics_string = helics_data_type_string, helics_double = helics_data_type_double, helics_int = helics_data_type_int, helics_complex = helics_data_type_complex,
  helics_vector = helics_data_type_vector, helics_complex_vector = helics_data_type_complex_vector, helics_named_point = helics_data_type_named_point, helics_bool = helics_data_type_boolean,
  helics_time = helics_data_type_time, helics_custom = helics_data_type_raw, helics_any = helics_data_type_any, helics_multi = helics_data_type_multi,
  helics_json = helics_data_type_json, helics_unknown = 262355
}
 

Functions

template<class X >
constexpr const char * helics::typeNameString ()
 
template<>
constexpr const char * helics::typeNameString< std::vector< std::string > > ()
 
template<>
constexpr const char * helics::typeNameString< std::vector< double > > ()
 
template<>
constexpr const char * helics::typeNameString< std::vector< std::complex< double > > > ()
 
template<>
constexpr const char * helics::typeNameString< double > ()
 
template<>
constexpr const char * helics::typeNameString< float > ()
 
template<>
constexpr const char * helics::typeNameString< bool > ()
 
template<>
constexpr const char * helics::typeNameString< char > ()
 
template<>
constexpr const char * helics::typeNameString< unsigned char > ()
 
template<>
constexpr const char * helics::typeNameString< std::int32_t > ()
 
template<>
constexpr const char * helics::typeNameString< std::uint32_t > ()
 
template<>
constexpr const char * helics::typeNameString< int64_t > ()
 
template<>
constexpr const char * helics::typeNameString< std::uint64_t > ()
 
template<>
constexpr const char * helics::typeNameString< std::complex< float > > ()
 
template<>
constexpr const char * helics::typeNameString< std::complex< double > > ()
 
template<>
constexpr const char * helics::typeNameString< std::string > ()
 
template<>
constexpr const char * helics::typeNameString< NamedPoint > ()
 
constexpr bool helics::isRawType (data_type type)
 
const std::string & helics::typeNameStringRef (data_type type)
 
data_type helics::getTypeFromString (const std::string &typeName)
 
std::string helics::helicsComplexString (double real, double imag)
 
std::string helics::helicsComplexString (std::complex< double > val)
 
std::string helics::helicsVectorString (const std::vector< double > &val)
 
std::string helics::helicsVectorString (const double *vals, size_t size)
 
std::string helics::helicsComplexVectorString (const std::vector< std::complex< double >> &val)
 
std::string helics::helicsNamedPointString (const NamedPoint &point)
 
std::string helics::helicsNamedPointString (const std::string &pointName, double val)
 
std::string helics::helicsNamedPointString (const char *pointName, double val)
 
std::complex< double > helics::helicsGetComplex (const std::string &val)
 
std::vector< double > helics::helicsGetVector (const std::string &val)
 
void helics::helicsGetVector (const std::string &val, std::vector< double > &data)
 
std::vector< std::complex< double > > helics::helicsGetComplexVector (const std::string &val)
 
void helics::helicsGetComplexVector (const std::string &val, std::vector< std::complex< double >> &data)
 
NamedPoint helics::helicsGetNamedPoint (const std::string &val)
 
double helics::getDoubleFromString (const std::string &val)
 
std::complex< double > helics::getComplexFromString (const std::string &val)
 
bool helics::helicsBoolValue (const std::string &val)
 
double helics::vectorNorm (const std::vector< double > &vec)
 
double helics::vectorNorm (const std::vector< std::complex< double >> &vec)
 
data_block helics::typeConvert (data_type type, double val)
 
data_block helics::typeConvert (data_type type, int64_t val)
 
data_block helics::typeConvert (data_type type, const char *val)
 
data_block helics::typeConvert (data_type type, const std::string &val)
 
data_block helics::typeConvert (data_type type, const std::vector< double > &val)
 
data_block helics::typeConvert (data_type type, const double *vals, size_t size)
 
data_block helics::typeConvert (data_type type, const std::vector< std::complex< double >> &val)
 
data_block helics::typeConvert (data_type type, const std::complex< double > &val)
 
data_block helics::typeConvert (data_type type, const NamedPoint &val)
 
data_block helics::typeConvert (data_type type, const char *str, double val)
 
data_block helics::typeConvert (data_type type, const std::string &str, double val)
 
data_block helics::typeConvert (data_type type, bool val)
 
template<class X >
constexpr data_type helics::helicsType ()
 
template<>
constexpr data_type helics::helicsType< int64_t > ()
 
template<>
constexpr data_type helics::helicsType< bool > ()
 
template<>
constexpr data_type helics::helicsType< std::string > ()
 
template<>
constexpr data_type helics::helicsType< NamedPoint > ()
 
template<>
constexpr data_type helics::helicsType< double > ()
 
template<>
constexpr data_type helics::helicsType< Time > ()
 
template<>
constexpr data_type helics::helicsType< std::complex< double > > ()
 
template<>
constexpr data_type helics::helicsType< std::vector< double > > ()
 
template<>
constexpr data_type helics::helicsType< std::vector< std::complex< double > > > ()
 
template<class X >
constexpr bool helics::isConvertableType ()
 
template<>
constexpr bool helics::isConvertableType< float > ()
 
template<>
constexpr bool helics::isConvertableType< long double > ()
 
template<>
constexpr bool helics::isConvertableType< int32_t > ()
 
template<>
constexpr bool helics::isConvertableType< int16_t > ()
 
template<>
constexpr bool helics::isConvertableType< uint16_t > ()
 
template<>
constexpr bool helics::isConvertableType< char > ()
 
template<>
constexpr bool helics::isConvertableType< unsigned char > ()
 
template<>
constexpr bool helics::isConvertableType< uint64_t > ()
 
template<class X >
helics::invalidValue ()
 
template<>
constexpr double helics::invalidValue< double > ()
 
template<>
constexpr int64_t helics::invalidValue< int64_t > ()
 
template<>
constexpr uint64_t helics::invalidValue< uint64_t > ()
 
template<>
constexpr Time helics::invalidValue< Time > ()
 
template<>
NamedPoint helics::invalidValue< NamedPoint > ()
 
template<>
constexpr std::complex< double > helics::invalidValue< std::complex< double > > ()
 

Variables

constexpr identifier_type helics::invalid_id_value
 defining an invalid id value More...
 
constexpr interface_visibility helics::GLOBAL = interface_visibility::global
 
constexpr interface_visibility helics::LOCAL = interface_visibility::local
 
constexpr auto helics::typestrings::svecstr = "string_vector"
 
constexpr auto helics::typestrings::dvecstr = "double_vector"
 
constexpr auto helics::typestrings::cvecstr = "complex_vector"
 
constexpr auto helics::typestrings::doublestr = "double"
 
constexpr auto helics::typestrings::floatstr = "float"
 
constexpr auto helics::typestrings::boolstr = "bool"
 
constexpr auto helics::typestrings::charstr = "char"
 
constexpr auto helics::typestrings::ucharstr = "uchar"
 
constexpr auto helics::typestrings::i32str = "int32"
 
constexpr auto helics::typestrings::ui32str = "uint32"
 
constexpr auto helics::typestrings::i64str = "int64"
 
constexpr auto helics::typestrings::ui64str = "uint64"
 
constexpr auto helics::typestrings::cfloatstr = "complex_f"
 
constexpr auto helics::typestrings::cdoublestr = "complex"
 
constexpr auto helics::typestrings::npstr = "named_point"
 
constexpr auto helics::typestrings::strstr = "string"
 
constexpr double helics::invalidDouble = -1e48
 defined constant for an invalid value as a double
 
constexpr int helics::primaryType = 0
 
constexpr int helics::convertibleType = 1
 
constexpr int helics::nonConvertibleType = 2
 

Detailed Description

basic type information and control for HELICS