ExcelControl.h

説明を見る。

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

#include <rtm/Manager.h>
#include <rtm/DataFlowComponentBase.h>
#include <rtm/CorbaPort.h>
#include <rtm/DataInPort.h>
#include <rtm/DataOutPort.h>
#include <rtm/idl/BasicDataTypeSkel.h>
#include <rtm/idl/ExtendedDataTypesSkel.h>
#include <rtm/idl/InterfaceDataTypesSkel.h>

#include <vector>
#include <string>
#include <sstream>

#include <rtm/CorbaNaming.h>
#include <rtm/RTObject.h>
#include <rtm/CorbaConsumer.h>

#include "SubFunction.h"
#ifdef CREATE_EXE_EXCELRTC
        #include "Form1.h"
#else
        #include "ExcelObject.h"
#endif


using namespace RTC;

#include "SpreadSheetSVC_impl.h"
#include "ExcelTask.h"
#include "ExcelDataPort.h"


class ExcelTask;
class ExcelControl;
class ExcelPortBase;
class OtherPort;





void ListRecursive(CosNaming::NamingContext_ptr context,std::vector<OtherPort> &rtclist,std::string &name, TreeObject *to);

int rtc_get_rtclist(RTC::CorbaNaming &naming,std::vector<OtherPort> &rtclist, TreeObject *to, std::string IP_adress);










void portConnect(PortService_ptr p1, PortService_var p2);



