Inc.hpp

#include <cstdlib>
#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include "windows.h"

using namespace std;

typedef unsigned short uint;

class value
{
    private:
        double Value;
        bool   YesNo;

    public:
        //value(){Value = 0.0; YesNo = false;}
        value(){YesNo = false;}  //2009.11.3 임대식 수정 - 효률개선을 위해
        ~value(){}
        //void clear(){Value = 0.0; YesNo = false;}
        void clear(){YesNo = false;}  //2009.11.3 임대식 수정 - 효률개선을 위해
        value& operator=(double num){Value = num; YesNo = true; return *this;}
        double Return(){return Value;}
        bool   Existence(){return YesNo;}
};

class column
{
    private:
        value* Value;
        unsigned short period;

    public:
        column(){Value = 0; period = 0;}
        column(unsigned short t){Value = new value [t+1]; period = t;}
        ~column(){if (Value!=0) delete [] Value;}
        void Init(unsigned short t)
        {
            if (Value==0)
            {
                Value = new value [t+1];
                period = t;
            }
            else if (period==t)
            {
                for (int i=0; i<=period; i++)
                    Value[i].clear();
            }
            else
            {
                delete [] Value;
                Value = new value [t+1];
                period = t;
            }
        }
        value&  operator< (unsigned short t){return Value[t];            }
        double  operator()(unsigned short t){return Value[t].Return();   }
        bool    operator* (unsigned short t)
                          {//if (t>period) {SysLog << "column error!!! : " << t <<"/"<< period << endl; t=period;} //디버그용 로직, 실제 실행파일 생서시는 속도를 위해 제거 요망 !!!
                           return Value[t].Existence();}
};

class table
{
    private:
        value** Value;
        unsigned short row;
        unsigned short column;

    public:
        table(){Value = 0; row = 0; column = 0;}
        table(unsigned short r, unsigned short c)
        {
            this->open(r, c);
        }
        ~table()
        {
            this->close();
        }
       
        void Init(unsigned short r, unsigned short c)
        {
            if (Value==0)
            {
                this->open(r, c);
            }
            else if (r==row && c==column && (r+c)>0)
            {
                for (int i=0; i<=column; i++)
                {
                    for (int j=0; j<=row; j++)
                    {
                        Value[i][j].clear();
                    }
                }
            }
            else
            {
                this->close();
                this->open(r, c);
            }
        }
        void open(unsigned short r, unsigned short c)
        {
            this->row    = r;
            this->column = c;
           
            Value = new value* [c+1];
           
            for (int i=0; i<=c; i++)
            {
                Value[i] = new value [r+1];
            }
        }
        void close()
        {
            if (row==0 && column==0) return;
           
            for (int i=0; i<=column; i++)
            {
                if (Value[i]!=0) delete [] Value[i];
                Value[i] = 0;
            }
   
            if (Value!=0) delete [] Value;

            Value  = 0;
            row    = 0;
            column = 0;
        }
        double operator()(unsigned short r, unsigned short c) {return Value[c-1][r].Return();   }
        value& addr      (unsigned short r, unsigned short c) {return Value[c-1][r];            }
        bool   be        (unsigned short r, unsigned short c)
                         {//if (r>row || c>column)  //디버그용 로직, 실제 실행파일 생서시는 속도를 위해 제거 요망 !!!
                          //   {SysLog << "table error!!! : " << r <<"/"<< row << " : " << c << "/" << column << endl; r=row; c=column;}
                             return Value[c-1][r].Existence();   }
};

class FieldInfoSet
{
    private:
        char**   FieldName;       //필드명
        bool*    OrgWriteYN;      //원본 출력파일에 해당필드 출력 여부
        bool*    GrpWriteYN;      //Summary 출력파일에 해당필드 출력 여부
        bool*    CalcYN;          //필드끼리 연산을 통해 생성된 필드인지 여부
       
        long     FieldNumTot;     //총 필드 갯수(연산 필드 포함)
        long     FieldNumOrg;     //원본 출력파일의 총 필드 갯수, 원본 파일은 연산 필드를 포함하지 않고, 전체 필드를 모두 저장
        long     FieldNumGrp;     //Summary 출력파일의  총 필드 갯수, Summary 파일은 연산 필드를 포함하되 출력대상 필드만 저장
        long     FieldNumCur;     //현재 읽은 파일의 총 필드 갯수
        long     FieldNumMax;     //처리가능 필드 최대 허용 갯수

