Ccd0ExpImp.h

Go to the documentation of this file.

//Siemens Product Lifecycle Management Software Inc.
//All Rights Reserved.
//==================================================
//Copyright 2012 Siemens Product Lifecycle Management Software Inc. All Rights Reserved.

#ifndef CCDM__CCD0EXPIMP_H
#define CCDM__CCD0EXPIMP_H

#include <map>
#include <string>
#include <vector>
#include <fstream>

#include <ccdm/libccdm_exports.h>
#include <unidefs.h>

typedef std::map< std::string, std::vector< std::string > > StringArrayMap;

typedef struct ValueAddress
{
    tag_t valueObjectTag;                       
    std::vector<std::string> computedValue;     
    std::string computedAddress;                
    tag_t parmMemoryRecordTag;                  
}ValueAddressS;

typedef struct MemoryLayoutExportData
{
    tag_t memoryLayoutTag;                      
    std::vector<ValueAddress> valueAddress;     
}MemoryLayoutExportDataS;

typedef struct ParmFlashGenerationExpData
{

    std::vector<MemoryLayoutExportData > memoryLayoutExportData;        
    StringArrayMap attributesMap;                                       
}ParmFlashGenerationExpDataS;

typedef struct ParmValueDetails
{
    tag_t parmDefinitionRevTag;             
    tag_t parmValTag;                       
    tag_t variantExpTag;                    
}ParmValueDetailsS;

typedef struct ParmValueSharingExpData
{
    std::vector<ParmValueDetails> parmValDetails;   
    StringArrayMap attributesMap;                   
}ParmValueSharingExpDataS;

typedef struct GroupParmDetails
{
    tag_t parmGroupTag;                         
    std::vector<tag_t> parmDefinitionRevTag;    
}GroupParmDetailsS;

typedef struct ParmDictionaySharingExpData
{
    std::vector<GroupParmDetails> groupParmDetails; 
    StringArrayMap attributesMap;                   
}ParmDictionaySharingExpDataS;

typedef struct ExportFileData
{
    std::string absFilePath;        
    std::vector<tag_t> objectTags;  
}ExportFileDataS;

typedef struct ErrorInfo
{
    int ifail;      
    int severity;   
    std::string s1; 
    std::string s2; 
    std::string s3; 
    std::string s4; 
    std::string s5; 
    std::string s6; 
    std::string s7; 
} ErrorInfoS;

typedef struct ObjectErrorInfo
{
    tag_t objectTag;                    
    std::vector<ErrorInfoS> errorInfo;  
}ObjectErrorInfoS;

typedef struct ExportFileOutput
{
    std::vector<ExportFileDataS> exportFileData;    
    std::vector<ObjectErrorInfoS> objErrorInfos;    
}ExportFileOutputS;

typedef struct Blocks
{
    std::string startAddressOffset;     
    std::string blockName;              
    Blocks *parentBlock;                
}BlocksS;

typedef struct Records
{
    std::string recAddressOffset;       
    std::string parameterName;          
    Blocks *parentBlock;                
}RecordsS;

typedef struct MemoryLayoutDetails
{
    std::string name;               
    std::string startAddress;       
    std::vector<BlocksS> blocks;    
    std::vector<RecordsS> records;  
}MemoryLayoutDetailsS;

typedef struct AlgebraicFormula
{
    std::string name;               
    int numberOfConstNames;         
    char** constNames;              
    int numberOfVariableNames;      
    char** variableNames;           
    std::string expresssion;        
    std::string invExpression;      
    std::string asteExpression;     
    std::string invAsteExpression;  
}AlgebraicFormulaS;

typedef struct FormulaConversion
{
    int numberOfFormulaConstValues;     
    char** formulaConvConstVals;        
    AlgebraicFormulaS algebraicFormula; 
}FormulaConversionS;

typedef struct ValueConversion
{
    std::string inputValue;     
}ValueConversionS;

typedef struct RangeConversion
{
    std::string minValue;   
    std::string maxValue;   
}RangeConversionS;

