ExcelDataPort.h

説明を見る。

// -*-C++-*-
#ifndef EXCELDATAPORT_H
#define EXCELDATAPORT_H


#include "ExcelControl.h"

class ExcelPortBase;
class ExcelControl;


template <class T, class T2>
class DataListener
  : public ConnectorDataListenerT<T>
{
public:
        DataListener(ExcelPortBase *mp, std::vector<std::vector<T2>> &sv, ExcelControl *mrtc){
                m_port = mp;
                m_data = &sv;
                m_rtc = mrtc;
        }
  virtual ~DataListener()
  {
  
  }

  virtual void operator()(const ConnectorInfo& info,
                          const T& data)
  {

         

          std::vector<T2> tmp;
        
          
          tmp.push_back(data.data);
        
          m_port->_mutex.lock();
          m_data->push_back(tmp);
          m_port->_mutex.unlock();

          m_rtc->updateAPort(m_port);
       
  };
  ExcelPortBase *m_port;        
  std::vector<std::vector<T2>> *m_data; 
  ExcelControl *m_rtc; 
};


template <class T, class T2>
class SeqDataListener
  : public ConnectorDataListenerT<T>
{
public:
        SeqDataListener(ExcelPortBase *mp, std::vector<std::vector<T2>> &sv, ExcelControl *mrtc){
                m_port = mp;
                m_data = &sv;
                m_rtc = mrtc;
        }
  virtual ~SeqDataListener()
  {
  
  }

  virtual void operator()(const ConnectorInfo& info,
                          const T& data)
  {
        std::vector<T2> tmp;
        
        for(int i=0;i < data.data.length();i++)
        {
                tmp.push_back(data.data[i]);
        }
        
        m_port->_mutex.lock();
        m_data->push_back(tmp);
        m_port->_mutex.unlock();

        m_rtc->updateAPort(m_port);
  };
  ExcelPortBase *m_port; 
  std::vector<std::vector<T2>> *m_data; 
  ExcelControl *m_rtc; 
};



class OtherPort
{
        public:
                OtherPort(PortService_var p, std::vector<std::string> s)
                {
                        pb = p;
                        buff = s;
                        mpb = NULL;
                };
                PortService_var pb; 
                std::vector<std::string> buff; 
                ExcelPortBase *mpb; 
};



class ExcelPortBase
{
public:
        virtual ~ExcelPortBase()
        {
                delete pb;
        }

        
        virtual void setParam(int c, std::string l, std::string sn, std::string leng, bool mstate)
        {
                col = c;
                low = l;
                sheetName = sn;
                length = leng;
                num = 0;
                state = mstate;
                //update_cellName();
        }

        virtual bool isNew()
        {
                return false;
        }
        virtual void putData(bool moption)
        {

        }
        virtual void update_cellName()
        {
                
                ExcelObject::Obj->setCellStringSingle(col, low, sheetName, name);
        }


        std::string name; 
        int col; 
        std::string low; 
        std::string length; 
        int sheetnum; 
        std::string sheetName; 
        int num; 
        OtherPort *mop; 
        PortBase *pb; 
        std::string data_type; 
        std::vector<std::string> attachPort;  
        bool state; 
        ExcelControl *mexc; 
        coil::Mutex _mutex; 
        /*template <typename T>T GetOutPort()
        {
                return static_cast<ExcelOutPort<T>*>this;
        }

        template <typename T>T GetInPort()
        {
                return static_cast<ExcelInPort<T>*>this;
        }*/
};


template <class T, class T2>
class ExcelInPort : public ExcelPortBase
{
public:
        ExcelInPort(T *id, RTC::InPort<T> *ip, std::string n, std::string dt, ExcelControl *m_mexc){
                In = id;
                inIn = ip;
                name = n;
                data_type = dt;
                
                col = 1;
                low = 1;
                sheetnum = 1;
                

                
                pb = ip;

                
                mexc = m_mexc;

                
                inIn->addConnectorDataListener(ON_BUFFER_WRITE, new DataListener<T,T2>(this, buff, mexc));
                
        }
        ~ExcelInPort()
        {
                //delete inIn;
                //delete In;
        }
        
        virtual bool isNew()
        {
                return inIn->isNew();
        }

        
        