        long*    MappingOrg;      //원본 출력파일의 출력필드 순서 매핑, 핊드정보에서 3번째 필드가 출력파일의 첫번째 필드일 경우, OrgMapping[1-1] = 3-1
        long*    MappingGrp;      //Summary 출력파일의 출력필드 순서 매핑, 핊드정보에서 3번째 필드가 출력파일의 첫번째 필드일 경우, GrpMapping[1-1] = 3-1
        long*    MappingCur;      //현재 읽은 파일의 필드의 정해진 필드순번으로 매핑, 현재 파일의 첫번째 필드가 필드정보에서 3번째 필드일경우, CurMapping[1-1] = 3-1

        ifstream OUTLABEL;        //필드목록 파일

        char     GrpType[30];

    public:
        FieldInfoSet();
        ~FieldInfoSet();
       
        void     Init(char*, char* );     //클래스 초기화 함수, 처리필드목록을 읽고, 필드 정보 추출
        void     CurFile(char*);          //현재 읽은 파일의 필드정보 정리 - 헤더 부분중 필드명 레코드를 입력값을로 받아 필드정보 추출
        void     HardCoding();            //필드정보 수작업 입력
       
        char*    cFieldName(long i) { return FieldName[i];  }
        long     iMappingOrg(long i){ return MappingOrg[i]; }
        long     iMappingGrp(long i){ return MappingGrp[i]; }
        long     iMappingCur(long i){ return MappingCur[i]; }

        long     iFieldNumTot(){ return FieldNumTot; }
        long     iFieldNumOrg(){ return FieldNumOrg; }
        long     iFieldNumGrp(){ return FieldNumGrp; }
        long     iFieldNumCur(){ return FieldNumCur; }
        long     iFieldNumMax(){ return FieldNumMax; }
       
        bool     bCalcYN(long i){ return CalcYN[i];  }
};

class ModelEV
{
    private:
  //시스템변수
        unsigned short ProjPeriod;
        double**       Result_Org_val;
        long           FieldNumOrg;
        char           M_CODE[20];
        char           ALFAKEY2[20];
       