typedef struct RecordConversion
{
    std::string outputValue;            
    ValueConversionS *valueConversion;  
    RangeConversionS *rangeConversion;  
}RecordConversionS;

typedef struct RecordColConversion
{
    std::string defaultValue;                           
    std::vector<RecordConversionS> vecRecordConversion; 
    bool withInterpolation;     
}RecordColConversionS;

typedef struct ConversionRuleDetails
{
    std::string ruleName;                       
    std::string ruleDesc;                       
    FormulaConversionS *formulaConversion;      
    RecordColConversionS *recordColConversion;  
}ConversionRuleDetailsS;

typedef struct TableCellValueType {
    std::string     type;       
    std::string     strVal;     
    date_t          dateVal;    
    double          dblVal;     
    int             intVal;     
    bool            boolVal;    
}TableCellValueTypeS;

typedef struct TableCell {
    int row;                    
    int col;                    
    std::string desc;           
    TableCellValueTypeS value;  
}TableCellS;

typedef struct TableDef {
    int rows;                           
    int cols;                           
    std::vector<std::string> rowLabels; 
    std::vector<std::string> colLabels; 
}TableDefS;

typedef struct Table {
    TableDefS *tableDefInfo;
    std::vector<TableCellS> tableCells;
    //Table():tableDefInfo(), tableCells(){}
    //Table(TableDefS *tableDefInfo1, std::vector<TableCellS>& tableCells1):tableDefInfo(tableDefInfo1), tableCells(tableCells1){}
} TableS;

typedef struct BitDefinitionData {
    int byteNum;
    int bitNum;
    std::string name;

    std::string meaningOf0;     
    std::string meaningOf1;     
}BitDefinitionDataS;

typedef struct ParmDefinitionRevDetails
{
    std::string  parmDefRevComment;     
    std::string  parmDefControlEngr;    
    int parmDefSize;                    
    std::string  parmDefSizeUnits;      
    TableDefS tableDefinition;          
    bool parmDefIsSigned;               
    int parmDefResoNumerator;           
    int parmDefResoDenominator;         
    double parmDefTolerance;            
    double parmDefPrecision;            
    ConversionRuleDetailsS parmDefConversionRule;   
    TableS parmDefMinValues;                        
    TableS parmDefMaxValues;                        
    TableS parmDefInitialValues;                    
    TableS parmDefValidValues;                      
    std::vector<BitDefinitionDataS> vecBitDefInfo;  
}ParmDefinitionRevDetailsS;

typedef struct ParmGroupDetails
{
    std::string parmGrpName;        
    std::string parmGrpDescriptor;  
    std::string parmGrpComment;     
    std::string parmGrpRepresents;  
    std::string parmGrpControlEngr; 
    std::string parmGrpspecialistUser;  
    ParmGroupDetails *parentGroup;      
}ParmGroupDetailsS;

typedef struct ParmDefinitionDetails
{
    int findNumber;                             
    std::string  parmDefType;                   
    std::string  parmDefParmType;               
    std::string  parmDefComment;                
    std::string  parmDefName;                   
    ParmDefinitionRevDetailsS parmDefRevDetails;
    std::string  parmDefDescriptor;             
    ParmGroupDetailsS* parentGroup;             
}ParmDefinitionDetailsS;

typedef struct ParmDictionaryUpdateData
{
    tag_t selectedObject;                                   
    std::vector<MemoryLayoutDetailsS> vecMemLayoutDetails;  
    std::vector<ParmGroupDetailsS> vecParmGroupDetails;     
    std::vector<ParmDefinitionDetailsS> vecParmDefDetails;  
}ParmDictionaryUpdateDataS;

typedef struct DictionaryParseOutput
{
    ParmDictionaryUpdateData importData;            
    std::vector<ObjectErrorInfo> vecParseErrorData; 
}DictionaryParseOutputS;

#include <ccdm/libccdm_undef.h>
#endif // CCDM__CCD0EXPIMP_H