AbstractNode.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2016, Institut fuer Technische Optik (ITO),
    Universitaet Stuttgart, Germany

    This file is part of itom and its software development toolkit (SDK).

    itom is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public Licence as published by
    the Free Software Foundation; either version 2 of the Licence, or (at
    your option) any later version.
   
    In addition, as a special exception, the Institut fuer Technische
    Optik (ITO) gives you certain additional rights.
    These rights are described in the ITO LGPL Exception version 1.0,
    which can be found in the file LGPL_EXCEPTION.txt in this package.

    itom 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 Library
    General Public Licence for more details.

    You should have received a copy of the GNU Library General Public License
    along with itom. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************** */

#ifndef AbstractNode_H
#define AbstractNode_H

#include "plotCommon.h"
#include "../common/sharedStructures.h"

#include <qlist.h>
#include <qobject.h>
#include <qhash.h>

namespace ito {

class Channel; // forward declaration
class AbstractNode;

//----------------------------------------------------------------------------------------------------------------------------------
ITOMCOMMONPLOT_EXPORT uint calculateChannelHash(AbstractNode *parent, ito::Param *parentParam, AbstractNode *child, ito::Param *childParam);

//----------------------------------------------------------------------------------------------------------------------------------
typedef enum 
{
    rttiUnknown             = 0x0000, //default node type
    rttiPlotNode            = 0x1000, //arbitray nodes in a tree of graphic nodes
    rttiFilterNode          = 0x2000,
    rttiPlotNodeDObj        = 0x0100,
    rttiPlotNodePCL         = 0x0200,
    rttiPlotNode1D          = 0x0001,
    rttiPlotNode2D          = 0x0002,
    rttiPlotNode25D         = 0x0003,
    rttiPlotNode3D          = 0x0004
} rttiNodeType;


//----------------------------------------------------------------------------------------------------------------------------------
class ITOMCOMMONPLOT_EXPORT Channel
{    
    public: 
       enum ChanDirection {
            undefined,
            parentToChild,
            childToParent
        };
    private:
        static unsigned int UID; 
        unsigned int m_uniqueID; 
        AbstractNode* m_pParent; 
        AbstractNode* m_pChild; 
        ChanDirection m_direction; 
        ito::Param* m_pParentParam; 
        ito::Param* m_pChildParam; 
        bool m_deleteParentOnDisconnect, m_deleteChildOnDisconnect; 
        bool m_updatePending; 
        bool m_channelBuffering; 
        uint m_hashVal;

    public:
        Channel() : m_uniqueID(UID++), m_pParent(NULL), m_pChild(NULL), m_direction(Channel::undefined), m_pParentParam(NULL), m_pChildParam(NULL), m_deleteParentOnDisconnect(false), m_deleteChildOnDisconnect(false), m_updatePending(false), m_channelBuffering(false), m_hashVal(0) {}

        Channel(AbstractNode *parent, ito::Param *parentParam, bool deleteOnParentDisconnect, AbstractNode *child, ito::Param *childParam, bool deleteOnChildDiconnect, ChanDirection direction, bool update = false);
        
        ~Channel() {}
       
        inline AbstractNode* getParent() const { return m_pParent; }
        
        inline AbstractNode* getChild() const { return m_pChild; }
        
        inline ChanDirection getDirection() const { return m_direction; }
        
        inline bool getUpdatePending() const { return m_updatePending; }
        
        inline unsigned int getUniqueID() const { return m_uniqueID; }

        inline ito::Param* getOwnParam(AbstractNode* self) const
        {
            if(self == m_pParent)
                return m_pParentParam;
            else if(self == m_pChild)
                return m_pChildParam;
            else 
                return NULL;
        }

        inline ito::Param* getPartnerParam(AbstractNode* self) const
        {
            if(self == m_pParent)
                return m_pChildParam;
            else if(self == m_pChild)
                return m_pParentParam;
            else 
                return NULL;
        }

        inline QString getSenderParamName() const
        {
            if (m_direction == Channel::childToParent)
                return QString(m_pChildParam->getName());
            else if (m_direction == Channel::parentToChild)
                return QString(m_pParentParam->getName());
            else
                return QString();
        }