        long index_ACQ1_EXP,index_ACQ13_EXP,index_ACQ14_EXP,index_ACQ2_EXP;
        long index_ACQ3_EXP,index_ACQ4_EXP,index_ACQ5_EXP,index_ACQ8_EXP;
        long index_ADJ_MATH_RES,index_ALPHA_LOAD_IF,index_ALPHA_LOAD_IF_EXP,index_ANUITY_OUTGO;
        long index_BETA_LOAD_IF,index_CASH_PREM,index_COLL1_EXP,index_COLL13_EXP;
        long index_COLL14_EXP,index_COLL3_EXP,index_COLL8_EXP,index_COMM1_EXP,index_COMM124_EXP;
        long index_COMM2_EXP,index_COMM31_EXP,index_COMM32_EXP,index_COMM33_EXP,index_COMM34_EXP;
        long index_COMM4_EXP,index_COMM5_EXP,index_COMM6_EXP,index_COMM71_EXP,index_COMM72_EXP;
        long index_CRED_INT,index_DAC_ASSD,index_DAC_DIFF,index_DAC_UNAMORT,index_DEATH_OUTGO;
        long index_DEATH_RISK_PREM,index_DIAG_OUTGO,index_DIAG_RISK_PREM,index_DISBL_OUTGO;
        long index_DISBL_RISK_PREM,index_FMF_INC,index_FMF_OUT,index_GAMMA_LOAD_IF,index_GMAB_INC_IF;
        long index_GMAB_OUT_IF,index_GMAB_RES,index_GMAB_RES_IF,index_GMDB_INC_IF,index_GMDB_INC2_IF;
        long index_GMDB_INCTI_IF,index_GMDB_OUT_IF,index_GMDB_OUTTI_IF,index_GMDB_RES,index_GMDB_RES_IF;
        long index_GMDB_RESTI,index_GMDB_RESTI_IF,index_GMDB_RISK_IF,index_GMSB_INCTI_IF;
        long index_GMSB_OUTTI_IF,index_GMSB_RESTI,index_GMSB_RESTI_IF,index_GMSB_RISK_IF;
        long index_HOSP_OUTGO,index_HOSP_RISK_PREM,index_INFORCE_PREM,index_INFORCEPOL;
        long index_INFORCEPOL_TK,index_LIVING_OUTGO,index_MAINT1_EXP,index_MAINT13_EXP;
        long index_MAINT14_EXP,index_MAINT15_EXP,index_MAINT16_EXP,index_MAINT3_EXP;
        long index_MAINT4_EXP,index_MAINT5_EXP,index_MAINT8_EXP,index_MAINT9_EXP;
        long index_MAT_OUTGO,index_NO_NEW_POLS,index_NONU_INT,index_O_TAXBL_INC,index_OTH_OUTGO;
        long index_OTH_RISK_PREM,index_OTH_RISK_PREM_RBC,index_OTHER_EXP,index_OTHER1_EXP;
        long index_PART_SURR_OUTGO,index_PREM_1ST_M,index_PREM_1ST_S,index_PREM_INC;
        long index_PREM_INC_DISC,index_PREM_UL_BAL,index_PREM_UL_SUB,index_PREM1YR;
        long index_PRIOR_ADJ_MATH_RES,index_PRIOR_DAC_ASSD,index_PRIOR_DAC_UNAMORT;
        long index_PRIOR_GMAB_RES_IF,index_PRIOR_GMDB_RES_IF,index_PRIOR_GMDB_RESTI_IF;
        long index_PRIOR_GMSB_RESTI_IF,index_PRIOR_PREM_UL_BAL,index_PRIOR_RES_P,index_PRIOR_RES_W;
        long index_RBC_ASSET,index_RBC_ASSET_PRIOR,index_RBC_RISK_A,index_RBC_RISK_A_DEATH;
        long index_RBC_RISK_A_DIAGSURG,index_RBC_RISK_A_DISBL,index_RBC_RISK_A_HOSP;
        long index_RBC_RISK_A_OTH,index_RBC_RISK_A_PR_DEATH,index_RBC_RISK_A_PR_DIAGSURG;
        long index_RBC_RISK_A_PR_DISBL,index_RBC_RISK_A_PR_HOSP,index_RBC_RISK_A_PR_OTH;
        long index_RBC_RISK_A_PR_SILSON,index_RBC_RISK_A_SILSON,index_RBC_RISK_B,index_RBC_RISK_C;
        long index_RBC_RISK_D_ASSET,index_RBC_RISK_D_LIAB,index_RBC_RISK_D_LIAB_PRIOR;
        long index_RBC_RISK_D_MIN,index_RBC_RISK_D_MIN_PRIOR,index_RBC_RISK_D_RASSET,index_RBC_RISK_D_REV;
        long index_RBC_RISK_D_RLIAB,index_RBC_RISK_D_RLIAB_PRIOR,index_RBC_RISK_D_RLIAB_TEMP;
        long index_RBC_RISK_E_GEN,index_RBC_RISK_E_GMAB,index_RBC_RISK_E_GMAB_MIN,index_RBC_RISK_E_GMDB;
        long index_RBC_RISK_E_GMDB_MIN,index_RES_P,index_RES_W,index_RISK_PREM_SB_IF,index_SA_ANNUITY;
        long index_SAVING_PREM_SB_IF,index_SEP_CV_LOAD,index_SEP_LIVING_OUTGO,index_SEP_NET_LOAD;
        long index_SEP_PART_SURR_OUTGO,index_SEP_PREM_1ST_M,index_SEP_PREM_1ST_S,index_SEP_PREM_INFORCE;
        long index_SEP_PREM_UL_BAL,index_SEP_PREM_UL_SUB,index_SEP_PRIOR_PREM_UL_BAL,index_SEP_PRIOR_RES_P;
        long index_SEP_PRIOR_RES_W,index_SEP_PU_BETA_LOAD,index_SEP_PW_DIFF,index_SEP_RES_DTH;
        long index_SEP_RES_P,index_SEP_RES_W,index_SEP_RISK_PREM,index_SEP_SAVE_PREM,index_SEP_SURR_OUTGO;
        long index_SILSON_OUTGO,index_SILSON_RISK_PREM_RBC,index_STD_RES_DTH,index_SUDANG;
        long index_SUM_ASSD_IF,index_SURG_OUTGO,index_SURG_RISK_PREM,index_SURR_OUTGO,index_TOT_ALPHA_EXP;
        long index_TOT_BEN_OUTGO,index_TOT_BETA_EXP,index_TOT_GAMMA_EXP,index_WAIVER_PREM_IF;

       
        //사용자 정의 항목 - 개체 (값과 계산로직)
        //컬럼
        column vGEN_PREM; double fGEN_PREM(unsigned short);
        column vRISK_PREM_SB_IF; double fRISK_PREM_SB_IF(unsigned short);
        //테이블
        table  vRESULT_ORG; double fRESULT_ORG(unsigned short, unsigned short);

