RNBO: common/RNBO_Types.h Source File

Go to the documentation of this file.
 #ifndef _RNBO_TYPES_H_
 #define _RNBO_TYPES_H_
  
 #include "RNBO_CompilerMacros.h"
 #include "RNBO_Std.h"
  
 namespace RNBO {
  
     // let RNBO use 32 bit float instead of double
     // defining this here seems not to be ideal, we might want to have this is RNBO_LocalConfig.h or something similar
     // #define RNBO_USE_FLOAT32
  
 #ifdef RNBO_USE_FLOAT32
     using number = float;
     using SampleValue = float;
 #else
  
     using number = double;
  
     using SampleValue = double;
 #endif // RNBO_USE_FLOAT32
  
     using signal = SampleValue *;
  
     // avoid denom test for genexpr statements - speeds up computation
 #define RNBO_NO_DENORM_TEST
  
     using generic = number;
  
     using ParameterValue = number;
  
     using Sample = SampleValue;     // an alias of SampleValue, perhaps we can get rid of this?
  
     template <size_t L>
     using SampleArray = Sample*[L];
  
     template <size_t L>
     using ConstSampleArray = const Sample*[L];
  
     using MillisecondTime = double;
  
     // for now we need MillisecondTime to be 64 bit to avoid losing precision in long running patches
     static_assert(sizeof(MillisecondTime) * 8 == 64, "MillisecondTime has to be 64 bit");
  
     using Tempo = number;
  
     using BeatTime = number;
  
     enum TransportState
     {
         STOPPED,
         RUNNING
     };
  
     using Int = intptr_t;
  
 #if defined(RNBO_USE_FLOAT32) || defined(RNBO_NO_INT64)
     using UInt = uint32_t;
     using Index = UInt;
     const Index INVALID_INDEX = UINT32_MAX;
 #else
     using UInt = uint64_t;
     using Index = UInt;
     const Index INVALID_INDEX = UINT64_MAX;
 #endif
  
     using UInt32 = uint32_t;
     using UInt64 = uint64_t;
  
     using ParameterIndex = Index;
  
     using MessageIndex = Index;
  
     using OutletIndex = Index;
  
     using SignalIndex = Index;
  
     using SampleIndex = Int;
  
     using SampleOffset = Int;
  
     using ClockId = Int;
  
     using ParameterInterfaceId = const void*;
  
     using DataRefIndex = Int;
  
     using ProbingIndex = Int;
  
     using ConstCharPointer = const char *;
  
     using ConstByteArray = const uint8_t *;
  
     //.*BinOpInt have to be 32 bit for javascript calculation parity
     using BinOpInt = int32_t;
  
     using UBinOpInt = uint32_t;
  
     static const MillisecondTime RNBOTimeNow = 0;
     static const MillisecondTime TimeNow = 0;
  
     enum ParameterType
     {
         ParameterTypeNumber = 0,  
         ParameterTypeBang,        
         ParameterTypeList,        
         ParameterTypeSignal,      
         ParameterTypeCount
     };
  
     enum IOType
     {
         IOTypeInput,      
         IOTypeOutput,     
         IOTypeUndefined   
     };
  
     struct ParameterInfo
     {
         ParameterType type;
         IOType ioType = IOTypeUndefined;
         ParameterValue min = 0.;
         ParameterValue max = 1.;
         ParameterValue initialValue = 0.;
         ParameterValue exponent = 1.;
         int steps = 0; // 0 = continuous, 1 = toggle, 2+ indicates steps in the normalized representation
         bool debug = false;
         bool saveable = false;
         bool transmittable = false;
         bool initialized = false;
         bool visible = false;
         const char **enumValues = nullptr;
         const char *displayName = "";
         const char *unit = "";
         SignalIndex signalIndex = INVALID_INDEX;
     };
  
     enum LogLevel
     {
         Info,
         Warning,
         Error
     };
  
     template<typename T> T* addressOf(T& object) { return &object; }
  
     using MessageTag = uint32_t;
  
     // a simple SDBM Hash function http://www.partow.net/programming/hashfunctions/#SDBMHashFunction
     constexpr MessageTag TAG(const char* str, MessageTag hash = 0) {
         return (!(*str))
         ? hash
         : TAG(str + 1, static_cast<MessageTag>(*str) + (hash << 6) + (hash << 16) - hash);
     }
  
     constexpr MessageTag ID(const char* str) { return TAG(str); }
  
     static_assert(TAG("test") == 1195757874, "");   // testing if the const expr can actually be evaluted at compile time
     static_assert(TAG("") == 0, "");
     static_assert(ID("test") == 1195757874, "");
     static_assert(ID("") == 0, "");
  
     using MessageTagInfo = const char*;
  
     enum MessagePortType
     {
         Inport,      
         Outport,     
         Undefined    
     };
  
     struct MessageInfo
     {
         MessageTagInfo  tag;
         MessagePortType type;
     };
  
     static const MessageInfo NullMessageInfo = { "", MessagePortType::Undefined };
  
     enum class RuntimeError {
         OutOfRange,
         QueueOverflow
     };
  
  
 struct EXTERNALENGINE {
     EXTERNALENGINE(void*) {}
 };
  
 // member funs macro as recommended by isocpp.org FAQ
 #define CALL_MEMBER_FN(ptrToObject,ptrToMember)  ((*ptrToObject).*(ptrToMember))
  
 // quoting magic from http://stackoverflow.com/questions/6671698/adding-quotes-to-argument-in-c-preprocessor
 #define RNBO_Q(x) #x
 #define RNBO_QUOTE(x) RNBO_Q(x)
  
 } // namespace RNBO
  
 #endif // #ifndef _RNBO_TYPES_H_
C++ Guides

RNBO: common/RNBO_Types.h Source File
