cvtdevicespec.h

이 파일의 문서화 페이지로 가기

#ifndef _CVT_DEVICESPEC_
#define _CVT_DEVICESPEC_

#include <iostream>
#include <string>

#include <glog/logging.h>

#include "cvtcode.h"

using namespace std;

namespace stdcvt {

typedef enum {
    _DS_TX = 0,
    _DS_TY = 1,
    _DS_TZ = 2,
    _DS_PX = 3,
    _DS_PY = 4,
    _DS_PZ = 5,
} _dsiv_t;

#define _DS_MAX 6

/*
 @brief CvtDeviceSpec is a virtual class for a smartfarm device.
*/
class CvtDeviceSpec {
private:
    string _manufacturer;   
    string _model;          
    devtype_t _type;        
    devsec_t _section;      
    devtarget_t _target;    

    class CvtDeviceSection {
    private:
        int _sv[_DS_MAX];     

    public:
        CvtDeviceSection(long section) {
            long tmp = section;
            for (int i = 0; i < _DS_MAX; i++) {
                _sv[i] = tmp % 100;
                tmp = tmp / 100;
            }
        }

        int getvalue(_dsiv_t index) {
            return _sv[index];
        }
    };

public:
    CvtDeviceSpec () {
        _type = DT_DEV_UNKNOWN;
        _section = DL_UNKNOWN;
        _target = DO_UNKNOWN;
        _manufacturer = "";
        _model = "";
    }

    CvtDeviceSpec(devtype_t devtype, devsec_t section, devtarget_t target) {
        _type = devtype;
        _section = section;
        _target = target;
        _manufacturer = "";
        _model = "";
    }

    ~CvtDeviceSpec() {
    }

    devgroup_t getgrouptype() {
        return (devgroup_t)(_type / 10000);
    }

    devtype_t gettype() {
        return _type;
    }

    devsec_t getsection() {
        return _section;
    }

    devtarget_t gettarget() {
        return _target;
    }

    string setmanufacturer(string manufacturer) {
        _manufacturer = manufacturer;
        return _manufacturer;
    }

    string getmanufacturer() {
        return _manufacturer;
    }

    string setmodel(string model) {
        _model = model;
        return _model;
    }

    string getmodel() {
        return _model;
    }

    bool copy(CvtDeviceSpec *pdevspec) {
        _type = pdevspec->_type;
        _section = pdevspec->_section;
        _target = pdevspec->_target;
        _manufacturer = pdevspec->_manufacturer;
        _model = pdevspec->_model;
        return true;
    }

    string tostring() {
        return "CvtDeviceSpec type : " + to_string(_type) 
            + ", target : " + to_string(_target) + ", section : " + to_string(_section)
            + ", manufacturer : " + _manufacturer + ", model : " + _model;
    }

    bool checktarget(CvtDeviceSpec *pdevspec) {
        if ((_target == DO_UNKNOWN) || 
            (pdevspec->_target == DO_UNKNOWN)) {
            return false;
        }
        if (_target == pdevspec->_target)
            return true;
        // 설치 위치가 있는 장비와 설치 위치가 없는 상태의 장비에 대해
        // 지능적 처리가 필요할 수 있지만 현재는 무시한다.
        return false;
    }

    bool checktype(CvtDeviceSpec *pdevspec) {
        if ((_type == DT_DEV_UNKNOWN) || (_type == DT_SEN_UNKNOWN) || 
            (_type == DT_MOT_UNKNOWN) || (_type == DT_SWC_UNKNOWN) || 
            (pdevspec->_type == DT_SEN_UNKNOWN) || 
            (pdevspec->_type == DT_MOT_UNKNOWN) || 
            (pdevspec->_type == DT_SWC_UNKNOWN) || 
            (pdevspec->_type == DT_DEV_UNKNOWN)) {
            return false;
        }
        if (_type == pdevspec->_type)
            return true;

        // 창이 다겹인경우 장비 타입에 대해서
        // 지능적 처리가 필요할 수 있지만 현재는 무시한다.
        return false;
    }

    bool checksection(CvtDeviceSpec *pdevspec) {
        if ((_section == DL_UNKNOWN) || 
            (pdevspec->_section == DL_UNKNOWN)) {
            return false;
        }
        if (_section == pdevspec->_section) {
            return true;
        }

        CvtDeviceSection in(_section);
        CvtDeviceSection ex(pdevspec->_section);

        if (in.getvalue (_DS_TX) == ex.getvalue (_DS_TX)) {
            if (in.getvalue (_DS_PX) != ex.getvalue (_DS_PX)) {
                return false;   // x축 방향으로 같은 개수인데 다른 위치
            }
        } else {
            // x축 방향으로 다른 개수. 서로 다른 구역구분을 가지고 있는 경우.
            // 지능적으로 처리할 수 있지만 여기서는 단순히 처리함.
            return false;
        }

        if (in.getvalue (_DS_TY) == ex.getvalue (_DS_TY)) {
            if (in.getvalue (_DS_PY) != ex.getvalue (_DS_PY)) {
                return false;   // Y축 방향으로 같은 개수인데 다른 위치
            }
        } else {
            // Y축 방향으로 다른 개수. 서로 다른 구역구분을 가지고 있는 경우.
            // 지능적으로 처리할 수 있지만 여기서는 단순히 처리함.
            return false;
        }

        if (in.getvalue (_DS_TZ) == ex.getvalue (_DS_TZ)) {
            if (in.getvalue (_DS_PZ) != ex.getvalue (_DS_PZ)) {
                return false;   // Z축 방향으로 같은 개수인데 다른 위치
            }
        } else {
            // Z축 방향으로 다른 개수. 서로 다른 구역구분을 가지고 있는 경우.
            // 지능적으로 처리할 수 있지만 여기서는 단순히 처리함.
            return false;
        }

        return true;
    }
        
    bool ismatched(CvtDeviceSpec *pdevspec) {
        if (!checksection (pdevspec))
            return false;

        if (!checktarget (pdevspec))
            return false;

        if (!checktype (pdevspec))
            return false;

        return true;
    }
};

}
#endif