NetShrVarInterface.h

Go to the documentation of this file.

/*************************************************************************\ 
* Copyright (c) 2013 Science and Technology Facilities Council (STFC), GB. 
* All rights reverved. 
* This file is distributed subject to a Software License Agreement found 
* in the file LICENSE.txt that is included with this distribution. 
\*************************************************************************/ 


#ifndef NETSHRVAR_INTERFACE_H
#define NETSHRVAR_INTERFACE_H

#ifdef epicsExportSharedSymbols
#define NetShrVarSymbols
#undef epicsExportSharedSymbols
#include <shareLib.h>
#endif

#include <stdio.h>
#include <sys/timeb.h>

#include <string>
#include <vector>
#include <map>
#include <list>
#include <stdexcept>
#include <sstream>
#include <fstream>
#include <iostream>
#include <cstdint>

#if defined(_WIN32) && defined(_MSC_VER) && _MSC_VER < 1700 /* Pre VS2012 */
// boost atomic is not header only, volatile should be enough here
// as we will no longer care about 2010 soon 
#define NSV_EMULATE_ATOMIC
typedef volatile uint32_t my_atomic_uint32_t;
typedef volatile int64_t my_atomic_uint64_t;   // needs to be signed for later Interlocked operation
#else
#include <atomic>
typedef std::atomic<uint32_t> my_atomic_uint32_t;
typedef std::atomic<uint64_t> my_atomic_uint64_t;
#endif

#include <epicsMutex.h>
#include <epicsThread.h>
#include <epicsExit.h>
#include <macLib.h>
#include <asynDriver.h>

#include <cvirte.h>             
#include <userint.h>
#include <cvinetv.h>

#include "pugixml.hpp"

#ifdef NetShrVarSymbols
#undef NetShrVarSymbols
#define epicsExportSharedSymbols
#include <shareLib.h>
#endif

enum NetShrVarOptions { NVNothing = 0, NVSomething=1 };

struct NvItem;
class asynPortDriver;
struct CallbackData;


class epicsShareClass NetShrVarInterface
{
public:
        NetShrVarInterface(const char* configSection, const char *configFile, int options);
        size_t nParams();
        ~NetShrVarInterface() { }
        void updateValues();
        void createParams(asynPortDriver* driver);
        void report(FILE* fp, int details);
        void readValue(const char* param);
        void dataTransferredCallback (void * handle, int error, CallbackData* cb_data);
        void dataCallback (void * handle, CNVData data, CallbackData* cb_data);
        void statusCallback (void * handle, CNVConnectionStatus status, int error, CallbackData* cb_data);
        template<typename T> void setValue(const char* param, const T& value);
        template<typename T> void setArrayValue(const char* param, const T* value, size_t nElements);
        template<typename T> void readArrayValue(const char* paramName, T* value, size_t nElements, size_t* nIn);
        static bool varExists(const std::string& path);
        static bool pathExists(const std::string& path);
  
private:
        std::string m_configSection;  
        std::string m_configFile;   
        int m_options; 
//      epicsMutex m_lock;
        asynPortDriver* m_driver;
        typedef std::map<std::string,NvItem*> params_t;
        params_t m_params;
        pugi::xml_document m_xmlconfig;
    MAC_HANDLE* m_mac_env;
        int m_writer_wait_ms; 
        int m_b_writer_wait_ms; 
    
    my_atomic_uint32_t m_items_read;
    my_atomic_uint64_t m_bytes_read;
    struct timeb m_last_report;
    
    inline void updateBytesReadCount(unsigned nbytes)
    {
#ifdef NSV_EMULATE_ATOMIC
        InterlockedIncrement(&m_items_read);
        InterlockedExchangeAdd64(&m_bytes_read, nbytes);
#else
        ++m_items_read;
        m_bytes_read += nbytes;
#endif
    }
        
    template<typename T> void getAsynParamValue(int param, T& value);
    char* envExpand(const char *str);
        void getParams();
        void setValueCNV(const std::string& name, CNVData value);
        static void epicsExitFunc(void* arg);
        bool checkOption(NetShrVarOptions option) { return ( m_options & static_cast<int>(option) ) != 0; }
        void connectVars();
    bool convertTimeStamp(unsigned __int64 timestamp, epicsTimeStamp *epicsTS);
        template<typename T> void updateParamValue(int param_index, T val, epicsTimeStamp* epicsTS, bool do_asyn_param_callbacks);
        template<typename T> void updateParamArrayValue(int param_index, T* val, size_t nElements,
                                                            epicsTimeStamp* epicsTS, bool do_asyn_param_callbacks);
        void updateParamCNV (int param_index, CNVData data, epicsTimeStamp* epicsTS, bool do_asyn_param_callbacks);
        template<CNVDataType cnvType> void updateParamCNVImpl(int param_index, CNVData data, CNVDataType type, 
                                       unsigned int nDims, epicsTimeStamp* epicsTS, bool do_asyn_param_callbacks);
        template<typename T,typename U> void updateParamArrayValueImpl(int param_index, T* val, size_t nElements);
        void readVarInit(NvItem* item);
    void setParamStatus(int param_id, asynStatus status, epicsAlarmCondition alarmStat = epicsAlarmNone, epicsAlarmSeverity alarmSevr = epicsSevNone);
        void getParamStatus(int param_id, asynStatus& status, int& alarmStat, int& alarmSevr);
    void initAsynParamIds();
        void updateConnectedAlarmStatus(const std::string& paramName, int value, const std::string& alarmStr, epicsAlarmCondition stat, epicsAlarmSeverity sevr);
};

#endif /* NETSHRVAR_INTERFACE_H */