class ExcelControl
  : public RTC::DataFlowComponentBase
{
 public:
  
  ExcelControl(RTC::Manager* manager);

  ~ExcelControl();

   
   virtual RTC::ReturnCode_t onInitialize();

   
   virtual RTC::ReturnCode_t onExecute(RTC::UniqueId ec_id);
   
   
   virtual RTC::ReturnCode_t onDeactivated(RTC::UniqueId ec_id);

   virtual RTC::ReturnCode_t onFinalize();

   
   ExcelPortBase* createPort(OtherPort &op, int c, std::string l, std::string sn, std::string leng, bool mstate);
   
   void deleteOtherPort(OtherPort &op);
   void deleteAllPort();
   
   void save();
   
   void load();
   
   void resetPort(ExcelPortBase* mpb);
   
   void resetAllPort();
   
   void configUpdate();

   void update_cellName();


  
   void updateAPort(ExcelPortBase* ip);

   
    template <typename T>
   void setCellData(std::vector<std::vector<T>> dt, ExcelPortBase *pb)
        {
                
                ExcelObject::Obj->setCellValue<T>(pb->col+pb->num, pb->low, pb->sheetName, pb->state, dt);
                
        }
   
    template <typename T>
        std::vector<T> getCellData(ExcelPortBase *pb)
        {
                std::vector<T> td = ExcelObject::Obj->getCellValue<T>(pb->col+pb->num, pb->low, pb->sheetName, pb->length);
                
                return td;
        }
        
        template <typename T, typename T2> ExcelPortBase* crPortSeq(OtherPort &op, std::string tdt, int c, std::string l, std::string sn, std::string leng, bool mstate)
   {
                string PortType = NVUtil::toString(op.pb->get_port_profile()->properties,"port.port_type");
                
           string tname = op.buff[op.buff.size()-2];
                tname += op.buff[op.buff.size()-1];
          
                if(PortType == "DataInPort")
                {
                        T *m_out = new T();
                        OutPort<T> *m_outOut = new OutPort<T>(tname.c_str(),*m_out);
                        addOutPort(tname.c_str(), *m_outOut);
                        
                        ExcelPortBase *mip;
                        
                        mip= new ExcelOutPortSeq<T,T2>(m_out,m_outOut,tname,tdt,this);
                        mip->mop = &op;
                        
                        mip->setParam(c,l,sn,leng,mstate);
                        OutPorts.push_back(mip);
                        
                        portConnect(m_outOut->getPortRef(), op.pb);

                        op.mpb = mip;

                        return mip;
                
                }
                else if(PortType == "DataOutPort")
                {
                        T *m_in = new T();
                        InPort<T> *m_inIn = new InPort<T>(tname.c_str(),*m_in);

                        addInPort(tname.c_str(), *m_inIn);

                        ExcelPortBase *mip = new ExcelInPortSeq<T,T2>(m_in,m_inIn,tname,tdt,this);
                        mip->mop = &op;
                        

                        mip->setParam(c,l,sn,leng,mstate);
                        InPorts.push_back(mip);
                        
                        portConnect(m_inIn->getPortRef(), op.pb);

                        op.mpb = mip;

                        return mip;
                }
                return NULL;
        }
        
   template <typename T, typename T2> ExcelPortBase* crPort(OtherPort &op, std::string tdt, int c, std::string l, std::string sn, std::string leng, bool mstate)
   {
           string PortType = NVUtil::toString(op.pb->get_port_profile()->properties,"port.port_type");
                
           string tname = op.buff[op.buff.size()-2];
                tname += op.buff[op.buff.size()-1];
          
                if(PortType == "DataInPort")
                {
                        T *m_out = new T();
                        OutPort<T> *m_outOut = new OutPort<T>(tname.c_str(),*m_out);
                        addOutPort(tname.c_str(), *m_outOut);
                        
                        ExcelPortBase *mip;
                        
                        mip= new ExcelOutPort<T,T2>(m_out,m_outOut,tname,tdt,this);
                        mip->mop = &op;
                        
                        mip->setParam(c,l,sn,leng,mstate);
                        OutPorts.push_back(mip);
                        
                        portConnect(m_outOut->getPortRef(), op.pb);

                        op.mpb = mip;

                        return mip;
                
                }
                else if(PortType == "DataOutPort")
                {
                        T *m_in = new T();
                        InPort<T> *m_inIn = new InPort<T>(tname.c_str(),*m_in);
                        

                        addInPort(tname.c_str(), *m_inIn);

                        ExcelPortBase *mip = new ExcelInPort<T,T2>(m_in,m_inIn,tname,tdt,this);
                        mip->mop = &op;
                        

                        mip->setParam(c,l,sn,leng,mstate);
                        InPorts.push_back(mip);
                        
                        portConnect(m_inIn->getPortRef(), op.pb);

                        op.mpb = mip;

                        return mip;
                }
                return NULL;
   }
   
   template <typename T, typename T2> ExcelPortBase* confcrPortSeq(std::string tname, std::string PortType, std::string tdt, int c, std::string l, std::string sn, std::string leng, bool mstate)
   {
                
          
                if(PortType == "DataOutPort")
                {
                        T *m_out = new T();
                        OutPort<T> *m_outOut = new OutPort<T>(tname.c_str(),*m_out);
                        addOutPort(tname.c_str(), *m_outOut);
                        
                        ExcelPortBase *mip;
                        
                        mip= new ExcelOutPortSeq<T,T2>(m_out,m_outOut,tname,tdt,this);
                        
                        mip->setParam(c,l,sn,leng,mstate);
                        ConfOutPorts.push_back(mip);
                        

                        

                        return mip;
                
                }
                else if(PortType == "DataInPort")
                {
                        T *m_in = new T();
                        InPort<T> *m_inIn = new InPort<T>(tname.c_str(),*m_in);

                        addInPort(tname.c_str(), *m_inIn);

                        ExcelPortBase *mip = new ExcelInPortSeq<T,T2>(m_in,m_inIn,tname,tdt,this);
                        
                        

                        mip->setParam(c,l,sn,leng,mstate);
                        ConfInPorts.push_back(mip);
                        

                        

                        return mip;
                }
                return NULL;
        }
        
   template <typename T, typename T2> ExcelPortBase* confcrPort(std::string tname, std::string PortType, std::string tdt, int c, std::string l, std::string sn, std::string leng, bool mstate)
   {
          
          
                if(PortType == "DataOutPort")
                {
                        T *m_out = new T();
                        OutPort<T> *m_outOut = new OutPort<T>(tname.c_str(),*m_out);
                        addOutPort(tname.c_str(), *m_outOut);
                        
                        ExcelPortBase *mip;
                        
                        mip= new ExcelOutPort<T,T2>(m_out,m_outOut,tname,tdt,this);
                        
                        mip->setParam(c,l,sn,leng,mstate);
                        ConfOutPorts.push_back(mip);
                        

                        

                        return mip;
                
                }
                else if(PortType == "DataInPort")
                {
                        T *m_in = new T();
                        InPort<T> *m_inIn = new InPort<T>(tname.c_str(),*m_in);
                        

                        addInPort(tname.c_str(), *m_inIn);

                        ExcelPortBase *mip = new ExcelInPort<T,T2>(m_in,m_inIn,tname,tdt,this);
                        
                        

                        mip->setParam(c,l,sn,leng,mstate);
                        ConfInPorts.push_back(mip);
                        

                        

                        return mip;
                }
                return NULL;
   }


   

   
   
   
   ExcelPortBase* setDPort(std::vector<std::string> pt, int c, std::string l, std::string sn, std::string leng, bool mstate, bool msflag);
   
   void delDPort(std::vector<std::string> pt);
   
   ExcelPortBase* getDPort(std::vector<std::string> pt);
   
   
   void attachPort(ExcelPortBase *mpb, std::string n);
   
   void detachPort(ExcelPortBase *mpb, std::string n);
   
   ExcelPortBase *getInPort(std::string n);
   
   ExcelPortBase *getOutPort(std::string n);
   
   ExcelPortBase *getConfOutPort(std::string n);
   ExcelPortBase *getConfInPort(std::string n);

   
   TreeObject* getRTCTree(std::string IP_adress);

   void setFilePath(std::string FP);

   std::vector<ExcelPortBase*> InPorts; 
   std::vector<ExcelPortBase*> OutPorts;        
   std::vector<ExcelPortBase*> ConfInPorts;     
   std::vector<ExcelPortBase*> ConfOutPorts;    
   RTC::Manager* m_manager;     
   std::vector<OtherPort> rtclist;      
   RTC::CorbaPort m_SpreadSheetPort;    
   mSpreadSheetSVC_impl m_spreadsheet;  
 protected:
        std::string file_path;  
        std::string conf_data_type;     
        std::string conf_port_type;     
        int conf_column;        
        std::string conf_start_row;     
        std::string conf_end_row;       
        std::string conf_sheetname;     
        int c_move;
        std::string attach_Port;

        
        

        int actionLock; 
        int red;        
        int green;      
        int blue;       
        coil::Mutex _mutex; 
        ExcelTask *et;


 private:


};

class ExcelConfigUpdateParam
    : public RTC::ConfigurationSetListener
{
public:
    ExcelConfigUpdateParam(ExcelControl *e_rtc)
    {
                m_rtc = e_rtc;
    }
    void operator()(const coil::Properties& config_set)
        {
                
                m_rtc->configUpdate();
                
    }
        ExcelControl *m_rtc; 
};

template <class T>
void getProperty(coil::Properties& prop, const char* key, T& value)
{
if (prop.findNode(key) != 0)
  {
    T tmp;
    if (coil::stringTo(tmp, prop[key].c_str()))
      {
        value = tmp;
      }
  }
}


extern "C"
{
  DLL_EXPORT void ExcelControlInit(RTC::Manager* manager);
};

#endif