    public:
        ModelEV();
        ~ModelEV();
        void Init(long, FieldInfoSet*);
        void StartUp(double** result, FieldInfoSet* fieldinfo, char* mcode, char* alfakey2);
      

        //사용자 정의 항목 - 인터페이스용 함수
        //컬럼
        double GEN_PREM(unsigned short t){if (vGEN_PREM*t==false) vGEN_PREM<t = fGEN_PREM(t); return vGEN_PREM(t);}
        double RISK_PREM_SB_IF(unsigned short t){if (vRISK_PREM_SB_IF*t==false) vRISK_PREM_SB_IF<t = fRISK_PREM_SB_IF(t); return vRISK_PREM_SB_IF(t);}
        //테이블
        double RESULT_ORG(unsigned short r,unsigned short c){if (vRESULT_ORG.be(r,c)==false) vRESULT_ORG.addr(r,c)=fRESULT_ORG(r,c);return vRESULT_ORG(r,c);}
        //함수
        double RESULT(unsigned short r,unsigned short c);

};

class ResultUnit
{
    private:
        long   Period;
        short  FieldNum;

    public:
        ~ResultUnit  ();
        void Init    (long period, long fieldnum, short keynum, char**);
        void Save    (double** result);
        bool GroupCmp(char** key);

        short    KeyNum;
        char**   Key;
        double** value;
};

class GrpKeyTable
{
    private:
        ifstream KeyList;      //그룹핑키 목록 파일
        short    KeyListNum;
        char**   Product;
        long*    Spcode;
        char***  Key;
        char**   KeyError;
       
    public:
        short    KeyFieldNum;
        char**   KeyLabel;

        void     Init(char*);
        char**   KeySearch(char*, long);
        char*    KeySearch(char*, long, char*);

        ~GrpKeyTable();
};

class Group
{
    private:

        char path_label[500];
        char path_ofile[500];
        char path_ofile_grp[500];
        char path_ofile_sub[500];

        ifstream OUTLABEL;      //필드목록 파일
        ofstream OutputFile;    //출력 파일
        ofstream OutputFileGrp; //출력 파일(그룹핑 파일)

        long     FieldTotNum;   //총 필드 갯수 (LABEL에 적힌 필드와 연산필드를 합한 갯수  
        long     FieldORGNum;   //출력대상 총 필드 갯수(LABEL에 적힌 필드갯수)
        long     FieldMaxNum;   //허용가능 총 필드 갯수
        long     FieldGrpNum;   //Summary 출력대상 필드 갯수
       
        long     MT_MaxPeriod;
        short    MT_CurrentArray; 
        char     MT_Result_prod[3][20];
        long     MT_Result_spcode[3];
        long     MT_Result_period[3];
        double** MT_Result_val[3];
        long     MT_GrpNum;
        long     MT_GrpKeyIndex[10000];
        char     MT_path[500];
        char     MT_product[20];
        long     MT_spcode;
        long     MT_period;
        double** Result_Grp_val;
        char     GrpType[30];

        vector<ResultUnit*> RUnit;

        GrpKeyTable  GrpKey;
        FieldInfoSet FieldInfo;
        ModelEV      MDEV;
       
    public:
        Group(){return;}  
        ~Group();

        void  Init(char*, char*, char*, long, char*);   //클래스 초기화 함수, 처리필드목록을 읽고, 출력파일,로그파일 open
        void  MT_Read    (short currentarray);
        void  MT_WriteOrg(short currentarray);
        void  MT_CalcGrp (short currentarray, char* mcode, char* alfakey2);
        void  MT_SaveGrp (short currentarray);
        void  MT_WriteGrp();
        void  MT_WriteGrp(short keyindex);
        void  MT_Setting (char* path, char* product, long spcode);
 
        short CurrentArray(){ return MT_CurrentArray; }
        char* path()        { return MT_path;         }
        char* product()     { return MT_product;      }
        long  spcode()      { return MT_spcode;       }

        long  FileNum;       //현재처리중인 파일의 순번
        long  MergeNum;      //실제로 누적을 실행한 파일 갯수(결과파일 missing건 제외)

        void  Arraysetting(short ca){ MT_CurrentArray = ca; return; }
};

void MT_Main(bool eof, char* path, char* product, char* spcode);  

extern Group    group;        //전역변수
extern ofstream gLogFile;     //전역변수