Variable.h

Go to the documentation of this file.

/*****************************************************************************
 * vim:tw=78
 * $Id$
 *
 * Copyright (C) 2016       Richard Hacker (lerichi at gmx dot net)
 *
 * This file is part of the PdCom library.
 *
 * The PdCom library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * The PdCom library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with the PdCom library. If not, see <http://www.gnu.org/licenses/>.
 *
 *****************************************************************************/

#ifndef PDCOM_VARIABLE_H
#define PDCOM_VARIABLE_H

#include <string>
#include <vector>
#include <ostream>
#include <istream>
#include <stdint.h>

namespace PdCom {

class Process;

class Variable {
    public:

        enum Type {
            boolean_T = 0,
            uint8_T,  int8_T,
            uint16_T, int16_T,
            uint32_T, int32_T,
            uint64_T, int64_T,
            double_T, single_T
        };


        class Subscription {
            public:
                Subscription(Process* process,
                        int id,
                        const Variable* v,
                        int decimation,
                        const uint64_t* const* time,
                        const char* const* data);

                Process* const process; 
                const int id;   
                const Variable* const variable; 
                const int decimation;   
                const uint64_t* const* const time_ns;

                virtual void cancel() const = 0;

                bool poll() const;

                template <typename T>
                    void getValue(T* val, size_t index, size_t nelem) const;

                std::string getStringValue(char delimiter = ',') const;

                void print(std::ostream& os, char delimiter) const;

            protected:
                ~Subscription();

            private:

                const char* const * const data;
        };


        Variable( Type type,
                double sampleTime,
                size_t task,
                bool writeable,
                const std::string& alias,
                size_t ndim,
                const size_t *dims);

        virtual ~Variable();

        const Type type;          
        const char* const ctype;  
        const double sampleTime;  
        const size_t task;        
        const bool writeable;     
        const std::string alias;  
        virtual std::string name() const = 0;

        virtual std::string path() const = 0;

        const size_t nelem;     
        const std::vector<size_t> dim;  
        const size_t typeWidth; 
        const size_t bytes;     
        bool isScalar() const;

        size_t isVector() const;

        bool setStringValue(const std::string& value) const;


        template <typename T>
            bool setValue(const T* val,
                    size_t offset, size_t nelem) const;

        bool read(std::istream& is) const;

    protected:

        virtual bool poll(const Subscription*) const { return true; }

        virtual bool setValue(const void*, size_t /*UserTypeIdx*/,
                size_t /*index*/, size_t /*nelem*/) const {
            return true;
        }

        void copyValue(char* dst, const void* src,
                size_t UserTypeIdx, size_t n) const;

        void printValue(std::ostream& os, const char* buf, char delim) const;

    private:

        typedef void (Variable::*GetValueFunc_T)
            (void* dst, size_t nelem, const char* src, size_t offset) const;
        const GetValueFunc_T*  const getValueFunc;

        typedef void (Variable::*CopyValueFunc_T)
            (char* dst, const void* src, size_t nelem) const;
        const CopyValueFunc_T* const copyValueFunc;

        typedef void (Variable::*PrintValueFunc_T)
            (std::ostream& os, const char* data, char delim) const;
        const PrintValueFunc_T printValueFunc;

        template <class CType>
            void printFcn(
                    std::ostream& os, const char* buf, char delim) const;
        static const PrintValueFunc_T printValueFuncList[];

        template <class CType>
            bool readFcn(std::istream& is) const;
        typedef bool (Variable::*ReadValueFunc_T)
            (std::istream& is) const;
        const ReadValueFunc_T readValueFunc;
        static const ReadValueFunc_T readValueFuncList[];

        template <class CType, class UserType>
            void copyValue(char* dst, const void* src, size_t nelem) const;
        template <class CType, class UserType>
            void getValue(void* dst, size_t nelem,
                    const char* src, size_t offset) const;
        template <class CType>
            struct DataConverter {
                static const GetValueFunc_T getValueFunc[];
                static const CopyValueFunc_T copyValueFunc[];
            };
        static const GetValueFunc_T*  const getValueFuncList[];
        static const CopyValueFunc_T* const copyValueFuncList[];
};

}

std::ostream& operator<< (std::ostream& os,
        const PdCom::Variable::Subscription& subscription);

std::istream& operator>> (std::istream& is,
        const PdCom::Variable& variable);

#endif //PDCOM_VARIABLE_H