        inline signed char getDeleteBehaviour(AbstractNode* query) const 
        { 
            if(query == m_pParent)
                return m_deleteParentOnDisconnect;
            else if(query == m_pChild)
                return m_deleteChildOnDisconnect;
            else 
                return -1;
        }

        RetVal propagateUpdatePending();

        inline bool getChannelBuffering() const { return m_channelBuffering; }

        inline void setChannelBuffering(bool buffering) { m_channelBuffering = buffering; return; }

        inline uint getHash() const { return m_hashVal; }

        inline ito::Param * getParentParam() const { return m_pParentParam; }

        inline ito::Param * getChildParam() const { return m_pChildParam; }

        inline void resetUpdatePending(void){ m_updatePending = false;}

        inline bool isSender(AbstractNode *query) 
        { 
            if (((m_direction == Channel::childToParent) && (m_pChild == query)) 
                || ((m_direction == Channel::parentToChild) && (m_pParent == query)))
                return true;
            else
                return false;
        }

        inline bool isReceiver(AbstractNode *query) const
        { 
            if (((m_direction == Channel::childToParent) && (m_pParent == query)) 
                || ((m_direction == Channel::parentToChild) && (m_pChild == query)))
                return true;
            else
                return false;
        }

        inline AbstractNode* getSender(void) const
        {
            if(m_direction ==  Channel::childToParent)
                return m_pChild;
            else if (m_direction ==  Channel::parentToChild)
                return m_pParent;
            else return NULL;
        }

        inline AbstractNode* getReceiver(void) const
        {
            if(m_direction ==  Channel::childToParent)
                return m_pParent;
            else if (m_direction ==  Channel::parentToChild)
                return m_pChild;
            else return NULL;
        }
};

//----------------------------------------------------------------------------------------------------------------------------------
class ITOMCOMMONPLOT_EXPORT AbstractNode
{
    public:
        AbstractNode();

        virtual ~AbstractNode(); //>! will delete the node and all data associated with it, except m_pCurrentData if m_isCurrent is set to TRUE

        virtual RetVal applyUpdate(void) = 0; 
        virtual RetVal update(void) = 0; 
        RetVal updateParam(const ito::ParamBase *input, int isSource = 0); 
        RetVal updateParam(const QHash<QString, ito::ParamBase*> *inputs) 
        {
            ito::RetVal retval = ito::retOk;

            foreach (const ito::ParamBase *thisParam, *inputs)
            {
                retval += updateParam(thisParam);
                if (retval.containsError())
                    return retval;
            }
            return retval;
        }

        inline rttiNodeType getType() const { return m_NodeType; }

        virtual RetVal addChannel(AbstractNode *child, ito::Param* parentParam, ito::Param* childParam, Channel::ChanDirection direction, bool deleteOnParentDisconnect, bool deleteOnChildDisconnect) = 0;
        virtual RetVal addChannel(Channel *newChannel) = 0;

        virtual RetVal removeChannelFromList(unsigned int UniqueID) = 0;
        virtual RetVal removeChannel(Channel *delChannel) = 0;

        RetVal getUpdateStatus(void) const;
        
        RetVal updateChannels(const QList<QString> &paramNames);    

        inline bool isConnected() const { return !(m_pChannels.isEmpty()); }

        inline int getUniqueID(void) const { return m_uniqueID; }

        RetVal setUpdatePending(int uniqueID = -1);

        Channel * getInputChannel(const char *inpParamName) const;

        inline ito::Param* getInputParam(const QString &paramName) const
        { 
            if (m_pInput.contains(paramName))
            {
                return m_pInput[paramName];
            }
            return NULL;
        }

        inline ito::Param* getOutputParam(const QString &paramName) const
        { 
            if (m_pOutput.contains(paramName))
            {
                return m_pOutput[paramName];
            }
            return NULL;
        }

    protected:
        rttiNodeType m_NodeType;            
        QHash<QString, ito::Param*> m_pInput;        
        QHash<QString, ito::Param*> m_pOutput;       
        QHash<unsigned int, Channel*> m_pChannels;  

        int m_uniqueID;
        static unsigned int UID;
};

//----------------------------------------------------------------------------------------------------------------------------------
} // namespace ito

#endif