RawValue.h

// -*- c++ -*-

#ifndef __RAW_VALUE_H__
#define __RAW_VALUE_H__

#include <stdio.h>
#include <cstring>
#include <string>

// epics
#include <db_access.h>

// tools
#include "tools/NoCopy.h"
#include "tools/MemoryBuffer.h"

// storage
#include "storage/StorageTypes.h"


typedef unsigned short DbrType;

typedef unsigned short DbrCount;

enum RawValueSpecialSeverities
{
    ARCH_BASE_MASK          = 0x0007, // Mask for bits used by EPICS base
    ARCH_EST_REPEAT         = 0x0f80,
    ARCH_DISCONNECT         = 0x0f40,
    ARCH_STOPPED            = 0x0f20,
    ARCH_REPEAT             = 0x0f10,
    ARCH_DISABLED           = 0x0f08
};


class RawValue
{
public:
    typedef dbr_time_double Data;

    static Data * allocate(DbrType type, DbrCount count, size_t num);

    static void free(Data *value);

    static size_t getSize(DbrType type, DbrCount count);

    static bool equal(DbrType type, DbrCount count,
                      const Data *lhs, const Data *rhs)
    {   return memcmp(lhs, rhs, getSize(type, count)) == 0;    }

    static bool hasSameValue(DbrType type, DbrCount count,
                             size_t size, const Data *lhs, const Data *rhs);

    static bool hasSameValue(DbrType type, DbrCount count,
                             const Data *lhs, const Data *rhs);

    static void copy(DbrType type, DbrCount count, Data *lhs, const Data *rhs)
    {   memcpy(lhs, rhs, getSize(type, count));    }

    static short getStat(const Data *value)
    {   return value->status; }
 
    static short getSevr(const Data *value)
    {   return value->severity; }
 
    static void getStatus(const Data* value, std::string& status);

    static bool isInfo(const Data* value)
    {
        short s = value->severity;
        return s==ARCH_DISCONNECT || s==ARCH_STOPPED || s==ARCH_DISABLED;
    }


    static bool isAboveZero(DbrType type, const Data* value);
    
    static void setStatus(Data *value, short status, short severity)
    {
        value->status = status;
        value->severity = severity;
    }

    static bool parseStatus(const std::string& text, short& stat, short& sevr);

    static const epicsTime getTime(const Data* value)
    {   return epicsTime(value->stamp);  }

    static void getTime(const Data* value, std::string& time);

    static void setTime(Data* value, const epicsTime& stamp)
    {   value->stamp = (epicsTimeStamp)stamp; }


    static bool getDouble(DbrType type, DbrCount count,
                          const Data* value, double& d, int i=0);


    static bool getLong(DbrType type, DbrCount count,
                        const Data *value, long &l, int i=0);


    static bool setDouble(DbrType type, DbrCount count,
                          Data *value, double d);

    enum NumberFormat
    {
        DEFAULT,     
        DECIMAL,     
        ENGINEERING, 
        EXPONENTIAL  
    };

    static size_t formatDouble(double number, NumberFormat format, int prec,
                               char *buffer, size_t max_len);
    
    static void getValueString(std::string& text,
                               DbrType type, DbrCount count, const Data* value,
                               const class CtrlInfo *info=0,
                               NumberFormat format = DECIMAL,
                               int prec = -1);

    static void toString(std::string& text, DbrType type, DbrCount count,
                         const Data *value, const class CtrlInfo *info=0);


    static void show(FILE *file,
                     DbrType type, DbrCount count, const Data *value,
                     const class CtrlInfo *info=0);

};


class RawValueAutoPtr
{
public:
    RawValueAutoPtr() : ptr(0) {};

    RawValueAutoPtr(RawValue::Data *in) : ptr(in) {};

    RawValueAutoPtr(RawValueAutoPtr &rhs)
    {
        ptr = rhs.release();
    }

    ~RawValueAutoPtr()
    {
        assign(0);
    }

    RawValueAutoPtr & operator = (RawValueAutoPtr &rhs)
    {
        assign(rhs.release());
        return *this;
    }

    RawValueAutoPtr & operator = (RawValue::Data *p)
    {
        assign(p);
        return *this;
    }
    
    operator bool () const
    {
        return ptr != 0;
    }
    
    RawValue::Data &operator *() const
    {
        return *ptr;
    }

    RawValue::Data *operator ->() const
    {
        return ptr;
    }

    operator RawValue::Data * () const
    {
        return ptr;
    }

    void assign(RawValue::Data *new_ptr)
    {
        if (ptr)
            RawValue::free(ptr);
        ptr = new_ptr;
    }

    RawValue::Data * release()
    {
        RawValue::Data *tmp = ptr;
        ptr = 0;
        return tmp;
    }
    
private:
    PROHIBIT_DEFAULT_COPY(RawValueAutoPtr);
    RawValue::Data *ptr;
};


#endif