definitions.h

Go to the documentation of this file.

/*
 * Nominal Device Support v3 (NDS3)
 *
 * Copyright (c) 2015 Cosylab d.d.
 *
 * For more information about the license please refer to the license.txt
 * file included in the distribution.
 */

#ifndef NDS3_DEFINITIONS_H
#define NDS3_DEFINITIONS_H


#include <cstdint>
#include <functional>
#include <time.h>
#include <string>
#include <list>
#include <vector>
#include <map>

namespace nds
{

enum class state_t
{
    unknown,      
    off,          
    switchingOff, 
    initializing, 
    on,           
    stopping,     
    starting,     
    running,      
    fault,        
    MAX_STATE_NUM 
};

enum class dataType_t
{
    /* The value zero is reserved to static asserts to verify that the correct cpp types are being used */
    dataInt32 = 1,    
    dataFloat64,      
    dataInt8Array,    
    dataUint8Array,   
    dataInt32Array,   
    dataFloat64Array, 
    dataString        
};

enum class scanType_t
{
    periodic, 
    passive,  
    interrupt 
};


enum class logLevel_t: std::uint8_t
{
    debug,   
    info,    
    warning, 
    error,   
    none     
};

enum class dataDirection_t
{
    input, 
    output 
};

enum class nodeType_t
{
    generic,           
    inputChannel,      
    outputChannel,     
    dataSourceChannel, 
    dataSinkChannel,   
    stateMachine       
};

enum class inputPvType_t
{
    generic,        
    getLocalState,  
    getGlobalState  
};

enum class outputPvType_t
{
    generic,       
    setLocalState  
};

#define ndsLogStream(node, logLevel) \
    if(!(node).isLogLevelEnabled(logLevel)) {} else (node).getLogger(logLevel)

#define ndsDebugStream(node) ndsLogStream(node, nds::logLevel_t::debug)

#define ndsInfoStream(node) ndsLogStream(node, nds::logLevel_t::info)

#define ndsWarningStream(node) ndsLogStream(node, nds::logLevel_t::warning)

#define ndsErrorStream(node) ndsLogStream(node, nds::logLevel_t::error)

typedef std::vector<std::string> parameters_t;

typedef std::function<parameters_t (const parameters_t& parameters)> command_t;

typedef std::map<std::string, std::string> namedParameters_t;

class Factory;

typedef std::function<void*(Factory& factory, const std::string& deviceName, const namedParameters_t& parameters)> allocateDriver_t;

typedef std::function<void (void*)> deallocateDriver_t;


typedef std::function<void ()> stateChange_t;


typedef std::function<bool (const state_t, const state_t, const state_t)> allowChange_t;

typedef std::function<timespec ()> getTimestampPlugin_t;

typedef std::function<void ()> threadFunction_t;


typedef std::list<std::string> enumerationStrings_t;


} // namespace nds

#define NDS_DEFINE_DRIVER(driverName, className)\
extern "C" \
{ \
void* allocateDevice(nds::Factory& factory, const std::string& device, const nds::namedParameters_t& parameters) \
{ \
    return new className(factory, device, parameters); \
} \
void deallocateDevice(void* device) \
{ \
    delete (className*)device; \
} \
const char* getDeviceName() \
{ \
    return #driverName; \
} \
nds::RegisterDevice<className> registerDevice##driverName(#driverName); \
} // extern "C"

// Generic helper definitions for shared library support
#if defined _WIN32 || defined __CYGWIN__
  #define NDS3_HELPER_DLL_IMPORT __declspec(dllimport)
  #define NDS3_HELPER_DLL_EXPORT __declspec(dllexport)
#else
  #if __GNUC__ >= 4
    #define NDS3_HELPER_DLL_IMPORT __attribute__ ((visibility ("default")))
    #define NDS3_HELPER_DLL_EXPORT __attribute__ ((visibility ("default")))
  #else
    #define NDS3_HELPER_DLL_IMPORT
    #define NDS3_HELPER_DLL_EXPORT
  #endif
#endif


// NDS3_API is used for the public API symbols

#ifdef NDS3_DLL // defined if NDS3 is compiled as a DLL
  #ifdef NDS3_DLL_EXPORTS // defined if we are building the NDS3 DLL (instead of using it)
    #define NDS3_API NDS3_HELPER_DLL_EXPORT
  #else
    #define NDS3_API NDS3_HELPER_DLL_IMPORT
  #endif // NDS3_DLL_EXPORTS
#else // NDS3_DLL is not defined: this means NDS3 is a static lib.
  #define NDS3_API
#endif // NDS3_DLL

#endif // NDS3_DEFINITIONS_H