        virtual void putData(bool moption)
        {
                
                
                std::vector<std::vector<T2>> v;
                if(!moption)
                {
                        
                        if(inIn->isNew())
                        {
                                inIn->read();
                                //std::cout << ip->In->data << std::endl;
                                
                                
                                std::vector<T2> v2;
                                v2.push_back(In->data);
                                v.push_back(v2);

                                
                        }
                }
                else
                {

                        _mutex.lock();
                        v = buff;
                        buff.clear();
                        _mutex.unlock();
                }
                
                

                mexc->setCellData<T2>(v, this);

                if(state)
                        num += v.size();
                

                

                
        }

        T *In; 
        RTC::InPort<T> *inIn; 
        std::vector<std::vector<T2>> buff; 
};


template <class T, class T2>
class ExcelInPortSeq : public ExcelPortBase
{
public:
        ExcelInPortSeq(T *id, RTC::InPort<T> *ip, std::string n, std::string dt, ExcelControl *m_mexc){
                In = id;
                inIn = ip;
                name = n;
                data_type = dt;
                
                col = 1;
                low = 1;
                sheetnum = 1;
                

                
                pb = ip;

                
                mexc = m_mexc;

                
                inIn->addConnectorDataListener(ON_BUFFER_WRITE, new SeqDataListener<T,T2>(this, buff, mexc));


        }
        ~ExcelInPortSeq()
        {
                //delete inIn;
                //delete In;
        }
        
        virtual bool isNew()
        {
                return inIn->isNew();
        }

        
                

                
                
        
        virtual void putData(bool moption)
        {
                std::vector<std::vector<T2>> v;
                if(!moption)
                {
                        
                        if(inIn->isNew())
                        {
                                inIn->read();
                                
                                std::vector<T2> v2;
                                

                                for(int i=0;i < In->data.length();i++)
                                {
                                        v2.push_back(In->data[i]);
                                        
                                }
                                v.push_back(v2);

                        }
                }
                else
                {

                        _mutex.lock();
                        v = buff;
                        buff.clear();
                        _mutex.unlock();
                }

                mexc->setCellData<T2>(v, this);

                if(state)
                        num += v.size();

                
                                
                                

                        
                
        }

        T *In; 
        RTC::InPort<T> *inIn; 
        std::vector<std::vector<T2>> buff; 
};



template <class T, class T2>
class ExcelOutPort : public ExcelPortBase
{
public:
        ExcelOutPort(T *od, RTC::OutPort<T> *op, std::string n, std::string dt, ExcelControl *m_mexc){
                Out = od;
                outOut = op;
                name = n;
                data_type = dt;

                col = 1;
                low = 1;
                sheetnum = 1;
                

                
                pb = op;

                mexc = m_mexc;

                

                
        }
        ~ExcelOutPort()
        {
                //delete outOut;
                //delete Out;
        }
        
        virtual void putData(bool moption)
        {
                                
                std::vector<T2> v = mexc->getCellData<T2>(this);
                
                Out->data = v[0];
                if(state)
                        num += 1;
                
                
                outOut->write();
        }
        T *Out; 
        RTC::OutPort<T> *outOut; 
};


template <class T, class T2>
class ExcelOutPortSeq : public ExcelPortBase
{
public:
        ExcelOutPortSeq(T *od, RTC::OutPort<T> *op, std::string n, std::string dt, ExcelControl *m_mexc){
                Out = od;
                outOut = op;
                name = n;
                data_type = dt;

                col = 1;
                low = 1;
                sheetnum = 1;
                

                
                pb = op;

                mexc = m_mexc;

                

                
        }
        ~ExcelOutPortSeq()
        {
                //delete outOut;
                //delete Out;
        }


        
        virtual void putData(bool moption)
        {
                int t_l = convertStrToVal(low);
                int t_leng = convertStrToVal(length);

                int leng = t_leng-t_l+1;

                Out->data.length(leng);
                std::vector<T2> v = mexc->getCellData<T2>(this);
                if(leng != v.size())return;
                for(int i=0;i < leng;i++)
                {
                        Out->data[i] = v[i];
                }
                if(state)
                        num += 1;
                
                
                outOut->write();
        }
        T *Out; 
        RTC::OutPort<T> *outOut; 
};


#endif