4261 lines
136 KiB
C++
4261 lines
136 KiB
C++
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#ifdef WIN32
|
||
#include <Windows.h>
|
||
#endif // WIN32
|
||
#include "slf.h"
|
||
#include <QDir>
|
||
#include <QDateTime>
|
||
#include <QString>
|
||
#pragma execution_character_set("utf-8")
|
||
int RepSize[12]={4,
|
||
sizeof(int),
|
||
sizeof(short),
|
||
sizeof(long long),
|
||
sizeof(float),
|
||
sizeof(double),
|
||
sizeof(char),
|
||
sizeof(char),
|
||
sizeof(unsigned char),
|
||
sizeof(unsigned short),
|
||
sizeof(unsigned int),
|
||
sizeof(unsigned int)
|
||
};
|
||
|
||
const char *Rep_STR[]={
|
||
"INT","SHORT","LONG","FLOAT","DOUBLE","STRING","CHAR","UCHAR","USHORT","UINT","ULONG"
|
||
};
|
||
int Slf_Int(float depth,float stdep,float rlev)
|
||
{
|
||
float ddepnum=(depth-stdep)/rlev;
|
||
int First=0;
|
||
if(ddepnum>=0) First=(int)(ddepnum+0.5);
|
||
else First=(int)(ddepnum-0.5);
|
||
return First;
|
||
}
|
||
CString MemName(CString wellname,CString Curve)
|
||
{
|
||
CString cs=wellname+("_")+Curve;
|
||
return cs.GetString();
|
||
}
|
||
|
||
wchar_t* AnsiToUnicode(const char* szStr)
|
||
{
|
||
int nLen = MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, szStr, -1, NULL, 0 );
|
||
if (nLen == 0)
|
||
{
|
||
return NULL;
|
||
}
|
||
wchar_t* pResult = new wchar_t[nLen];
|
||
MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, szStr, -1, pResult, nLen );
|
||
return pResult;
|
||
}
|
||
int IsMappingMem(const char *MemName)
|
||
{
|
||
QString slf1=MemName;
|
||
slf1.replace("\\","/");
|
||
slf1.replace(".","_");
|
||
wchar_t *pname=AnsiToUnicode(slf1.toStdString().c_str());
|
||
HANDLE hMapFile = OpenFileMapping(FILE_MAP_READ,
|
||
false,
|
||
pname);
|
||
DWORD fInit =hMapFile>0?1:0;
|
||
// (GetLastError() == ERROR_ALREADY_EXISTS);
|
||
CloseHandle(hMapFile);
|
||
return fInit;
|
||
}
|
||
bool MappingMem(HANDLE *hHandle,LPSTR *hMem,int len,const char* name)
|
||
{
|
||
QString slf1=name;
|
||
slf1.replace("\\","/");
|
||
slf1.replace(".","_");
|
||
wchar_t *pname=AnsiToUnicode(slf1.toStdString().c_str());
|
||
HANDLE hMapFile = OpenFileMapping(FILE_MAP_READ|FILE_MAP_WRITE,
|
||
false,
|
||
pname);
|
||
if(!hMapFile)
|
||
{
|
||
*hHandle = CreateFileMapping((HANDLE)-1,
|
||
(LPSECURITY_ATTRIBUTES) NULL,
|
||
PAGE_READWRITE,
|
||
(DWORD)0,
|
||
(DWORD)len, // size: low 32-bits
|
||
pname); // name of map object
|
||
}
|
||
else *hHandle=hMapFile;
|
||
delete pname;
|
||
if (*hHandle == NULL) {
|
||
return FALSE;
|
||
}
|
||
*hMem = (LPSTR )MapViewOfFile(
|
||
*hHandle, // object to map view of
|
||
FILE_MAP_WRITE, // read/write access
|
||
0, // high offset: map from
|
||
0, // low offset: beginning
|
||
0); // default: map entire file
|
||
if (*hMem == NULL) return FALSE;
|
||
return TRUE;
|
||
}
|
||
|
||
void CloseView(HANDLE hMapObject,LPVOID lpvMem)
|
||
{
|
||
if(lpvMem)UnmapViewOfFile(lpvMem);
|
||
if(hMapObject)CloseHandle(hMapObject);
|
||
}
|
||
|
||
time_t StringToTime(char * szTime)
|
||
{
|
||
struct tm tm1;
|
||
memset(&tm1,0,sizeof(tm));
|
||
time_t time1;
|
||
sscanf(szTime, "%4d-%2d-%2d %2d:%2d:%2d",
|
||
&tm1.tm_year,
|
||
&tm1.tm_mon,
|
||
&tm1.tm_mday,
|
||
&tm1.tm_hour,
|
||
&tm1.tm_min,
|
||
&tm1.tm_sec);
|
||
tm1.tm_year -= 1900;
|
||
tm1.tm_mon --;
|
||
tm1.tm_isdst=-1;
|
||
time1 = mktime(&tm1);
|
||
return time1;
|
||
}
|
||
|
||
void CSlfIO::InitWis(int BlockLen,int MaxObjectNumber, int MachineType)
|
||
{
|
||
m_Head.BlockLen=BlockLen;
|
||
m_Head.MaxObjectNumber=MaxObjectNumber;
|
||
m_Head.MachineType=MachineType;
|
||
m_Head.ObjectNumber=0;
|
||
m_Head.EntryOffset=sizeof(Slf_HEAD)+10;
|
||
m_Head.DataOffset=(int)((m_Head.EntryOffset+sizeof(Slf_OBJECT_ENTRY)*m_Head.MaxObjectNumber)/(float)BlockLen+(float)0.5)*BlockLen;
|
||
m_Head.FileSize=m_Head.DataOffset;
|
||
time_t createTime;
|
||
gmtime(&createTime);
|
||
m_Head.TimeCreate=(unsigned int)createTime;
|
||
strcpy(m_Head.Reserved,"WIS 1.0");
|
||
WriteWisHead();
|
||
m_ObjectEntry=new Slf_OBJECT_ENTRY[m_Head.MaxObjectNumber];
|
||
Slf_Info_Head=new char *[m_Head.MaxObjectNumber];
|
||
for(int i=0;i<m_Head.MaxObjectNumber;i++) Slf_Info_Head[i]=NULL;
|
||
WriteWisObjectEntry();
|
||
}
|
||
int CSlfIO::ReadWisHead()
|
||
{
|
||
mFile->seek(10L);
|
||
return mFile->read(reinterpret_cast<char*>(&m_Head),sizeof(Slf_HEAD));
|
||
}
|
||
int CSlfIO::WriteWisHead()
|
||
{
|
||
mFile->seek(0);
|
||
char buf[100];
|
||
int len=mFile->read(buf,10);
|
||
if(len>=10) mFile->seek(10);
|
||
else mFile->write("WIS 1.0 ",10);
|
||
if(m_Head.MaxObjectNumber==0) {
|
||
AfxMessageBox("错误文件头！");
|
||
return 0;
|
||
}
|
||
mFile->write(reinterpret_cast<char*>(&m_Head),sizeof(Slf_HEAD));
|
||
mFile->flush();
|
||
return 1;
|
||
}
|
||
int CSlfIO::ReadWisObjectEntry()
|
||
{
|
||
mFile->seek(m_Head.EntryOffset);
|
||
int sz=sizeof(Slf_OBJECT_ENTRY);
|
||
return mFile->read(reinterpret_cast<char*>(m_ObjectEntry),sizeof(Slf_OBJECT_ENTRY)*m_Head.ObjectNumber);
|
||
}
|
||
bool CSlfIO::IsObject(int index)
|
||
{
|
||
if(index<0) return false;
|
||
int FieldNum=GetSlfTableFieldCount(index);
|
||
if(FieldNum<1)
|
||
{
|
||
return 0;
|
||
}
|
||
int rec=GetSlfTableRecordCount(index);
|
||
int reclen=GetSlfTableRecordLength(index);
|
||
Slf_TABLE_ENTRY obj;
|
||
GetSlfObjectEntry(index,&obj);
|
||
Slf_OBJECT_FIELD *pf=new Slf_OBJECT_FIELD[FieldNum];
|
||
memset(pf,0,sizeof(Slf_OBJECT_FIELD)*FieldNum);
|
||
GetSlfTableFieldInfo(index,pf);
|
||
int pos=0;
|
||
if(pf[0].Start>10000000) {
|
||
delete []pf;
|
||
return 0;
|
||
}
|
||
if(pf[0].Start<=-4.3160208e+008) {
|
||
delete []pf;
|
||
return 0;
|
||
}
|
||
if(pf[0].RepCode<0||pf[0].RepCode>REPR_ULONG){
|
||
delete []pf;
|
||
return 0;
|
||
}
|
||
if(pf[0].CodeLength<0){
|
||
delete []pf;
|
||
return 0;
|
||
}
|
||
if(FieldNum>1) {
|
||
if(pf[1].CodeLength<=0) {
|
||
delete []pf;
|
||
return 0;
|
||
}
|
||
if(pf[1].ArrayNum<0) {
|
||
delete []pf;
|
||
return 0;
|
||
}
|
||
if(pf[1].RepCode<0) {
|
||
delete []pf;
|
||
return 0;
|
||
}
|
||
}
|
||
delete []pf;
|
||
return true;
|
||
}
|
||
int CSlfIO::WriteWisObjectEntry()
|
||
{
|
||
mFile->seek(m_Head.EntryOffset);
|
||
for(int i=0;i<m_Head.ObjectNumber;i++)
|
||
{
|
||
strupr(m_ObjectEntry[i].Name);
|
||
}
|
||
mFile->write(reinterpret_cast<char*>(m_ObjectEntry),sizeof(Slf_OBJECT_ENTRY)*m_Head.ObjectNumber);
|
||
mFile->flush();
|
||
return 1;
|
||
}
|
||
int CSlfIO::WriteWisObjectEntry(int index,Slf_OBJECT_ENTRY *pEntry)
|
||
{
|
||
if(index<0) return 0;
|
||
mFile->seek(m_Head.EntryOffset+sizeof(Slf_OBJECT_ENTRY)*index);
|
||
if(pEntry) mFile->write(reinterpret_cast<char*>(pEntry),sizeof(Slf_OBJECT_ENTRY));
|
||
else mFile->write(reinterpret_cast<char*>(&m_ObjectEntry[index]),sizeof(Slf_OBJECT_ENTRY));
|
||
mFile->flush();
|
||
return 1;
|
||
}
|
||
bool CSlfIO::InitChannelValue(int index)
|
||
{
|
||
Slf_CHANNEL *m_Channel =(Slf_CHANNEL *)Slf_Info_Head[index];
|
||
if(index>-1&&index<m_Head.MaxObjectNumber) {
|
||
strcpy(m_Channel->AliasName,"none");
|
||
strcpy(m_Channel->AliasUnit,"none");
|
||
m_Channel->CodeLen=0;
|
||
m_Channel->NumOfDimension=1;
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
int CSlfIO::ReadWisChannelInfo(int index,Slf_CHANNEL *pInfo)
|
||
{
|
||
int i=0;
|
||
mFile->seek(m_ObjectEntry[index].Position);
|
||
if(pInfo) i=mFile->read(reinterpret_cast<char*>(pInfo),sizeof(Slf_CHANNEL));
|
||
else i=mFile->read(Slf_Info_Head[index],sizeof(Slf_CHANNEL));
|
||
return i;
|
||
}
|
||
int CSlfIO::WriteWisChannelInfo(int index,Slf_CHANNEL *pInfo)
|
||
{
|
||
mFile->seek(m_ObjectEntry[index].Position);
|
||
char *buf=new char[m_Head.BlockLen+1];
|
||
if(pInfo) {
|
||
memmove(buf,pInfo, sizeof(Slf_CHANNEL));
|
||
mFile->write(buf,m_Head.BlockLen);
|
||
if(Slf_Info_Head[index]) memmove(Slf_Info_Head[index],pInfo, sizeof(Slf_CHANNEL));
|
||
}
|
||
else
|
||
{
|
||
memmove(buf,Slf_Info_Head[index], sizeof(Slf_CHANNEL));
|
||
mFile->write(buf,m_Head.BlockLen);
|
||
}
|
||
mFile->flush();
|
||
delete []buf;
|
||
return 1;
|
||
}
|
||
int CSlfIO::ReadWisStreamInfo(int index)
|
||
{
|
||
mFile->seek(m_ObjectEntry[index].Position);
|
||
return mFile->read(Slf_Info_Head[index],sizeof(DWORD));
|
||
}
|
||
int CSlfIO::WriteWisStreamInfo(int index)
|
||
{
|
||
mFile->seek(m_ObjectEntry[index].Position);
|
||
mFile->write(Slf_Info_Head[index],sizeof(DWORD));
|
||
mFile->flush();
|
||
return 1;
|
||
}
|
||
bool CSlfIO::ExpandWisObject(int index, DWORD BlockNum)
|
||
{
|
||
// return 0;
|
||
DWORD point1,point,pos=m_ObjectEntry[index].Position+m_ObjectEntry[index].BlockNum*m_Head.BlockLen;
|
||
int j=0,len=WisFindFreeSpace(BlockNum,index);
|
||
if(len<=0) return FALSE;
|
||
char *buffer=new char [len+1];
|
||
point =m_Head.FileSize;
|
||
point1=m_Head.FileSize+m_Head.BlockLen*BlockNum;
|
||
while(point>=pos) {
|
||
if(point<len) break;
|
||
point-=len;
|
||
mFile->seek(point);
|
||
mFile->read(buffer,len);
|
||
if(point1<len) break;
|
||
point1-=len;
|
||
mFile->seek(point1);
|
||
mFile->write(buffer,len);
|
||
}
|
||
memset(buffer,0,len);
|
||
mFile->seek(pos);
|
||
mFile->write(buffer,len);
|
||
mFile->flush();
|
||
delete []buffer;
|
||
|
||
for(j=index+1;j<m_Head.ObjectNumber;j++) {
|
||
m_ObjectEntry[j].Position+=m_Head.BlockLen*BlockNum;
|
||
}
|
||
m_ObjectEntry[index].BlockNum+=BlockNum;
|
||
WriteWisObjectEntry();
|
||
m_Head.FileSize+=len;
|
||
WriteWisHead();
|
||
return TRUE;
|
||
}
|
||
int CSlfIO::WisFindFreeSpace(DWORD BlockNum,int nExceptIndex)
|
||
{
|
||
DWORD len=BlockNum*m_Head.BlockLen+m_Head.FileSize;
|
||
mFile->resize(len);
|
||
if(mFile->size()==len) return BlockNum*m_Head.BlockLen;
|
||
return 0;
|
||
}
|
||
CSlfIO::CSlfIO()
|
||
{
|
||
mHandle=NULL;
|
||
m_Value=NULL;
|
||
m_ObjectEntry=NULL;
|
||
m_SlfObjectEntry=NULL;
|
||
Slf_Info_Head=NULL;
|
||
mFile=NULL;
|
||
IsWis=0;
|
||
memset((char *)&m_SlfHead,0,sizeof(m_SlfHead));
|
||
memset((char *)&m_Head,0,sizeof(m_Head));
|
||
IsChange=false;
|
||
isShengLi=0;
|
||
}
|
||
CSlfIO::CSlfIO(const char* LogName,int FileType)
|
||
{
|
||
mHandle=NULL;
|
||
m_Value=NULL;
|
||
m_ObjectEntry=NULL;
|
||
m_SlfObjectEntry=NULL;
|
||
Slf_Info_Head=NULL;
|
||
mFile=NULL;
|
||
IsWis=FileType;
|
||
memset((char *)&m_SlfHead,0,sizeof(m_SlfHead));
|
||
memset((char *)&m_Head,0,sizeof(m_Head));
|
||
if(!Open(LogName,modeReadWrite,1024,1024,0,FileType))
|
||
{
|
||
AfxMessageBox("Open File Error !");
|
||
};
|
||
isShengLi=0;
|
||
}
|
||
CSlfIO::~CSlfIO()
|
||
{
|
||
Close();
|
||
}
|
||
QString ConvertDataByFloat(float fValue)
|
||
{
|
||
if(fValue<0)
|
||
return "";
|
||
if(abs(fValue)<0.000001)//等于0
|
||
{
|
||
return "";
|
||
}
|
||
if(abs(fValue-9999999)<0.000001)//等于9999999为0
|
||
{
|
||
return "0";
|
||
}
|
||
QString szTemp=QString::number(fValue,'f',6);
|
||
QString szBit(szTemp[0]);
|
||
int nBit =szBit.toInt();
|
||
//小于6
|
||
if(nBit<6)
|
||
{
|
||
szTemp = szTemp.mid(1,szTemp.size()-1);
|
||
szTemp = QString::number(szTemp.toFloat(),'f',nBit);
|
||
return szTemp;
|
||
}
|
||
else
|
||
{
|
||
szTemp = szTemp.mid(1,szTemp.size()-1);
|
||
szTemp = QString::number(szTemp.toFloat(),'f',0);
|
||
return szTemp;
|
||
}
|
||
}
|
||
float ConvertDataByString(QString szText)
|
||
{
|
||
//空
|
||
if(szText.isEmpty())
|
||
return -99999.f;
|
||
|
||
bool bOK;
|
||
float fTemp = szText.toFloat(&bOK);
|
||
//转换失败
|
||
if(!bOK)
|
||
return -99999.f;
|
||
//等于0
|
||
if(abs(fTemp)<0.000001)
|
||
{
|
||
return 9999999.f;
|
||
}
|
||
|
||
//小于0
|
||
if(fTemp<0)
|
||
return -99999.f;;
|
||
//有小数点
|
||
if(szText.contains("."))
|
||
{
|
||
auto rList =szText.split(".");
|
||
int nNum =rList[1].size();
|
||
//不超过6
|
||
if(nNum>6)
|
||
nNum =6;
|
||
if(nNum==0)//无小数点
|
||
szText.insert(0,QString::number(7));
|
||
else
|
||
szText.insert(0,QString::number(nNum));
|
||
}
|
||
//无小数点
|
||
else
|
||
szText.insert(0,QString::number(7));
|
||
return szText.toFloat();
|
||
}
|
||
|
||
bool CSlfIO::Open(const char* LogName,unsigned int nOpenFlags,int BlockLen,int MaxObjectNumber, int MachineType,int FileType)
|
||
{
|
||
CString cs=LogName;
|
||
strcpy(m_LogFileName,LogName);
|
||
if(nOpenFlags==modeCreate) {
|
||
return Open(nOpenFlags,BlockLen,MaxObjectNumber,MachineType,FileType);
|
||
}
|
||
else if(nOpenFlags==modeRead) {
|
||
QFileInfo w(m_LogFileName);
|
||
if(w.isFile()) {
|
||
}
|
||
else return false;
|
||
}
|
||
char buf[20];
|
||
DWORD r;
|
||
QString cs1=m_LogFileName;
|
||
int i=cs1.lastIndexOf("\\");
|
||
int j=cs1.lastIndexOf("/");
|
||
if(j>i) i=j;
|
||
cs1=cs1.left(i);
|
||
QDir dir;
|
||
if(!dir.exists(cs1)) dir.mkdir(cs1);
|
||
if(dir.exists(m_LogFileName)) {
|
||
QFile* aFile=new QFile(m_LogFileName);
|
||
aFile->open(QIODevice::ReadWrite);
|
||
if(aFile->read(&buf[0],8)==8) {//文件已存在
|
||
typedef struct tagSlf3_FILE_MESSAGE
|
||
{
|
||
//起始位置 变量名称 字节长度 描 述
|
||
char AreaName[64];// 64 油矿名称
|
||
char OilCompanyName[64];// 64 公司名称
|
||
char WellName[64];// 64 井名
|
||
char WellType[20];// 20 井类型：直井、斜井
|
||
float Xcoor;// 4 大地x坐标
|
||
float Ycoor;// 4 大地y坐标
|
||
float Altitude;// 4 海拔高度
|
||
float Kelly;// 4 补心高度
|
||
float StartDepth;// 4 起始深度
|
||
float EndDepth;// 4 终止深度
|
||
__time32_t StartDrillDate;// 4 开钻时间
|
||
__time32_t EndDrillDate;// 4 完钻时间
|
||
__time32_t LoggingDate;// 4 测井时间
|
||
|
||
char LogCompanyName[64];// 64 测井公司
|
||
char LoggingTeam[32];// 20 测井队
|
||
char Operator[32];// 20 操作员
|
||
char LoggingSerial[32];// 20 测井系列
|
||
float Well_Bottom_Temperature;//井底温度
|
||
|
||
float Mud_Density[10];
|
||
float Mud_Viscosity[10];
|
||
float Mud_Resistivity[10];
|
||
|
||
float Bit_Diameter[10];
|
||
float Bushing_Detpth[10];
|
||
float Bushing_Inside_Diameter[10];
|
||
float Bushing_Outside_Diameter[10];
|
||
float Bit_Depth[10];
|
||
char Mud_Property[32];//泥浆性能
|
||
char YqType[32];//仪器类型：skd3000、h2530、5700
|
||
char JB[32];//井别：开发、探井、采油井、注水井
|
||
float LoggingDepth;//测时井深
|
||
float azca;//闭合方位,磁偏角
|
||
float TVD;// 备注
|
||
float X0,Y0,Z0;// 起始测点位置坐标偏移量
|
||
float Mud_Temp;// 泥浆温度
|
||
char Intor[12];// 备注
|
||
char IntDepths[12];// 备注
|
||
char audit[32];
|
||
char Prog[32];
|
||
float WaterLoss;
|
||
char Item[32];
|
||
char Reserved[10];// 备注
|
||
}Slf3_FILE_MESSAGE;
|
||
typedef struct tagSlf_FILE_MESSAGE31
|
||
{
|
||
//起始位置 变量名称 字节长度 描 述
|
||
char AreaName[64];// 64 油矿名称
|
||
char OilCompanyName[64];// 64 公司名称
|
||
char WellName[64];// 64 井名
|
||
char WellAliasName[64];//绘图需要的井名
|
||
char WellType[20];// 20 井类型：直井、斜井
|
||
double Xcoor;// 4 大地x坐标
|
||
double Ycoor;// 4 大地y坐标
|
||
float Altitude;// 4 海拔高度
|
||
float Kelly;// 4 补心高度
|
||
float StartDepth;// 4 起始深度
|
||
float EndDepth;// 4 终止深度
|
||
__time32_t StartDrillDate;// 4 开钻时间
|
||
__time32_t EndDrillDate;// 4 完钻时间
|
||
__time32_t LoggingDate;// 4 测井时间
|
||
|
||
char LogCompanyName[64];// 64 测井公司
|
||
char LoggingTeam[32];// 20 测井队
|
||
char Operator[32];// 20 操作员
|
||
char LoggingSerial[32];// 20 测井系列
|
||
float Well_Bottom_Temperature;//井底温度
|
||
|
||
float Mud_Density[10];
|
||
float Mud_Viscosity[10];
|
||
float Mud_Resistivity[10];
|
||
float Bit_Diameter[10];
|
||
float Bushing_Detpth[10];
|
||
float Bushing_Inside_Diameter[10];
|
||
float Bushing_Outside_Diameter[10];
|
||
float Bit_Depth[10];
|
||
char Mud_Property[32];//泥浆性能
|
||
char YqType[32];//仪器类型：skd3000、h2530、5700
|
||
char JB[32];//井别：开发、探井、采油井、注水井
|
||
float LoggingDepth;//测时井深
|
||
float azca;//闭合方位,磁偏角
|
||
float TVD;// 备注
|
||
double X0,Y0;
|
||
float Z0;// 起始测点位置坐标偏移量
|
||
float Mud_Temp;// 泥浆温度
|
||
char Intor[12];// 备注
|
||
char IntDepths[12];// 备注
|
||
char audit[32];
|
||
char Prog[32];
|
||
float WaterLoss;
|
||
char Item[32];
|
||
char Reserved[10];// 备注
|
||
}Slf31_FILE_MESSAGE;
|
||
typedef struct tagSlf_FILE_MESSAGE32
|
||
{
|
||
//起始位置 变量名称 字节长度 描 述
|
||
char AreaName[64];// 64 油矿名称
|
||
char OilCompanyName[64];// 64 公司名称
|
||
char WellName[64];// 64 井名
|
||
char WellAliasName[64];//绘图需要的井名
|
||
char WellType[20];// 20 井类型：直井、斜井
|
||
double Xcoor;// 4 大地x坐标
|
||
double Ycoor;// 4 大地y坐标
|
||
float Altitude;// 4 海拔高度
|
||
float Kelly;// 4 补心高度
|
||
float StartDepth;// 4 起始深度
|
||
float EndDepth;// 4 终止深度
|
||
__time32_t StartDrillDate;// 4 开钻时间
|
||
__time32_t EndDrillDate;// 4 完钻时间
|
||
__time32_t LoggingDate;// 4 测井时间
|
||
|
||
char LogCompanyName[64];// 64 测井公司
|
||
char LoggingTeam[32];// 20 测井队
|
||
char Operator[32];// 20 操作员
|
||
char LoggingSerial[32];// 20 测井系列
|
||
float Well_Bottom_Temperature;//井底温度
|
||
|
||
float Mud_Density[10];
|
||
float Mud_Viscosity[10];
|
||
float Mud_Resistivity[10];
|
||
float Bit_Diameter[10];
|
||
float Bushing_Detpth[10];
|
||
float Bushing_Inside_Diameter[10];
|
||
float Bushing_Outside_Diameter[10];
|
||
float Bit_Depth[10];
|
||
char Mud_Property[32];//泥浆性能
|
||
char YqType[32];//仪器类型：skd3000、h2530、5700
|
||
char JB[32];//井别：开发、探井、采油井、注水井
|
||
float LoggingDepth;//测时井深
|
||
float azca;//闭合方位,磁偏角
|
||
float TVD;// 备注
|
||
double X0,Y0;
|
||
float Z0;// 起始测点位置坐标偏移量
|
||
float Mud_Temp;// 泥浆温度
|
||
char Intor[12];// 备注
|
||
char IntDepths[12];// 备注
|
||
char audit[32];
|
||
char Prog[32];
|
||
float WaterLoss;
|
||
char Item[32];
|
||
char temp[1024];
|
||
char Reserved[12];// 备注
|
||
}Slf32_FILE_MESSAGE;
|
||
|
||
typedef struct tagSlf3_FILE_HEAD
|
||
{
|
||
//起始位置 变量名称 字节长度 描 述
|
||
char Version[12];// 12 版本号
|
||
DWORD BinaryType;// 4 二进制数据标准
|
||
DWORD TableNumber;// 4 已存储表个数
|
||
DWORD MaxTableNumber;// 4 预留最大表个数
|
||
DWORD TableMessageLength;// 4 表基本信息长度
|
||
__time32_t TimeCreate;// 32 文件产生时间
|
||
/////////////////////////////////////
|
||
Slf3_FILE_MESSAGE WellMessage;
|
||
}Slf3_FILE_HEAD;
|
||
typedef struct tagSlf31_FILE_HEAD
|
||
{
|
||
//起始位置 变量名称 字节长度 描 述
|
||
char Version[12];// 12 版本号
|
||
DWORD BinaryType;// 4 二进制数据标准
|
||
DWORD TableNumber;// 4 已存储表个数
|
||
DWORD MaxTableNumber;// 4 预留最大表个数
|
||
DWORD TableMessageLength;// 4 表基本信息长度
|
||
__time32_t TimeCreate;// 32 文件产生时间
|
||
/////////////////////////////////////
|
||
Slf31_FILE_MESSAGE WellMessage;
|
||
}Slf_FILE_HEAD31;
|
||
typedef struct tagSlf32_FILE_HEAD
|
||
{
|
||
//起始位置 变量名称 字节长度 描 述
|
||
char Version[12];// 12 版本号
|
||
DWORD BinaryType;// 4 二进制数据标准
|
||
DWORD TableNumber;// 4 已存储表个数
|
||
DWORD MaxTableNumber;// 4 预留最大表个数
|
||
DWORD TableMessageLength;// 4 表基本信息长度
|
||
__time32_t TimeCreate;// 32 文件产生时间
|
||
/////////////////////////////////////
|
||
Slf32_FILE_MESSAGE WellMessage;
|
||
}Slf_FILE_HEAD32;
|
||
buf[7]=0;
|
||
if(stricmp(buf,"Slf 2.0")==0||stricmp(buf,"Slf 3.0")==0) {
|
||
char *p=(char *)&m_SlfHead;
|
||
int off=(char *)&m_SlfHead.WellMessage-p;
|
||
aFile->seek(0);
|
||
Slf_FILE_HEAD31 slf;
|
||
Slf3_FILE_HEAD slf3;
|
||
aFile->read((char *)&slf3,sizeof(Slf3_FILE_HEAD));
|
||
|
||
Slf_TABLE_ENTRY *slf3en=new Slf_TABLE_ENTRY[slf3.MaxTableNumber];
|
||
memset(slf3en,0,sizeof(Slf_TABLE_ENTRY)*slf3.MaxTableNumber);
|
||
int len=sizeof(Slf_FILE_HEAD31)-sizeof(Slf3_FILE_HEAD);
|
||
for(int i=0;i<slf3.TableNumber;i++) {
|
||
aFile->seek(sizeof(Slf3_FILE_HEAD)+i*slf3.TableMessageLength);
|
||
aFile->read((char *)&slf3en[i],sizeof(Slf_TABLE_ENTRY));
|
||
slf3en[i].Position+=len;
|
||
for(int j=0;j<slf3en[i].RecondNum;j++){
|
||
slf3en[i].DataRecord[j].DataPosition+=len;
|
||
}
|
||
}
|
||
memset(&slf,0,sizeof(Slf_FILE_HEAD31));
|
||
memmove(&slf,&slf3,off);
|
||
|
||
strcpy(slf.Version,"Slf 3.1");
|
||
slf.WellMessage.Altitude=slf.WellMessage.Altitude;
|
||
|
||
slf.WellMessage.AreaName[64];// 64 油矿名称
|
||
memmove(slf.WellMessage.OilCompanyName,slf3.WellMessage.OilCompanyName,sizeof(slf.WellMessage.OilCompanyName));// 64 公司名称
|
||
memmove(slf.WellMessage.WellName,slf3.WellMessage.WellName,sizeof(slf.WellMessage.WellName));//[64];// 64 井名
|
||
memmove(slf.WellMessage.WellAliasName,slf3.WellMessage.WellName,sizeof(slf.WellMessage.WellAliasName));//绘图需要的井名
|
||
memmove(slf.WellMessage.WellType,slf3.WellMessage.WellType,sizeof(slf.WellMessage.WellType));// 20 井类型：直井、斜井
|
||
slf.WellMessage.Xcoor=slf3.WellMessage.Xcoor;// 4 大地x坐标
|
||
slf.WellMessage.Ycoor=slf3.WellMessage.Ycoor;// 4 大地y坐标
|
||
slf.WellMessage.Altitude=slf3.WellMessage.Altitude;// 4 海拔高度
|
||
slf.WellMessage.Kelly=slf3.WellMessage.Kelly;// 4 补心高度
|
||
slf.WellMessage.StartDepth=slf3.WellMessage.StartDepth;// 4 起始深度
|
||
slf.WellMessage.EndDepth=slf3.WellMessage.EndDepth;// 4 终止深度
|
||
memmove((char *)&slf.WellMessage.StartDrillDate,(char *)&slf3.WellMessage.StartDrillDate,sizeof((char *)&slf.WellMessage.StartDrillDate));// 4 开钻时间
|
||
memmove((char *)&slf.WellMessage.EndDrillDate,(char *)&slf3.WellMessage.LoggingDate,sizeof(slf.WellMessage.LoggingDate));// 4 完钻时间
|
||
memmove((char *)&slf.WellMessage.LoggingDate,(char *)&slf3.WellMessage.LoggingDate,sizeof(slf.WellMessage.LoggingDate));// 4 测井时间
|
||
|
||
memmove(slf.WellMessage.LogCompanyName,slf3.WellMessage.LogCompanyName,sizeof(slf.WellMessage.LogCompanyName));//[64];// 64 测井公司
|
||
memmove(slf.WellMessage.LoggingTeam,slf3.WellMessage.LoggingTeam,sizeof(slf.WellMessage.LoggingTeam));// 20 测井队
|
||
memmove(slf.WellMessage.Operator,slf3.WellMessage.Operator,sizeof(slf.WellMessage.Operator));// 20 操作员
|
||
memmove(slf.WellMessage.LoggingSerial,slf3.WellMessage.LoggingSerial,sizeof(slf.WellMessage.LoggingSerial));// 20 测井系列
|
||
slf.WellMessage.Well_Bottom_Temperature=slf3.WellMessage.Well_Bottom_Temperature;//井底温度
|
||
for(int i=0;i<10;i++) {
|
||
slf.WellMessage.Mud_Density[i]=slf3.WellMessage.Mud_Density[i];
|
||
slf.WellMessage.Mud_Viscosity[i]=slf3.WellMessage.Mud_Viscosity[i];
|
||
slf.WellMessage.Mud_Resistivity[i]=slf3.WellMessage.Mud_Resistivity[i];
|
||
slf.WellMessage.Bit_Diameter[i]=slf3.WellMessage.Bit_Diameter[i];
|
||
slf.WellMessage.Bushing_Detpth[i]=slf3.WellMessage.Bushing_Detpth[i];
|
||
slf.WellMessage.Bushing_Inside_Diameter[i]=slf3.WellMessage.Bushing_Inside_Diameter[i];
|
||
slf.WellMessage.Bushing_Outside_Diameter[i]=slf3.WellMessage.Bushing_Outside_Diameter[i];
|
||
slf.WellMessage.Bit_Depth[i]=slf3.WellMessage.Bit_Depth[i];
|
||
}
|
||
memmove(slf.WellMessage.Mud_Property,slf3.WellMessage.Mud_Property,sizeof(slf.WellMessage.Mud_Property));//泥浆性能
|
||
memmove(slf.WellMessage.YqType,slf3.WellMessage.YqType,sizeof(slf.WellMessage.YqType));//仪器类型：skd3000、h2530、5700
|
||
memmove(slf.WellMessage.JB,slf3.WellMessage.JB,sizeof(slf.WellMessage.JB));//井别：开发、探井、采油井、注水井
|
||
slf.WellMessage.LoggingDepth=slf3.WellMessage.LoggingDepth;//测时井深
|
||
slf.WellMessage.azca=slf3.WellMessage.azca;//闭合方位,磁偏角
|
||
slf.WellMessage.TVD=slf3.WellMessage.TVD;// 备注
|
||
slf.WellMessage.X0=slf3.WellMessage.X0;
|
||
slf.WellMessage.Y0=slf3.WellMessage.Y0;
|
||
slf.WellMessage.Z0=slf3.WellMessage.Z0;// 起始测点位置坐标偏移量
|
||
slf.WellMessage.Mud_Temp=slf3.WellMessage.Mud_Temp;// 泥浆温度
|
||
memmove(slf.WellMessage.Intor,slf3.WellMessage.Intor,sizeof(slf.WellMessage.Intor));// 备注
|
||
memmove(slf.WellMessage.IntDepths,slf3.WellMessage.IntDepths,sizeof(slf.WellMessage.IntDepths));// 备注
|
||
memmove(slf.WellMessage.audit,slf3.WellMessage.audit,sizeof(slf.WellMessage.audit));
|
||
memmove(slf.WellMessage.Prog,slf3.WellMessage.Prog,sizeof(slf.WellMessage.Prog));
|
||
slf.WellMessage.WaterLoss=slf3.WellMessage.WaterLoss;
|
||
memmove(slf.WellMessage.Item,slf3.WellMessage.Item,sizeof(slf.WellMessage.Item));
|
||
memmove(slf.WellMessage.Reserved,slf3.WellMessage.Reserved,sizeof(slf3.WellMessage.Reserved));// 备注
|
||
|
||
char *buffer=new char [len+1];
|
||
long pos=sizeof(Slf3_FILE_HEAD);
|
||
long point =aFile->size();
|
||
long point1=aFile->size()+len;
|
||
while(point>=pos) {
|
||
if(point<len) break;
|
||
point-=len;
|
||
aFile->seek(point);
|
||
aFile->read(buffer,len);
|
||
if(point1<len) break;
|
||
point1-=len;
|
||
aFile->seek(point1);
|
||
aFile->write(buffer,len);
|
||
}
|
||
aFile->seek(0);
|
||
aFile->write((char*)&slf,sizeof(Slf_FILE_HEAD));
|
||
for(int i=0;i<slf3.TableNumber;i++) {
|
||
aFile->seek(sizeof(Slf_FILE_HEAD)+i*slf.TableMessageLength);
|
||
aFile->write((char *)&slf3en[i],sizeof(Slf_TABLE_ENTRY));
|
||
}
|
||
aFile->flush();
|
||
delete []buffer;
|
||
delete slf3en;
|
||
// QString cs=buf;
|
||
// cs+="该数据格式不再支持,请重新创建该文件！";
|
||
// AfxMessageBox(cs);
|
||
// return false;
|
||
}
|
||
if(stricmp(buf,"wis 1.0")==0||stricmp(buf,"SLF 1.0")==0) IsWis=1;
|
||
else if(stricmp(buf,"Slf 2.0")==0||
|
||
stricmp(buf,"Slf 3.0")==0||stricmp(buf,"Slf 3.1")==0)
|
||
{
|
||
IsWis=0;
|
||
}
|
||
else if(stricmp(buf,"Slf 3.2")==0)
|
||
{
|
||
Slf_FILE_HEAD slf;
|
||
Slf_FILE_HEAD32 slf32;
|
||
char *p=(char *)&slf;
|
||
int off=(char *)&slf.WellMessage.Reserved-p;
|
||
aFile->seek(0);
|
||
aFile->read((char *)&slf32,sizeof(Slf_FILE_HEAD32));
|
||
if(slf32.WellMessage.Kelly)slf32.WellMessage.Kelly=ConvertDataByString(QString::number(slf32.WellMessage.Kelly,'f',2));
|
||
if(slf32.WellMessage.Bit_Diameter[0])slf32.WellMessage.Bit_Diameter[0]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Diameter[0],'f',2));
|
||
if(slf32.WellMessage.Bit_Depth[0])slf32.WellMessage.Bit_Depth[0]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Depth[0],'f',2 ));
|
||
if(slf32.WellMessage.Bit_Diameter[1])slf32.WellMessage.Bit_Diameter[1]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Diameter[1],'f',2 ));
|
||
if(slf32.WellMessage.Bit_Depth[1])slf32.WellMessage.Bit_Depth[1]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Depth[1],'f',2 ));
|
||
if(slf32.WellMessage.Bit_Diameter[2])slf32.WellMessage.Bit_Diameter[2]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Diameter[2],'f',2));
|
||
if(slf32.WellMessage.Bit_Depth[2])slf32.WellMessage.Bit_Depth[2]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Depth[2],'f',2 ));
|
||
if(slf32.WellMessage.Bit_Diameter[3])slf32.WellMessage.Bit_Diameter[3]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Diameter[3],'f',2));
|
||
if(slf32.WellMessage.Bit_Depth[3])slf32.WellMessage.Bit_Depth[3]=ConvertDataByString(QString::number(slf32.WellMessage.Bit_Depth[3],'f',2 ));
|
||
if(slf32.WellMessage.Bushing_Inside_Diameter[0])slf32.WellMessage.Bushing_Inside_Diameter[0]=ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Inside_Diameter[0],'f',2) );
|
||
if(slf32.WellMessage.Bushing_Detpth[0])slf32.WellMessage.Bushing_Detpth[0]=ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Detpth[0],'f',2));
|
||
if(slf32.WellMessage.Bushing_Inside_Diameter[1])slf32.WellMessage.Bushing_Inside_Diameter[1]=ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Inside_Diameter[1],'f',2) );
|
||
if(slf32.WellMessage.Bushing_Detpth[1])slf32.WellMessage.Bushing_Detpth[1]=ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Detpth[1],'f',2));
|
||
if(slf32.WellMessage.Bushing_Inside_Diameter[2])slf32.WellMessage.Bushing_Inside_Diameter[2]=(ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Inside_Diameter[2],'f',2) ));
|
||
if(slf32.WellMessage.Bushing_Detpth[2])slf32.WellMessage.Bushing_Detpth[2]=ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Detpth[2],'f',2));
|
||
if(slf32.WellMessage.Bushing_Outside_Diameter[0])slf32.WellMessage.Bushing_Outside_Diameter[0]=(ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Outside_Diameter[0],'f',2)));
|
||
if(slf32.WellMessage.Bushing_Outside_Diameter[1])slf32.WellMessage.Bushing_Outside_Diameter[1]=(ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Outside_Diameter[1],'f',2)));
|
||
if(slf32.WellMessage.Bushing_Outside_Diameter[2])slf32.WellMessage.Bushing_Outside_Diameter[2]=ConvertDataByString(QString::number(slf32.WellMessage.Bushing_Outside_Diameter[2],'f',2));
|
||
|
||
memset(&slf,0,sizeof(Slf_FILE_HEAD));
|
||
memmove(&slf,&slf32,off);
|
||
memmove(&slf.WellMessage.Reserved,&slf32.WellMessage.Reserved,10);
|
||
Slf_TABLE_ENTRY *slf3en=new Slf_TABLE_ENTRY[slf32.MaxTableNumber];
|
||
memset(slf3en,0,sizeof(Slf_TABLE_ENTRY)*slf32.MaxTableNumber);
|
||
int len=sizeof(Slf_FILE_HEAD32)-sizeof(Slf_FILE_HEAD);
|
||
for(int i=0;i<slf32.TableNumber;i++) {
|
||
aFile->seek(sizeof(Slf_FILE_HEAD32)+i*slf32.TableMessageLength);
|
||
aFile->read((char *)&slf3en[i],sizeof(Slf_TABLE_ENTRY));
|
||
slf3en[i].Position-=len;
|
||
for(int j=0;j<slf3en[i].RecondNum;j++){
|
||
slf3en[i].DataRecord[j].DataPosition-=len;
|
||
}
|
||
}
|
||
strcpy(slf.Version,"Slf 3.1");
|
||
long length=aFile->size();
|
||
char *buffer=new char [len+1];
|
||
long point =sizeof(Slf_FILE_HEAD32);
|
||
long point1=sizeof(Slf_FILE_HEAD);
|
||
|
||
while(point<length) {
|
||
aFile->seek(point);
|
||
aFile->read(buffer,len);
|
||
aFile->seek(point1);
|
||
aFile->write(buffer,len);
|
||
point+=len;
|
||
point1+=len;
|
||
}
|
||
aFile->seek(0);
|
||
aFile->write((char*)&slf,sizeof(Slf_FILE_HEAD));
|
||
for(int i=0;i<slf32.TableNumber;i++) {
|
||
aFile->seek(sizeof(Slf_FILE_HEAD)+i*slf.TableMessageLength);
|
||
aFile->write((char *)&slf3en[i],sizeof(Slf_TABLE_ENTRY));
|
||
}
|
||
aFile->resize(length-len);
|
||
aFile->flush();
|
||
delete []buffer;
|
||
delete slf3en;
|
||
|
||
IsWis=0;
|
||
}
|
||
else {
|
||
IsWis=0;
|
||
aFile->close();
|
||
delete aFile;
|
||
return false;
|
||
}
|
||
}
|
||
else IsWis=0;//新文件
|
||
aFile->close();
|
||
delete aFile;
|
||
}
|
||
else IsWis=0;
|
||
return Open(nOpenFlags,BlockLen,MaxObjectNumber,MachineType,IsWis);
|
||
}
|
||
bool CSlfIO::BackUpFile()
|
||
{
|
||
QDir ss;
|
||
QString temp=m_LogFileName;
|
||
int pos=temp.indexOf("logdata",0,Qt::CaseInsensitive);
|
||
if(pos>-1)
|
||
{
|
||
QString tt=temp.left(pos+8);
|
||
tt+="/temp/#backup/";
|
||
ss.mkdir(tt);
|
||
temp=tt;
|
||
}
|
||
QString temp1=temp+"1.slf";
|
||
int i=1;
|
||
char buf[100];
|
||
while(ss.exists(temp1))
|
||
{
|
||
if(i>2)
|
||
{
|
||
QString temp2;
|
||
for(int j=1;j<i;j++)
|
||
{
|
||
sprintf(buf,"%d.slf",j);
|
||
temp2=temp+buf;
|
||
sprintf(buf,"%d.slf",j+1);
|
||
temp1=temp+buf;
|
||
if(j==1) QFile::remove(temp2);
|
||
QFile::rename(temp1,temp2);
|
||
}
|
||
break;
|
||
}
|
||
i++;
|
||
sprintf(buf,"%d.slf",i);
|
||
temp1=temp+buf;
|
||
}
|
||
bool l=QFile::copy(m_LogFileName,temp1);
|
||
return l;
|
||
}
|
||
|
||
bool CSlfIO::OpenWis(unsigned int nOpenFlags,int BlockLen,int MaxObjectNumber, int MachineType)
|
||
{
|
||
IsWis=1;
|
||
if(nOpenFlags==modeCreate)
|
||
{
|
||
// Attach a CFile object to the handle we have.
|
||
mFile=new QFile(m_LogFileName);
|
||
mFile->open(QIODevice::ReadWrite);
|
||
InitWis(BlockLen, MaxObjectNumber, MachineType);
|
||
mFile->flush();
|
||
return TRUE;
|
||
}
|
||
else {
|
||
int isexit=0;
|
||
QFileInfo w(m_LogFileName);
|
||
if(w.isFile()) isexit=1;
|
||
if(nOpenFlags&modeRead&&!(nOpenFlags&modeWrite)&&!isexit) return FALSE;
|
||
mFile=new QFile(m_LogFileName);
|
||
mFile->open(QIODevice::ReadWrite);
|
||
if(nOpenFlags&modeReadWrite&&!isexit) {
|
||
InitWis(BlockLen, MaxObjectNumber, MachineType);
|
||
mFile->flush();
|
||
}
|
||
ReadWisHead();
|
||
if(m_Head.MaxObjectNumber<=0) {
|
||
// AfxMessageBox("文件信息错误！");
|
||
return FALSE;
|
||
}
|
||
m_ObjectEntry=new Slf_OBJECT_ENTRY[m_Head.MaxObjectNumber];
|
||
Slf_Info_Head=new char *[m_Head.MaxObjectNumber];
|
||
for(int i=0;i<m_Head.MaxObjectNumber;i++) Slf_Info_Head[i]=NULL;
|
||
ReadWisObjectEntry();
|
||
for(int i=0;i<m_Head.ObjectNumber;i++)
|
||
{
|
||
strupr(m_ObjectEntry[i].Name);
|
||
}
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
void CSlfIO::Clear()
|
||
{
|
||
if(!mFile) return;
|
||
mFile->flush();
|
||
mFile->close();
|
||
delete mFile;
|
||
mFile=NULL;
|
||
// QFileInfo w(m_LogFileName);
|
||
// if(w.isFile()) {
|
||
// }
|
||
// else return;
|
||
mFile=new QFile(m_LogFileName);
|
||
mFile->open(QIODevice::ReadWrite);
|
||
{
|
||
int TableNumber=m_SlfHead.TableNumber;
|
||
if(mFile&&m_SlfObjectEntry)
|
||
{
|
||
ReadSlfHead();
|
||
ReadSlfObjectEntry();
|
||
int num=0;
|
||
for(int index=m_SlfHead.TableNumber;index<m_SlfHead.MaxTableNumber;index++)
|
||
{
|
||
Slf_Info_Head[index]=NULL;
|
||
}
|
||
for(int index=0;index<m_SlfHead.TableNumber;index++) {
|
||
if(m_SlfObjectEntry[index].Status==OBJECT_DISCARD) {
|
||
num++;
|
||
}
|
||
}
|
||
for(int j=0;j<num;j++)
|
||
{
|
||
for(int index=m_SlfHead.TableNumber-1;index>=0;index--)
|
||
{
|
||
if(m_SlfObjectEntry[index].Status==OBJECT_DISCARD)
|
||
{
|
||
DiscardSlfObjectData(index);
|
||
memmove((char *)&m_SlfObjectEntry[index],(char *)&m_SlfObjectEntry[index+1],sizeof(Slf_TABLE_ENTRY)*(m_SlfHead.TableNumber-index));
|
||
|
||
if(Slf_Info_Head[index]) {
|
||
Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
|
||
delete []temp1->pField;
|
||
delete []temp1;
|
||
for(int i=index;i<m_SlfHead.TableNumber;i++) {
|
||
if(i<m_SlfHead.MaxTableNumber-1) Slf_Info_Head[i]=Slf_Info_Head[i+1];
|
||
else Slf_Info_Head[i]=NULL;
|
||
}
|
||
Slf_Info_Head[m_SlfHead.TableNumber]=NULL;
|
||
}
|
||
|
||
WriteSlfObjectEntry();
|
||
if(m_SlfHead.TableNumber>0)m_SlfHead.TableNumber--;
|
||
if((int)m_SlfHead.TableNumber<0) m_SlfHead.TableNumber=0;
|
||
WriteSlfHead();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
void CSlfIO::Close()
|
||
{
|
||
Clear();
|
||
if(mFile){
|
||
mFile->flush();
|
||
mFile->close();
|
||
//CloseHandle(mFile->m_hFile);
|
||
delete mFile;
|
||
mFile=NULL;
|
||
}
|
||
if(m_ObjectEntry)delete []m_ObjectEntry;
|
||
if(m_SlfObjectEntry)delete []m_SlfObjectEntry;
|
||
if(Slf_Info_Head) {
|
||
if(IsWis) {
|
||
for(int i=0;i<m_Head.MaxObjectNumber;i++)
|
||
if(Slf_Info_Head[i]) {
|
||
delete Slf_Info_Head[i];
|
||
Slf_Info_Head[i]=NULL;
|
||
}
|
||
}
|
||
else {
|
||
for(int i=0;i<m_SlfHead.MaxTableNumber;i++)
|
||
if(Slf_Info_Head[i]) {
|
||
CloseSlfTable(i);
|
||
// delete Slf_Info_Head[i];
|
||
// Slf_Info_Head[i]=NULL;
|
||
}
|
||
}
|
||
delete [] Slf_Info_Head;
|
||
}
|
||
m_ObjectEntry=NULL;
|
||
m_SlfObjectEntry=NULL;
|
||
Slf_Info_Head=NULL;
|
||
}
|
||
void CSlfIO::GetWisHead(Slf_HEAD* pHead)
|
||
{
|
||
memmove(pHead,&m_Head,sizeof(Slf_HEAD));
|
||
}
|
||
void CSlfIO::Convert(char*,DWORD,WORD)
|
||
{
|
||
}
|
||
//Object Operations
|
||
int CSlfIO::FindWisObjectIndex(const char* namee,int status)
|
||
{
|
||
char name[128];
|
||
strcpy(name,namee);
|
||
strupr((char *)name);
|
||
for(int i=0;i<m_Head.ObjectNumber;i++) {
|
||
if(strcmp(name,m_ObjectEntry[i].Name)==0) {
|
||
if(status==-1) return i;
|
||
if(status==m_ObjectEntry[i].Status) return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
int CSlfIO::FindWisObjectName(char* name,short Attribute, short SubAttribute, int status)
|
||
{
|
||
for(int i=0;i<m_Head.ObjectNumber;i++)
|
||
{
|
||
if(strcmp(name,m_ObjectEntry[i].Name)==0)
|
||
{
|
||
if(Attribute>-1)
|
||
{
|
||
if(m_ObjectEntry[i].Attribute==Attribute)
|
||
{
|
||
if(SubAttribute>-1)
|
||
{
|
||
if(m_ObjectEntry[i].SubAttribute==SubAttribute)
|
||
{
|
||
if(status>-1)
|
||
{
|
||
if(m_ObjectEntry[i].Status==status) return i;
|
||
continue;//else return -1;
|
||
}
|
||
else return i;
|
||
}
|
||
continue;//else return -1;
|
||
}
|
||
else if(status>-1)
|
||
{
|
||
if(m_ObjectEntry[i].Status==status) return i;
|
||
continue;//else return -1;
|
||
}
|
||
else return i;
|
||
}
|
||
continue;//else return -1;
|
||
}
|
||
else if(SubAttribute>-1)
|
||
{
|
||
if(m_ObjectEntry[i].SubAttribute==SubAttribute)
|
||
{
|
||
if(status>-1)
|
||
{
|
||
if(m_ObjectEntry[i].Status==status) return i;
|
||
continue;//else return -1;
|
||
}
|
||
else return i;
|
||
}
|
||
continue;//else return -1;
|
||
}
|
||
else if(status>-1)
|
||
{
|
||
if(m_ObjectEntry[i].Status==status) return i;
|
||
continue;//else return -1;
|
||
}
|
||
else return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
bool CSlfIO::DeleteWisObject(const char* namee)
|
||
{
|
||
char name[128];
|
||
strcpy(name,namee);
|
||
strupr((char *)name);
|
||
int index=FindWisObjectName((char *)name,-1,-1,OBJECT_NORMAL);
|
||
if(index>-1) {
|
||
m_ObjectEntry[index].Status=OBJECT_DELETE;
|
||
WriteWisObjectEntry();
|
||
return TRUE;
|
||
}
|
||
else return FALSE;
|
||
}
|
||
bool CSlfIO::DiscardWisObject(const char* namee)
|
||
{
|
||
char name[128];
|
||
strcpy(name,namee);
|
||
strupr((char *)name);
|
||
int index=FindWisObjectName((char *)name,-1,-1,OBJECT_DELETE);
|
||
if(index<0) index=FindWisObjectName((char *)name);
|
||
return DiscardWisObject(index);
|
||
}
|
||
bool CSlfIO::DiscardWisObject(int index)
|
||
{
|
||
if(index>-1&&index<m_Head.ObjectNumber) {
|
||
int i=0;
|
||
DWORD point,point1;
|
||
char *buffer=new char[m_Head.BlockLen+1];
|
||
point1=m_ObjectEntry[index].Position;
|
||
point =m_ObjectEntry[index].Position+m_ObjectEntry[index].BlockNum*m_Head.BlockLen;
|
||
while(point<m_Head.FileSize){
|
||
mFile->seek(point);
|
||
mFile->read(buffer,m_Head.BlockLen);
|
||
mFile->seek(point1);
|
||
mFile->write(buffer,m_Head.BlockLen);
|
||
point+=m_Head.BlockLen;
|
||
point1+=m_Head.BlockLen;
|
||
}
|
||
mFile->flush();
|
||
delete []buffer;
|
||
DWORD len=m_ObjectEntry[index].BlockNum*m_Head.BlockLen;
|
||
m_Head.FileSize-=len;
|
||
if(Slf_Info_Head[index]) {
|
||
delete []Slf_Info_Head[index];
|
||
Slf_Info_Head[index]=NULL;
|
||
}
|
||
for(i=index+1;i<m_Head.ObjectNumber;i++) m_ObjectEntry[i].Position-=len;
|
||
for(i=index ;i<m_Head.ObjectNumber;i++) {
|
||
if(i<m_Head.MaxObjectNumber-1)
|
||
memmove(&m_ObjectEntry[i],&m_ObjectEntry[i+1],sizeof(Slf_OBJECT_ENTRY));
|
||
else memset(&m_ObjectEntry[i],0,sizeof(Slf_OBJECT_ENTRY));
|
||
}
|
||
for(i=index ;i<m_Head.ObjectNumber;i++)
|
||
{
|
||
if(i<m_Head.MaxObjectNumber-1) Slf_Info_Head[i]=Slf_Info_Head[i+1];
|
||
else Slf_Info_Head[i]=NULL;
|
||
}
|
||
Slf_Info_Head[m_Head.ObjectNumber-1]=NULL;
|
||
m_Head.ObjectNumber--;
|
||
WriteWisObjectEntry();
|
||
WriteWisHead();
|
||
mFile->resize(m_Head.FileSize);
|
||
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
bool CSlfIO::RenameWisObject(int index,const char* newNamee)
|
||
{
|
||
char newName[128];
|
||
strcpy(newName,newNamee);
|
||
strupr((char *)newName);
|
||
int ind=FindWisObjectName(newName);
|
||
if(ind>=0) return false;
|
||
if(index>-1) {
|
||
memmove(m_ObjectEntry[index].Name,newName,sizeof(m_ObjectEntry[index].Name));
|
||
WriteWisObjectEntry();
|
||
if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT) {
|
||
Slf_CHANNEL m_Channel;
|
||
ReadWisChannelInfo(index,&m_Channel);
|
||
|
||
memmove(m_Channel.DimInfo[0].Name,newName,sizeof(m_Channel.DimInfo[0].Name));
|
||
WriteWisChannelInfo(index,&m_Channel);
|
||
}
|
||
return TRUE;
|
||
}
|
||
else return FALSE;
|
||
}
|
||
bool CSlfIO::RenameWisObject(const char* oldName,const char* newNamee)
|
||
{
|
||
int index=FindWisObjectIndex(oldName);
|
||
return RenameWisObject(index,newNamee);
|
||
}
|
||
bool CSlfIO::CopyWisObject(const char* oldName,const char* newName, bool bFailExist)
|
||
{
|
||
if(m_Head.ObjectNumber>=m_Head.MaxObjectNumber) return false;
|
||
int index=FindWisObjectIndex(oldName);
|
||
if(index<0) return FALSE;
|
||
index=FindWisObjectIndex(newName);
|
||
if(index>=0&&bFailExist) return FALSE;
|
||
if(index>=0) {
|
||
char back[200];
|
||
strcpy(back,newName);
|
||
strcat(back,".bak");
|
||
CString sss;
|
||
sss.Format("CopyWisObject %s",back);
|
||
AfxMessageBox(sss);
|
||
RenameObject(newName,back);
|
||
}
|
||
index=FindWisObjectIndex(oldName);//whp add 2011.10.30 如果没有词句，index=-1，m_ObjectEntry[index].BlockNum是个很大的数字
|
||
char *buffer=new char[m_Head.BlockLen+1];
|
||
DWORD point1,point2;
|
||
point1=m_ObjectEntry[index].Position;
|
||
point2=m_Head.FileSize;
|
||
for(DWORD i=0;i<m_ObjectEntry[index].BlockNum;i++) {
|
||
mFile->seek(point1);
|
||
mFile->read(buffer,m_Head.BlockLen);
|
||
mFile->seek(point2);
|
||
mFile->write(buffer,m_Head.BlockLen);
|
||
point1+=m_Head.BlockLen;
|
||
point2+=m_Head.BlockLen;
|
||
}
|
||
mFile->flush();
|
||
memmove(&m_ObjectEntry[m_Head.ObjectNumber],&m_ObjectEntry[index],sizeof(Slf_OBJECT_ENTRY));
|
||
m_ObjectEntry[m_Head.ObjectNumber].Position=m_Head.FileSize;
|
||
memmove(m_ObjectEntry[m_Head.ObjectNumber].Name,newName,sizeof(m_ObjectEntry[m_Head.ObjectNumber].Name));
|
||
if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT) {
|
||
Slf_CHANNEL temp;
|
||
ReadWisChannelInfo(index,&temp);
|
||
memmove(temp.DimInfo[0].Name,newName,sizeof(temp.DimInfo[0].Name));
|
||
WriteWisChannelInfo(m_Head.ObjectNumber,&temp);
|
||
}
|
||
m_Head.FileSize+=m_ObjectEntry[index].BlockNum*m_Head.BlockLen;
|
||
m_Head.ObjectNumber++;
|
||
WriteWisObjectEntry();
|
||
WriteWisHead();
|
||
delete []buffer;
|
||
return TRUE;
|
||
}
|
||
bool CSlfIO::UnDeleteWisObject(const char* name)
|
||
{
|
||
int index=FindWisObjectIndex(name);
|
||
if(index>-1) {
|
||
m_ObjectEntry[index].Status=OBJECT_NORMAL;
|
||
WriteWisObjectEntry();
|
||
return TRUE;
|
||
}
|
||
else return FALSE;
|
||
}
|
||
WORD CSlfIO::GetWisObjectCount()
|
||
{
|
||
return m_Head.ObjectNumber;
|
||
}
|
||
void CSlfIO::GetAllWisObjectEntry(Slf_OBJECT_ENTRY* pEntry,WORD count)
|
||
{
|
||
if(count<=0) count=m_Head.ObjectNumber;
|
||
memmove(pEntry,m_ObjectEntry,sizeof(Slf_OBJECT_ENTRY)*count);
|
||
}
|
||
void CSlfIO::GetWisObjectEntry(int index,Slf_OBJECT_ENTRY* pEntry)
|
||
{
|
||
memmove(pEntry,&m_ObjectEntry[index],sizeof(Slf_OBJECT_ENTRY));
|
||
}
|
||
void CSlfIO::SetWisObjectReserved(int index,char* pEntry)
|
||
{
|
||
int len=strlen(pEntry);
|
||
if(len>=32) len=31;
|
||
memmove(&m_ObjectEntry[index].Reserved,pEntry,len);
|
||
m_ObjectEntry[index].Reserved[len]=0;
|
||
WriteWisObjectEntry();
|
||
}
|
||
bool CSlfIO::GetWisObjectEntry(const char* name,Slf_OBJECT_ENTRY* pEntry)
|
||
{
|
||
int index=FindWisObjectIndex(name);
|
||
if(index>-1) {
|
||
GetWisObjectEntry(index,pEntry);
|
||
return TRUE;
|
||
}
|
||
else return FALSE;
|
||
}
|
||
void CSlfIO::GetWisObjectAttribute(int index,short* Attribute, short* SubAttribute)
|
||
{
|
||
*Attribute=m_ObjectEntry[index].Attribute;
|
||
*SubAttribute=m_ObjectEntry[index].SubAttribute;
|
||
if(m_ObjectEntry[index].Attribute==TABLE_OBJECT) *SubAttribute=m_ObjectEntry[index].SubAttribute+CARD_OBJECT;
|
||
}
|
||
bool CSlfIO::GetWisObjectAttribute(const char* name,short* Attribute, short* SubAttribute)
|
||
{
|
||
int index=FindWisObjectIndex(name);
|
||
if(index>-1) {
|
||
GetWisObjectAttribute(index,Attribute, SubAttribute);
|
||
return TRUE;
|
||
}
|
||
else return FALSE;
|
||
}
|
||
//Channel Operations
|
||
int CSlfIO::OpenWisChannel(const char *name)
|
||
{
|
||
Slf_CHANNEL m_Channel;
|
||
for(int i=0;i<m_Head.ObjectNumber;i++) {
|
||
if(m_ObjectEntry[i].Attribute==CHANNEL_OBJECT) {
|
||
ReadWisChannelInfo(i,&m_Channel);
|
||
if(m_ObjectEntry[i].Status==OBJECT_NORMAL&&(/*strcmp(m_Channel.AliasName,name)==0||*/strcmp(m_ObjectEntry[i].Name,name)==0)) {
|
||
if(!Slf_Info_Head[i])Slf_Info_Head[i]=new char[sizeof(Slf_CHANNEL)];
|
||
memmove(Slf_Info_Head[i],&m_Channel,sizeof(Slf_CHANNEL));
|
||
return i;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
int CSlfIO::OpenWisChannel(const char *namee,short Attribute)
|
||
{
|
||
char name[128];
|
||
strcpy(name,namee);
|
||
strupr((char *)name);
|
||
Slf_CHANNEL m_Channel;
|
||
for(int i=0;i<m_Head.ObjectNumber;i++) {
|
||
if(m_ObjectEntry[i].Attribute==CHANNEL_OBJECT&&m_ObjectEntry[i].SubAttribute==Attribute) {
|
||
ReadWisChannelInfo(i,&m_Channel);
|
||
if(m_ObjectEntry[i].Status==OBJECT_NORMAL&&(/*strcmp(m_Channel.AliasName,name)==0||*/strcmp(m_ObjectEntry[i].Name,name)==0)) {
|
||
if(!Slf_Info_Head[i])Slf_Info_Head[i]=new char[sizeof(Slf_CHANNEL)];
|
||
memmove(Slf_Info_Head[i],&m_Channel,sizeof(Slf_CHANNEL));
|
||
return i;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
DWORD CSlfIO::ComputerWisChannelLength(Slf_CHANNEL *pInfo,unsigned char nDimension)
|
||
{
|
||
return (DWORD)(pInfo->DimInfo[(int)nDimension].Samples*pInfo->DimInfo[(int)nDimension].Size);
|
||
}
|
||
DWORD CSlfIO::ComputerWisChannelLength(int index)
|
||
{
|
||
Slf_CHANNEL *m_Channel=(Slf_CHANNEL *)Slf_Info_Head[index];
|
||
int fmtsize;
|
||
if(m_ObjectEntry[index].SubAttribute==FMT_OBJECT) fmtsize=sizeof(int);
|
||
else if(m_ObjectEntry[index].SubAttribute==TDT_OBJECT) fmtsize=sizeof(double);
|
||
else fmtsize=0;
|
||
return (DWORD)(m_Channel->DimInfo[0].Size+fmtsize);
|
||
}
|
||
int CSlfIO::GetWisChannelDefaultValue(Slf_CHANNEL* pInfo,unsigned char nDimension,char* buffer,DWORD buflen)
|
||
{
|
||
return 1;
|
||
}
|
||
bool CSlfIO::SetWisChannelPointNum(int index, DWORD nPointNum, DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
|
||
{
|
||
if(mFile->seek(m_ObjectEntry[index].Position+m_Head.BlockLen)>=0) {
|
||
mFile->write(reinterpret_cast<char*>(&nPointNum),sizeof(DWORD));
|
||
mFile->flush();
|
||
}
|
||
return TRUE;
|
||
}
|
||
DWORD CSlfIO::GetWisChannelPointNum(int index,DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
|
||
{
|
||
DWORD nPointNum=0;
|
||
if(mFile->seek(m_ObjectEntry[index].Position+m_Head.BlockLen)>=0) {
|
||
mFile->read(reinterpret_cast<char*>(&nPointNum),sizeof(DWORD));
|
||
}
|
||
return nPointNum;
|
||
}
|
||
int CSlfIO::CreateWisChannel(short SubAttribute,const char *namee,Slf_CHANNEL* pInfo,bool bFailExist)
|
||
{
|
||
char name[128];
|
||
strcpy(name,namee);
|
||
strupr((char *)name);
|
||
int index=FindWisObjectName((char *)name,1,-1,OBJECT_NORMAL);//int index=FindWisObjectIndex(name);
|
||
int BlockNum,PointNum=pInfo->DimInfo[0].Samples;
|
||
if(PointNum==0) PointNum=pInfo->DimInfo[0].MaxSamples;
|
||
if(SubAttribute==FMT_OBJECT) BlockNum=mod((pInfo->DimInfo[0].Size+sizeof(DWORD))*PointNum+sizeof(DWORD),m_Head.BlockLen);
|
||
else if(SubAttribute==TDT_OBJECT) BlockNum=mod((pInfo->DimInfo[0].Size+sizeof(double))*PointNum,m_Head.BlockLen);
|
||
else BlockNum=mod(pInfo->DimInfo[0].Size*PointNum,m_Head.BlockLen);
|
||
pInfo->DimInfo[0].MaxSamples=BlockNum*m_Head.BlockLen/pInfo->DimInfo[0].Size;
|
||
if(index<0) {
|
||
index=m_Head.ObjectNumber++;
|
||
if(!Slf_Info_Head[index]){
|
||
Slf_Info_Head[index]=new char [sizeof(Slf_CHANNEL)];
|
||
//TODO aiya
|
||
//assert(AfxIsValidAddress(Slf_Info_Head[index], sizeof(Slf_CHANNEL), FALSE));
|
||
}
|
||
if(SubAttribute==FMT_OBJECT) pInfo->DimInfo[0].Samples=0;
|
||
memmove(Slf_Info_Head[index],pInfo,sizeof(Slf_CHANNEL));
|
||
m_ObjectEntry[index].SubAttribute=SubAttribute;
|
||
m_ObjectEntry[index].Attribute=CHANNEL_OBJECT;
|
||
m_ObjectEntry[index].Position=m_Head.FileSize;
|
||
m_ObjectEntry[index].BlockNum=1;
|
||
memmove(m_ObjectEntry[index].Name,name,sizeof(m_ObjectEntry[index].Name));
|
||
m_ObjectEntry[index].Status=0;
|
||
time_t createTime;
|
||
gmtime(&createTime);
|
||
m_ObjectEntry[index].TimeCreate=(unsigned int)createTime;
|
||
m_ObjectEntry[index].TimeWrite=(unsigned int)createTime;
|
||
strcpy(m_ObjectEntry[index].Reserved,"WANG WEI ");
|
||
WriteWisObjectEntry();
|
||
WriteWisChannelInfo(index);//,pInfo);
|
||
m_Head.FileSize+=m_Head.BlockLen;
|
||
ExpandWisObject(index,BlockNum);
|
||
if(SubAttribute==FMT_OBJECT) SetWisChannelPointNum(index,PointNum);
|
||
return index;
|
||
}
|
||
else if(bFailExist) {
|
||
if(!Slf_Info_Head[index]) Slf_Info_Head[index]=new char [sizeof(Slf_CHANNEL)];
|
||
ReadWisChannelInfo(index);
|
||
Slf_CHANNEL *temp=(Slf_CHANNEL *) Slf_Info_Head[index];
|
||
if(temp->DimInfo[0].Delta!=pInfo->DimInfo[0].Delta)
|
||
WisChannelResamples(index,temp->DimInfo[0].Delta);
|
||
if(temp->DimInfo[0].MaxSamples!=pInfo->DimInfo[0].MaxSamples)
|
||
ExpandWisChannel(index,0,temp->DimInfo[0].MaxSamples,temp->DimInfo[0].MaxSamples);
|
||
m_ObjectEntry[index].SubAttribute=SubAttribute;
|
||
// memmove(Slf_Info_Head[index],pInfo,sizeof(Slf_CHANNEL));
|
||
WriteWisObjectEntry();
|
||
// WriteWisChannelInfo(index);
|
||
return index;
|
||
}
|
||
return -1;
|
||
}
|
||
DWORD CSlfIO::SeekWisChannel(int index,DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
|
||
{
|
||
int dim=0,fmtsize=0;
|
||
DWORD samples=0;
|
||
DWORD point,len;
|
||
if(samples1>0) {dim=0;samples=samples1;}
|
||
if(samples2>0) {dim=1;samples=samples2;}
|
||
if(samples3>0) {dim=2;samples=samples3;}
|
||
if(samples4>0) {dim=3;samples=samples4;}
|
||
if(dim==0&&samples==0)samples=1;
|
||
if(m_ObjectEntry[index].SubAttribute==FMT_OBJECT) fmtsize=sizeof(int);
|
||
else if(m_ObjectEntry[index].SubAttribute==TDT_OBJECT) fmtsize=sizeof(double);
|
||
else fmtsize=0;
|
||
point=m_ObjectEntry[index].Position+m_Head.BlockLen+fmtsize;
|
||
len=ComputerWisChannelLength(index)*(samples-1);
|
||
point+=len;
|
||
point=mFile->seek(point);
|
||
return samples;
|
||
}
|
||
DWORD CSlfIO::WriteWisChannel(int index,char* buffer,DWORD num, DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
|
||
{
|
||
int SamplesPos=SeekWisChannel(index,samples1,samples2,samples3,samples4);
|
||
int BlockNum=mod((SamplesPos+num-1)*ComputerWisChannelLength(index)+m_Head.BlockLen-m_ObjectEntry[index].BlockNum*m_Head.BlockLen,m_Head.BlockLen);
|
||
Slf_CHANNEL *m_Channel=(Slf_CHANNEL *)Slf_Info_Head[index];
|
||
if(BlockNum>0) {
|
||
ExpandWisObject(index,BlockNum);
|
||
SeekWisChannel(index,samples1,samples2,samples3,samples4);
|
||
m_Channel->DimInfo[0].MaxSamples=(m_ObjectEntry[index].BlockNum-1)*m_Head.BlockLen/m_Channel->DimInfo[0].Size;
|
||
WriteWisChannelInfo(index);
|
||
SeekWisChannel(index,samples1,samples2,samples3,samples4);
|
||
}
|
||
if(SamplesPos+num-1>(int)m_Channel->DimInfo[0].Samples) {
|
||
m_Channel->DimInfo[0].Samples=SamplesPos+num-1;
|
||
WriteWisChannelInfo(index);
|
||
SeekWisChannel(index,samples1,samples2,samples3,samples4);
|
||
}
|
||
int l=num*ComputerWisChannelLength(index);
|
||
mFile->write(buffer,l);
|
||
mFile->flush();
|
||
return l;
|
||
}
|
||
DWORD CSlfIO::ReadWisChannel(int index,char* buffer,DWORD num, DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
|
||
{
|
||
int samples=SeekWisChannel(index,samples1,samples2,samples3,samples4);
|
||
int len=num*ComputerWisChannelLength(index);
|
||
return mFile->read(buffer,len);
|
||
}
|
||
bool CSlfIO::ExpandWisChannel(int index, unsigned char nDimension, DWORD nSamples, DWORD nTopSamples)
|
||
{
|
||
Slf_CHANNEL *m_Channel=(Slf_CHANNEL *)Slf_Info_Head[index];
|
||
if(nTopSamples>m_Channel->DimInfo[0].MaxSamples) {
|
||
int len=nTopSamples*ComputerWisChannelLength(index);
|
||
DWORD BlockNum=mod(len,m_Head.BlockLen)+1-m_ObjectEntry[index].BlockNum;
|
||
m_Channel->DimInfo[nDimension].Samples=nSamples;
|
||
m_Channel->DimInfo[nDimension].MaxSamples=(m_ObjectEntry[index].BlockNum-1+BlockNum)*m_Head.BlockLen/m_Channel->DimInfo[nDimension].Size;
|
||
WriteWisChannelInfo(index);
|
||
ExpandWisObject(index,BlockNum);
|
||
}
|
||
else if(nTopSamples<m_Channel->DimInfo[0].MaxSamples) {
|
||
int len=nTopSamples*ComputerWisChannelLength(index);
|
||
int SBlockNum=mod(len,m_Head.BlockLen)+1;
|
||
if(SBlockNum<1) return FALSE;
|
||
int BlockNum =m_ObjectEntry[index].BlockNum-SBlockNum;
|
||
if(BlockNum<1) return FALSE;
|
||
m_Channel->DimInfo[nDimension].Samples=nSamples;
|
||
m_Channel->DimInfo[nDimension].MaxSamples=SBlockNum*m_Head.BlockLen/m_Channel->DimInfo[nDimension].Size;
|
||
// WriteWisChannelInfo(index);
|
||
char *buffer=new char[m_Head.BlockLen+1];
|
||
DWORD point,point1;
|
||
point1=m_ObjectEntry[index].Position+SBlockNum*m_Head.BlockLen;
|
||
point =m_ObjectEntry[index].Position+m_ObjectEntry[index].BlockNum*m_Head.BlockLen;
|
||
while(point<m_Head.FileSize){
|
||
mFile->seek(point);
|
||
mFile->read(buffer,m_Head.BlockLen);
|
||
mFile->seek(point1);
|
||
mFile->write(buffer,m_Head.BlockLen);
|
||
point+=m_Head.BlockLen;
|
||
point1+=m_Head.BlockLen;
|
||
}
|
||
mFile->flush();
|
||
delete []buffer;
|
||
m_ObjectEntry[index].BlockNum-=BlockNum;
|
||
m_Head.FileSize-=BlockNum*m_Head.BlockLen;;
|
||
for(int i=index+1;i<m_Head.ObjectNumber;i++) m_ObjectEntry[i].Position-=BlockNum*m_Head.BlockLen;
|
||
WriteWisObjectEntry();
|
||
WriteWisHead();
|
||
mFile->resize(m_Head.FileSize);
|
||
return FALSE;
|
||
}
|
||
return 1;
|
||
}
|
||
bool CSlfIO::MoveWisChannel(int index, unsigned char nDimension, DWORD nStart, int nMove, DWORD nTotal)
|
||
{
|
||
Slf_CHANNEL *m_Channel=(Slf_CHANNEL *)Slf_Info_Head[index];
|
||
char *buffer=new char[m_Channel->DimInfo[nDimension].Size+1];
|
||
DWORD point,point1,point2;
|
||
int lenn=0;
|
||
nStart--;nTotal--;
|
||
point=m_ObjectEntry[index].Position+m_Head.BlockLen;
|
||
for(int i=1;i<nDimension;i++) lenn+=m_Channel->DimInfo[i].Size*m_Channel->DimInfo[i].MaxSamples;
|
||
if(nMove<0) {
|
||
if(nStart+nMove<0) nStart=-nMove;
|
||
for(int j=nStart;j<=(int)nTotal;j++) {
|
||
point1=point+lenn+m_Channel->DimInfo[0].Size*j;
|
||
point2=point+lenn+m_Channel->DimInfo[0].Size*(j+nMove);
|
||
mFile->seek(point1);
|
||
mFile->read(buffer,m_Channel->DimInfo[nDimension].Size);
|
||
mFile->seek(point2);
|
||
mFile->write(buffer,m_Channel->DimInfo[nDimension].Size);
|
||
}
|
||
mFile->flush();
|
||
}
|
||
else {
|
||
if(nTotal+nMove>=m_Channel->DimInfo[0].Samples) {
|
||
int mm=nTotal+nMove-m_Channel->DimInfo[0].Samples;
|
||
m_Channel->DimInfo[0].Samples+=mm;
|
||
if(nTotal+nMove>=m_Channel->DimInfo[0].MaxSamples) {
|
||
nTotal=m_Channel->DimInfo[0].MaxSamples-nMove;
|
||
m_Channel->DimInfo[0].Samples=m_Channel->DimInfo[0].MaxSamples;
|
||
}
|
||
WriteWisChannelInfo(index);
|
||
}
|
||
for(int j=nTotal;j>=(int)nStart;j--) {
|
||
point1=point+lenn+m_Channel->DimInfo[0].Size*j;
|
||
point2=point+lenn+m_Channel->DimInfo[0].Size*(j+nMove);
|
||
mFile->seek(point1);
|
||
mFile->read(buffer,m_Channel->DimInfo[nDimension].Size);
|
||
mFile->seek(point2);
|
||
mFile->write(buffer,m_Channel->DimInfo[nDimension].Size);
|
||
}
|
||
mFile->flush();
|
||
}
|
||
delete buffer;
|
||
return 1;
|
||
}
|
||
bool CSlfIO::OrderWisChannel(int index, unsigned char nDimension, int nMethod)
|
||
{
|
||
return 1;
|
||
}
|
||
bool CSlfIO::CorrectWisChannel(int index, unsigned char nDimension, float delta)
|
||
{
|
||
Slf_CHANNEL *m_Channel=(Slf_CHANNEL *)Slf_Info_Head[index];
|
||
m_Channel->DimInfo[nDimension].StartVal+=delta;
|
||
WriteWisChannelInfo(index);
|
||
return 1;
|
||
}
|
||
void CSlfIO::SetData(int RepCode,char *buffer,float *yy)
|
||
{
|
||
switch(RepCode)
|
||
{
|
||
case REPR_INT: //0
|
||
(*((int*)buffer))=(int)*yy;
|
||
break;
|
||
case REPR_SHORT: //1
|
||
(*((short *)buffer))=(short)*yy;
|
||
break;
|
||
case REPR_LONG://2
|
||
(*((long *)buffer))=(long)*yy;
|
||
break;
|
||
case REPR_FLOAT://3
|
||
(*((float *)buffer))=*yy;
|
||
break;
|
||
case REPR_DOUBLE://4
|
||
(*((double *)buffer))=(double)*yy;
|
||
break;
|
||
case REPR_CHAR://5
|
||
(*((char *)buffer))=(char)*yy;
|
||
break;
|
||
case REPR_UCHAR://6
|
||
(*((unsigned char *)buffer))=(unsigned char)*yy;
|
||
break;
|
||
case REPR_USHORT://7
|
||
(*((unsigned short *)buffer))=(unsigned short)*yy;
|
||
break;
|
||
case REPR_UINT://8
|
||
(*((unsigned int *)buffer))=(unsigned int)*yy;
|
||
break;
|
||
case REPR_ULONG://9
|
||
(*((unsigned long *)buffer))=(unsigned long )*yy;
|
||
break;
|
||
case REPR_STRING://10
|
||
// *yy=-99999;
|
||
break;
|
||
}
|
||
}
|
||
float CSlfIO::GetData(int RepCode,char *buffer,float *yy)
|
||
{
|
||
switch(RepCode)
|
||
{
|
||
case REPR_INT: //0
|
||
*yy=(float)(*((int*)buffer));
|
||
break;
|
||
case REPR_SHORT: //1
|
||
*yy=(float)(*((short *)buffer));
|
||
break;
|
||
case REPR_LONG://2
|
||
*yy=(float)(*((long *)buffer));
|
||
break;
|
||
case REPR_FLOAT://3
|
||
*yy=(float)(*((float *)buffer));
|
||
break;
|
||
case REPR_DOUBLE://4
|
||
*yy=(float)(*((double *)buffer));
|
||
break;
|
||
case REPR_CHAR://5
|
||
*yy=(float)(*((char *)buffer));
|
||
break;
|
||
case REPR_UCHAR://6
|
||
*yy=(float)(*((unsigned char *)buffer));
|
||
break;
|
||
case REPR_USHORT://7
|
||
*yy=(float)(*((unsigned short *)buffer));
|
||
break;
|
||
case REPR_UINT://8
|
||
*yy=(float)(*((unsigned int *)buffer));
|
||
break;
|
||
case REPR_ULONG://9
|
||
*yy=(float)(*((unsigned long *)buffer));
|
||
break;
|
||
case REPR_STRING://10
|
||
*yy=-99999;
|
||
break;
|
||
}
|
||
return *yy;
|
||
}
|
||
void CSlfIO::GetData(int RepCode,char *buffer,char *format,char *buf)
|
||
{
|
||
switch(RepCode)
|
||
{
|
||
case REPR_INT: //0
|
||
sprintf(buf,format,*(int*)buffer);
|
||
break;
|
||
case REPR_SHORT: //1
|
||
sprintf(buf,format,*(short *)buffer);
|
||
break;
|
||
case REPR_LONG://2
|
||
sprintf(buf,format,*(long *)buffer);
|
||
break;
|
||
case REPR_FLOAT://3
|
||
sprintf(buf,format,*(float *)buffer);
|
||
break;
|
||
case REPR_DOUBLE://4
|
||
sprintf(buf,format,*(double *)buffer);
|
||
break;
|
||
case REPR_CHAR://5
|
||
sprintf(buf,format,*(char *)buffer);
|
||
break;
|
||
case REPR_UCHAR://6
|
||
sprintf(buf,format,*(unsigned char *)buffer);
|
||
break;
|
||
case REPR_USHORT://7
|
||
sprintf(buf,format,*(unsigned short *)buffer);
|
||
break;
|
||
case REPR_UINT://8
|
||
sprintf(buf,format,*(unsigned int *)buffer);
|
||
break;
|
||
case REPR_ULONG://9
|
||
sprintf(buf,format,*(unsigned long *)buffer);
|
||
break;
|
||
case REPR_STRING://10
|
||
strcpy(buf,buffer);
|
||
break;
|
||
}
|
||
}
|
||
void CSlfIO::WisChannelResamples(int index,float newDelta)
|
||
{
|
||
Slf_CHANNEL *m_Channel=(Slf_CHANNEL *)Slf_Info_Head[index];
|
||
Slf_CHANNEL mych,mych1;
|
||
if(m_Channel->DimInfo[0].Delta==newDelta) return;
|
||
if(FindWisObjectIndex("NEWNAME")>-1) DiscardWisObject("NEWNAME");
|
||
if(!CopyWisObject((const char* )m_ObjectEntry[index].Name,(const char* )"NEWNAME")) return;
|
||
ReadWisChannelInfo(index,&mych);
|
||
mych.DimInfo[0].Samples =(DWORD)((mych.DimInfo[0].Delta*mych.DimInfo[0].Samples )/newDelta+0.5);
|
||
ExpandWisChannel(index,0,mych.DimInfo[0].Samples,mych.DimInfo[0].Samples);
|
||
// ReadWisChannelInfo(index,&mych);
|
||
mych.DimInfo[0].Delta=newDelta;
|
||
WriteWisChannelInfo(index,&mych);
|
||
ReadWisChannelInfo(index);
|
||
int mIndex=OpenWisChannel("NEWNAME");
|
||
float dep,yy1,yy2,yy;
|
||
int k1,k2;
|
||
DWORD num,num1;
|
||
int Pos=0;
|
||
ReadWisChannelInfo(mIndex,&mych1);
|
||
if(m_ObjectEntry[index].SubAttribute==CURVE_OBJECT) {
|
||
num1=mych1.DimInfo[0].Samples*mych1.DimInfo[0].Size;
|
||
char *buffer1=new char[num1+1];
|
||
ReadWisChannel(mIndex,(char *)buffer1,mych1.DimInfo[0].Samples,1,0,0,0);
|
||
num=mych.DimInfo[0].Samples*mych.DimInfo[0].Size;
|
||
char *buffer=new char[num+1];
|
||
for(DWORD i=0;i<mych.DimInfo[0].Samples;i++) {
|
||
dep=i*newDelta;
|
||
k1=dep/mych1.DimInfo[0].Delta+0.5;
|
||
k2=dep/mych1.DimInfo[0].Delta+1.5;
|
||
Pos=k1*mych.CodeLen;
|
||
GetData(mych.RepCode,&buffer1[Pos],&yy1);
|
||
Pos=k2*mych.CodeLen;
|
||
GetData(mych.RepCode,&buffer1[Pos],&yy2);
|
||
// add by whp 2004.1.13
|
||
if(k1==k2)yy=yy1;
|
||
else yy=yy1+(yy2-yy1)*(i*mych.DimInfo[0].Delta-k1*mych1.DimInfo[0].Delta)/((k2-k1)*mych1.DimInfo[0].Delta);
|
||
Pos=i*mych.CodeLen;
|
||
SetData(mych.RepCode,&buffer[Pos],&yy);
|
||
}
|
||
WriteWisChannel(index,(char *)buffer,mych.DimInfo[0].Samples,1,0,0,0);
|
||
delete []buffer;
|
||
delete []buffer1;
|
||
}
|
||
else if(m_ObjectEntry[index].SubAttribute==WAVE_OBJECT) {
|
||
num1=mych1.DimInfo[0].Size;
|
||
char *buffer=new char[num1+1];
|
||
for(DWORD i=0;i<mych.DimInfo[0].Samples;i++) {
|
||
dep=i*newDelta;
|
||
k1=dep/mych1.DimInfo[0].Delta+0.5;
|
||
ReadWisChannel(mIndex,buffer,1,0,k1);
|
||
WriteWisChannel(index,buffer,1,0,i+1);
|
||
}
|
||
delete []buffer;
|
||
}
|
||
CloseChannel(mIndex);
|
||
DiscardWisObject("NEWNAME");
|
||
}
|
||
void CSlfIO::CloseChannel(int index)
|
||
{
|
||
if(index<0) return ;
|
||
if(IsWis) {
|
||
if(Slf_Info_Head[index])delete Slf_Info_Head[index];
|
||
Slf_Info_Head[index]=NULL;
|
||
}
|
||
else CloseSlfTable(index);
|
||
}
|
||
//Table Opeartions
|
||
|
||
int CSlfIO::OpenWisTable(const char*namee)
|
||
{
|
||
char name[128];
|
||
strcpy(name,namee);
|
||
strupr((char *)name);
|
||
int index;
|
||
index=FindWisObjectName((char *)name,(short)TABLE_OBJECT);
|
||
if(index>-1) {
|
||
if(m_ObjectEntry[index].Status!=OBJECT_NORMAL) return -1;
|
||
if(!Slf_Info_Head[index])Slf_Info_Head[index]=new char [sizeof(Slf_TABLE)];
|
||
Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
|
||
SeekWisTable(index,-1);
|
||
mFile->read(Slf_Info_Head[index],sizeof(Slf_TABLE_HEAD));
|
||
m_Table->Length=GetWisTableRecordLength(index);
|
||
return index;
|
||
}
|
||
return -1;
|
||
}
|
||
int CSlfIO::CreateWisTable(short SubAttribute,const char* namee,DWORD length,bool bFailExist)
|
||
{
|
||
char name[128];
|
||
strcpy(name,namee);
|
||
strupr((char *)name);
|
||
int index=FindWisObjectName((char *)name,(short)TABLE_OBJECT);
|
||
if(index>-1) {
|
||
if(!Slf_Info_Head[index])Slf_Info_Head[index]=new char [sizeof(Slf_TABLE)];
|
||
if(bFailExist) return index;
|
||
m_ObjectEntry[index].SubAttribute=SubAttribute;
|
||
time_t createTime;
|
||
gmtime(&createTime);
|
||
m_ObjectEntry[index].TimeWrite=(unsigned int)createTime;
|
||
WriteWisObjectEntry();
|
||
return index;
|
||
}
|
||
index=m_Head.ObjectNumber++;
|
||
if(!Slf_Info_Head[index])Slf_Info_Head[index]=new char [sizeof(Slf_TABLE)];
|
||
m_ObjectEntry[index].SubAttribute=SubAttribute;
|
||
m_ObjectEntry[index].Position=m_Head.FileSize;
|
||
memmove(m_ObjectEntry[index].Name,name,sizeof(m_ObjectEntry[index].Name));
|
||
m_ObjectEntry[index].Attribute=TABLE_OBJECT;
|
||
m_ObjectEntry[index].Status=0;
|
||
|
||
time_t createTime;
|
||
gmtime(&createTime);
|
||
m_ObjectEntry[index].TimeCreate=(unsigned int)createTime;
|
||
m_ObjectEntry[index].TimeWrite=(unsigned int)createTime;
|
||
|
||
strcpy(m_ObjectEntry[index].Reserved,"WANG WEI !");
|
||
m_ObjectEntry[index].BlockNum=0;
|
||
WriteWisObjectEntry();
|
||
int BlockNum=mod(length+sizeof(Slf_TABLE),m_Head.BlockLen);
|
||
if(BlockNum>0) ExpandWisTable(index,BlockNum);
|
||
return index;
|
||
}
|
||
bool CSlfIO::CloseTable(int index)
|
||
{
|
||
if(index<0) return FALSE;
|
||
if(Slf_Info_Head[index]) {
|
||
if(!IsWis) {
|
||
Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
|
||
delete []temp1->pField;
|
||
}
|
||
delete []Slf_Info_Head[index];
|
||
}
|
||
Slf_Info_Head[index]=NULL;
|
||
return TRUE;
|
||
}
|
||
bool CSlfIO::SeekWisTable(int index, int OffsetCount, DWORD dwMoveMode)
|
||
{
|
||
Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
|
||
int len=0;
|
||
if(OffsetCount<0) len=0;
|
||
else if(OffsetCount==0) len=sizeof(Slf_TABLE_HEAD);
|
||
else len=sizeof(Slf_TABLE_HEAD)+m_Table->FieldCount*sizeof(Slf_TABLE_FIELD_OLD)+(OffsetCount-1)*m_Table->Length;
|
||
return SeekWisStream(index,len, dwMoveMode);
|
||
}
|
||
int CSlfIO::GetWisTableRecordCount(int index)
|
||
{
|
||
Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
|
||
return m_Table->RecordCount;
|
||
}
|
||
int CSlfIO::GetWisTableFieldCount(int index)
|
||
{
|
||
Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
|
||
if(!m_Table) return 0;
|
||
return m_Table->FieldCount;
|
||
}
|
||
int CSlfIO::GetMaxObjectNumber()
|
||
{
|
||
if(IsWis) return m_Head.MaxObjectNumber;
|
||
return m_SlfHead.MaxTableNumber;
|
||
}
|
||
int CSlfIO::GetObjectStatus(int index)
|
||
{
|
||
if(IsWis) return m_ObjectEntry[index].Status;
|
||
return m_SlfObjectEntry[index].Status;
|
||
}
|
||
|
||
int CSlfIO::SetWisTableFieldInfo(int index,Slf_TABLE_FIELD *FieldInfo)
|
||
{
|
||
Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
|
||
|
||
SeekWisTable(index,-1);
|
||
mFile->seek(sizeof(Slf_TABLE_HEAD)+SEEK_CUR);
|
||
for(int i=0;i<m_Table->FieldCount;i++){
|
||
mFile->write(reinterpret_cast<char*>(&FieldInfo[i]),sizeof(Slf_TABLE_FIELD_OLD));
|
||
}
|
||
mFile->flush();
|
||
if(FieldInfo) return 1;
|
||
else return 0;
|
||
}
|
||
|
||
int CSlfIO::SetWisTableHead(int index,DWORD RecordCount,DWORD FieldCount,Slf_TABLE_FIELD *FieldInfo)
|
||
{
|
||
Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
|
||
m_Table->RecordCount=RecordCount;
|
||
m_Table->FieldCount=FieldCount;
|
||
if(FieldInfo) {
|
||
m_Table->Length=0;
|
||
for(int i=0;i<(int)m_Table->FieldCount;i++)
|
||
{
|
||
m_Table->Length+=FieldInfo[i].Length;
|
||
}
|
||
}
|
||
SeekWisTable(index,-1);
|
||
mFile->write(reinterpret_cast<char*>(m_Table),sizeof(Slf_TABLE_HEAD));
|
||
for(int i=0;i<FieldCount;i++)
|
||
{
|
||
mFile->write(reinterpret_cast<char*>(&FieldInfo[i]),sizeof(Slf_TABLE_FIELD_OLD));
|
||
}
|
||
mFile->flush();
|
||
if(FieldInfo) return 1;
|
||
else return 0;
|
||
}
|
||
|
||
bool CSlfIO::SetWisTableRecordCount(int index,int Count)
|
||
{
|
||
Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
|
||
SeekWisTable(index,-1);
|
||
m_Table->RecordCount=Count;
|
||
mFile->write(reinterpret_cast<char*>(m_Table),sizeof(DWORD));
|
||
mFile->flush();
|
||
return 1;
|
||
}
|
||
|
||
bool CSlfIO::ExpandWisTable(int index,DWORD BlockNum)
|
||
{
|
||
return ExpandWisObject(index,BlockNum);
|
||
}
|
||
|
||
bool CSlfIO::GetWisTableFieldInfo(int index,Slf_TABLE_FIELD *FieldInfo)
|
||
{
|
||
Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
|
||
SeekWisTable(index);
|
||
int len=m_Table->FieldCount*sizeof(Slf_TABLE_FIELD_OLD);
|
||
Slf_TABLE_FIELD_OLD*pOd=new Slf_TABLE_FIELD_OLD[m_Table->FieldCount+1];
|
||
int len1=mFile->read(reinterpret_cast<char*>(pOd),len);
|
||
for(int i=0;i<m_Table->FieldCount;i++){
|
||
memmove(FieldInfo[i].Name,pOd[i].Name,sizeof(FieldInfo->Name));
|
||
memmove(FieldInfo[i].HZName,pOd[i].HZName,sizeof(FieldInfo->Name));
|
||
FieldInfo[i].Unit[0]=0;
|
||
FieldInfo[i].HZUnit[0]=0;
|
||
FieldInfo[i].RepCode=pOd[i].RepCode;
|
||
FieldInfo[i].Length=pOd[i].Length;
|
||
FieldInfo[i].Reserved=0;
|
||
}
|
||
delete pOd;
|
||
if(len==len1){
|
||
return TRUE;
|
||
}
|
||
else return FALSE;
|
||
}
|
||
|
||
int CSlfIO::GetWisTableRecordLength(int index)
|
||
{
|
||
Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
|
||
Slf_TABLE_FIELD buf;
|
||
SeekWisTable(index);
|
||
m_Table->Length=0;
|
||
for(int i=0;i<(int)m_Table->FieldCount;i++) {
|
||
mFile->read(reinterpret_cast<char*>(&buf),sizeof(Slf_TABLE_FIELD_OLD));
|
||
m_Table->Length+=buf.Length;
|
||
}
|
||
return m_Table->Length;
|
||
}
|
||
int CSlfIO::ReadWisTable(int index, int count, void *buffer)
|
||
{
|
||
Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
|
||
if(count<1) return 0;
|
||
SeekWisTable(index,count);
|
||
return mFile->read(reinterpret_cast<char*>(buffer),m_Table->Length);
|
||
}
|
||
int CSlfIO::mod(int a,int b)
|
||
{
|
||
if(a<0||b<0) return -1;
|
||
if(a%b==0) return a/b;
|
||
else return a/b+1;
|
||
}
|
||
int CSlfIO::WriteWisTable(int index, int count, void *buffer)
|
||
{
|
||
Slf_TABLE *m_Table=(Slf_TABLE *)Slf_Info_Head[index];
|
||
if(count<1) return 0;
|
||
int BlockNum=mod(count*m_Table->Length+m_Table->FieldCount*sizeof(Slf_TABLE_FIELD_OLD)+sizeof(Slf_TABLE_HEAD)-m_ObjectEntry[index].BlockNum*m_Head.BlockLen,m_Head.BlockLen);
|
||
if(BlockNum>0) ExpandWisTable(index,BlockNum);
|
||
if((DWORD)count>m_Table->RecordCount) {
|
||
m_Table->RecordCount=count;
|
||
SetWisTableRecordCount(index,count);
|
||
}
|
||
SeekWisTable(index,count);
|
||
mFile->write(reinterpret_cast<char*>(buffer),m_Table->Length);
|
||
mFile->flush();
|
||
return 1;
|
||
}
|
||
|
||
//Stream Operations
|
||
int CSlfIO::OpenWisStream(const char* namee)
|
||
{
|
||
char name[256];
|
||
strcpy(name,namee);
|
||
strupr((char *)name);
|
||
int index=FindWisObjectName((char *)name,(short)STREAM_OBJECT);
|
||
if(index>-1) {
|
||
if(m_ObjectEntry[index].Status!=OBJECT_NORMAL) return -1;
|
||
if(!Slf_Info_Head[index])Slf_Info_Head[index]=new char [sizeof(Slf_STREAM)];
|
||
ReadWisStreamInfo(index);
|
||
return index;
|
||
}
|
||
return -1;
|
||
}
|
||
int CSlfIO::CreateWisStream(short SubAttribute,const char *namee,DWORD length,bool bFailExist)
|
||
{
|
||
char name[128];
|
||
strcpy(name,namee);
|
||
strupr((char *)name);//对象名为大写
|
||
int index=FindWisObjectName((char *)name,(short)STREAM_OBJECT);
|
||
if(index>-1) {
|
||
if(!Slf_Info_Head[index])Slf_Info_Head[index]=new char [sizeof(Slf_STREAM)];
|
||
if(bFailExist) return index;
|
||
m_ObjectEntry[index].SubAttribute=SubAttribute;
|
||
time_t createTime;
|
||
gmtime(&createTime);
|
||
m_ObjectEntry[index].TimeWrite=(unsigned int)createTime;
|
||
WriteWisObjectEntry();
|
||
return index;
|
||
}
|
||
index=m_Head.ObjectNumber++;
|
||
if(!Slf_Info_Head[index])Slf_Info_Head[index]=new char [sizeof(Slf_STREAM)];
|
||
m_ObjectEntry[index].SubAttribute=SubAttribute;
|
||
m_ObjectEntry[index].Position=m_Head.FileSize;
|
||
memmove(m_ObjectEntry[index].Name,name,sizeof(m_ObjectEntry[index].Name));
|
||
m_ObjectEntry[index].Attribute=STREAM_OBJECT;
|
||
m_ObjectEntry[index].Status=0;
|
||
|
||
time_t createTime;
|
||
gmtime(&createTime);
|
||
m_ObjectEntry[index].TimeCreate=(unsigned int)createTime;
|
||
m_ObjectEntry[index].TimeWrite=(unsigned int)createTime;
|
||
|
||
strcpy(m_ObjectEntry[index].Reserved,"WANG WEI !");
|
||
m_ObjectEntry[index].BlockNum=0;
|
||
int BlockNum=mod(length,m_Head.BlockLen);
|
||
if(BlockNum>0) ExpandWisStream(index,BlockNum);
|
||
SetWisStreamLength(index, (DWORD)0);
|
||
return index;
|
||
}
|
||
void CSlfIO::CloseStream(int index)
|
||
{
|
||
if(index<0) return;
|
||
if(IsWis) {
|
||
if(Slf_Info_Head[index]) {
|
||
delete []Slf_Info_Head[index];
|
||
}
|
||
Slf_Info_Head[index]=NULL;
|
||
}
|
||
else CloseSlfTable(index);
|
||
}
|
||
bool CSlfIO::SetWisStreamLength(int index, DWORD length)
|
||
{
|
||
Slf_STREAM *m_Stream=(Slf_STREAM *)Slf_Info_Head[index];
|
||
SeekWisStream(index);
|
||
mFile->write((const char *)&length,sizeof(DWORD));
|
||
mFile->flush();
|
||
m_Stream->Length=length;
|
||
DWORD len=length;
|
||
if(len==length) return TRUE;
|
||
else return FALSE;
|
||
}
|
||
bool CSlfIO::ExpandWisStream(int index, DWORD BlockNum)
|
||
{
|
||
return ExpandWisObject(index,BlockNum);
|
||
}
|
||
bool CSlfIO::SeekWisStream(int index, int lMove, DWORD dwMoveMode)
|
||
{
|
||
DWORD point;
|
||
if(dwMoveMode==0) point=m_ObjectEntry[index].Position+lMove;
|
||
else if(dwMoveMode==1) point=m_ObjectEntry[index].Position+lMove;
|
||
else {
|
||
if(index+1>=m_Head.ObjectNumber) point=m_Head.FileSize-lMove;
|
||
else point=m_ObjectEntry[index+1].Position-lMove;
|
||
}
|
||
mFile->seek(point);
|
||
return 1;
|
||
}
|
||
bool CSlfIO::ReadWisStream(int index, DWORD length, LPDWORD lpBytesRead, char *buffer)
|
||
{
|
||
SeekWisStream(index, sizeof(DWORD));
|
||
*lpBytesRead=mFile->read(buffer,length);
|
||
if(*lpBytesRead==length) return TRUE;
|
||
else return FALSE;
|
||
}
|
||
bool CSlfIO::WriteWisStream(int index, DWORD length, LPDWORD lpBytesWrite, const char *buffer)
|
||
{
|
||
Slf_STREAM *m_Stream=(Slf_STREAM *)Slf_Info_Head[index];
|
||
int BlockNum=mod(length+sizeof(DWORD)-m_ObjectEntry[index].BlockNum*m_Head.BlockLen,m_Head.BlockLen);
|
||
if(BlockNum>0) ExpandWisStream(index,BlockNum);
|
||
m_Stream->Length=length;
|
||
WriteWisStreamInfo(index);
|
||
SeekWisStream(index, sizeof(DWORD));
|
||
mFile->write(buffer,length);
|
||
mFile->flush();
|
||
*lpBytesWrite=length;
|
||
if(*lpBytesWrite==length) return TRUE;
|
||
else return FALSE;
|
||
}
|
||
DWORD CSlfIO::GetWisStreamLength(int index)
|
||
{
|
||
Slf_STREAM *m_Stream=(Slf_STREAM *)Slf_Info_Head[index];
|
||
ReadWisStreamInfo(index);
|
||
return m_Stream->Length;
|
||
}
|
||
DWORD CSlfIO::GetWisObjectLength(char *name)
|
||
{
|
||
int index=FindWisObjectName(name);
|
||
if(index<0) return 0;
|
||
return m_ObjectEntry[index].BlockNum*m_Head.BlockLen;
|
||
}
|
||
bool CSlfIO::CopyWisObjectToMem(Slf_OBJECT_ENTRY *my,char *name,char *buffer,int Len)
|
||
{
|
||
int index=FindWisObjectName(name);
|
||
if(index<0) return NULL;
|
||
memmove(my,&m_ObjectEntry[index],sizeof(Slf_OBJECT_ENTRY));
|
||
mFile->seek(m_ObjectEntry[index].Position);
|
||
mFile->read(buffer,Len);
|
||
return TRUE;
|
||
}
|
||
bool CSlfIO::CopyFromWisFile(Slf_OBJECT_ENTRY *my,char *buffer,int Len)
|
||
{
|
||
int index=FindWisObjectName(my->Name);
|
||
if(index>=0) return FALSE;
|
||
memmove(&m_ObjectEntry[m_Head.ObjectNumber],my,sizeof(Slf_OBJECT_ENTRY));
|
||
m_ObjectEntry[m_Head.ObjectNumber].Position=m_Head.FileSize;
|
||
mFile->seek(m_Head.FileSize);
|
||
mFile->write(buffer,Len);
|
||
mFile->flush();
|
||
m_Head.FileSize+=Len;
|
||
m_Head.ObjectNumber++;
|
||
WriteWisHead();
|
||
WriteWisObjectEntry();
|
||
return TRUE;
|
||
}
|
||
bool CSlfIO::CopyFromWisFile(CSlfIO &Source,char *Name)
|
||
{
|
||
if(!Source.mFile) return FALSE;
|
||
if(Source.IsWis) {
|
||
int len=Source.GetWisObjectLength(Name);
|
||
if(len==0) return FALSE;
|
||
char *buf=new char[len+1];
|
||
if(!buf) return FALSE;
|
||
Slf_OBJECT_ENTRY obje;
|
||
if(Source.GetWisObjectEntry(Name,&obje)) {
|
||
if(Source.CopyWisObjectToMem(&obje,Name,buf,len)) {
|
||
if(CopyFromWisFile(&obje,buf,len)) {
|
||
delete buf;
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
delete buf;
|
||
}
|
||
return FALSE;
|
||
}
|
||
bool CSlfIO::CopyFromWisFile(CSlfIO &Source,char *Name,char *newName)
|
||
{
|
||
if(!Source.mFile) return FALSE;
|
||
if(Source.IsWis) {
|
||
int len=Source.GetWisObjectLength(Name);
|
||
if(len==0) return FALSE;
|
||
char *buf=new char[len+1];
|
||
if(!buf) return FALSE;
|
||
Slf_OBJECT_ENTRY obje;
|
||
if(Source.GetWisObjectEntry(Name,&obje)) {
|
||
if(Source.CopyWisObjectToMem(&obje,Name,buf,len)) {
|
||
strcpy(obje.Name,newName);
|
||
if(CopyFromWisFile(&obje,buf,len)) {
|
||
delete buf;
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
delete buf;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
void CSlfIO::Pack()
|
||
{
|
||
if(IsWis) WisPack();
|
||
else SlfPack();
|
||
}
|
||
void CSlfIO::Init(int BlockLen,int MaxObjectNumber, int MachineType)
|
||
{
|
||
if(IsWis) InitWis(BlockLen,MaxObjectNumber,MachineType);
|
||
else InitSlf(BlockLen,MaxObjectNumber,MachineType);
|
||
}
|
||
int CSlfIO::ReadHead()
|
||
{
|
||
if(IsWis) return ReadWisHead();
|
||
else return ReadSlfHead();
|
||
}
|
||
int CSlfIO::WriteHead()
|
||
{
|
||
if(IsWis) return WriteWisHead();
|
||
else return WriteSlfHead();
|
||
}
|
||
int CSlfIO::ReadObjectEntry()
|
||
{
|
||
if(IsWis) return ReadWisObjectEntry();
|
||
else return ReadSlfObjectEntry();
|
||
}
|
||
|
||
int CSlfIO::WriteObjectEntry()
|
||
{
|
||
if(IsWis) return WriteWisObjectEntry();
|
||
else return WriteSlfObjectEntry();
|
||
}
|
||
int CSlfIO::ReadChannelInfo(int index,Slf_CHANNEL *pInfo)
|
||
{
|
||
return ReadWisChannelInfo(index,pInfo);
|
||
}
|
||
int CSlfIO::WriteChannelInfo(int index,Slf_CHANNEL *pInfo)
|
||
{
|
||
return WriteWisChannelInfo(index,pInfo);
|
||
}
|
||
int CSlfIO::ReadStreamInfo(int index)
|
||
{
|
||
if(IsWis) return ReadWisStreamInfo(index);
|
||
else return ReadSlfStreamInfo(index);
|
||
}
|
||
int CSlfIO::WriteStreamInfo(int index)
|
||
{
|
||
if(IsWis) return WriteWisStreamInfo(index);
|
||
else return WriteSlfStreamInfo(index);
|
||
}
|
||
bool CSlfIO::ExpandObject(int index, DWORD BlockNum)
|
||
{
|
||
if(IsWis) return ExpandWisObject(index,BlockNum);
|
||
else return 1;//ExpandSlfObject(index,BlockNum);
|
||
}
|
||
int CSlfIO::FindFreeSpace(DWORD BlockNum,int nExceptIndex)
|
||
{
|
||
if(IsWis) return WisFindFreeSpace(BlockNum,nExceptIndex);
|
||
else return 1;//SlfFindFreeSpace(BlockNum,nExceptIndex);
|
||
}
|
||
bool CSlfIO::Open(unsigned int nOpenFlags,int BlockLen,int MaxObjectNumber, int MachineType,int FileType)
|
||
{
|
||
|
||
CString s;
|
||
char cs[MAX_PATH+100]="SlfOpen_";
|
||
strcat(cs,m_LogFileName);
|
||
s=cs;
|
||
s.Replace("\\","_");
|
||
s.Replace(":","_");
|
||
s.Replace(".","_");
|
||
s.Replace(" ","_");
|
||
s.Replace("#","_");
|
||
//cs=s.GetString();
|
||
//strcpy(cs,s.GetString());
|
||
//TODO
|
||
//MappingMem(&mHandle,(LPSTR *)&m_Value,4,s.GetString());
|
||
if(FileType) return OpenWis(nOpenFlags,BlockLen,MaxObjectNumber,MachineType);
|
||
else return OpenSlf(nOpenFlags,BlockLen,MaxObjectNumber,MachineType);
|
||
}
|
||
void CSlfIO::WisPack()
|
||
{
|
||
for(int i=0;i<m_Head.ObjectNumber;i++)
|
||
if(m_ObjectEntry[i].Status==OBJECT_DELETE) DiscardWisObject(i);
|
||
}
|
||
void CSlfIO::SlfPack()
|
||
{
|
||
for(int i=0;i<m_SlfHead.TableNumber;i++)
|
||
if(m_SlfObjectEntry[i].Status==OBJECT_DELETE)
|
||
{
|
||
DiscardSlfObject(i);
|
||
}
|
||
/*
|
||
for(int i=0;i<m_SlfHead.TableNumber;i++)
|
||
{
|
||
if(m_SlfObjectEntry[i].RecondNum>1)
|
||
{
|
||
int rec=GetSlfTableRecordCount(i);
|
||
SetSlfTableRecordCount(i,rec);
|
||
}
|
||
}*/
|
||
}
|
||
//Object Operations
|
||
int CSlfIO::FindObjectIndex(const char* namee)
|
||
{
|
||
if(IsWis) return FindWisObjectIndex(namee);
|
||
else return FindSlfObjectIndex(namee);
|
||
}
|
||
int CSlfIO::FindObjectName(char* name,short Attribute, short SubAttribute, int status,int otype)
|
||
{
|
||
if(IsWis) return FindWisObjectName(name,Attribute,SubAttribute,status);
|
||
else return FindSlfObjectName(name,Attribute,SubAttribute,status,otype);
|
||
}
|
||
bool CSlfIO::DeleteObject(const char* namee)
|
||
{
|
||
if(IsWis) return DeleteWisObject(namee);
|
||
else return DeleteSlfObject(namee);
|
||
}
|
||
bool CSlfIO::DiscardObject(const char* namee)
|
||
{
|
||
if(IsWis) return DiscardWisObject(namee);
|
||
else return DiscardSlfObject(namee);
|
||
}
|
||
bool CSlfIO::DiscardObject(int index)
|
||
{
|
||
if(IsWis) return DiscardWisObject(index);
|
||
else return DiscardSlfObject(index);
|
||
}
|
||
bool CSlfIO::RenameObject(int index,const char* newNamee)
|
||
{
|
||
if(IsWis) return RenameWisObject(index,newNamee);
|
||
else return RenameSlfObject(index,newNamee);
|
||
}
|
||
bool CSlfIO::RenameObject(const char* oldName,const char* newNamee)
|
||
{
|
||
if(IsWis) return RenameWisObject(oldName,newNamee);
|
||
else return RenameSlfObject(oldName,newNamee);
|
||
}
|
||
bool CSlfIO::CopyObject(const char* oldName,const char* newName, bool bFailExist)
|
||
{
|
||
if(IsWis) return CopyWisObject(oldName,newName,bFailExist);
|
||
else return CopySlfObject(oldName,newName,bFailExist);
|
||
}
|
||
bool CSlfIO::UnDeleteObject(const char* name)
|
||
{
|
||
if(IsWis) return UnDeleteWisObject(name);
|
||
else return UndeleteSlfObject(name);
|
||
}
|
||
WORD CSlfIO::GetObjectCount()
|
||
{
|
||
if(IsWis) return GetWisObjectCount();
|
||
else return GetSlfObjectCount();
|
||
}
|
||
void CSlfIO::GetAllObjectEntry(Slf_OBJECT_ENTRY* pEntry,WORD count)
|
||
{
|
||
if(IsWis) return GetAllWisObjectEntry(pEntry,count);
|
||
else return GetAllSlfObjectEntry((Slf_TABLE_ENTRY *)pEntry,count);
|
||
}
|
||
bool CSlfIO::GetObjectEntry(const char* name,Slf_OBJECT_ENTRY* pEntry)
|
||
{
|
||
if(IsWis) return GetWisObjectEntry(name,pEntry);
|
||
else {
|
||
Slf_TABLE_ENTRY my;
|
||
if(GetSlfObjectEntry(name,&my)) {
|
||
memmove((char *)pEntry->Name,my.Name,sizeof(pEntry->Name));
|
||
pEntry->Status=my.Status;
|
||
if(my.Type==CURVE_OBJECT||my.Type==TDT_OBJECT||my.Type==FMT_OBJECT) {
|
||
pEntry->Attribute=CHANNEL_OBJECT;
|
||
pEntry->SubAttribute=my.Type;
|
||
}
|
||
else if(my.Type==CARD_OBJECT) {
|
||
pEntry->Attribute=STREAM_OBJECT;
|
||
pEntry->SubAttribute=PARA_OBJECT;
|
||
}
|
||
else if(my.Type>CARD_OBJECT) {
|
||
pEntry->Attribute=TABLE_OBJECT;
|
||
pEntry->SubAttribute=my.Type-CARD_OBJECT;
|
||
}
|
||
return TRUE;
|
||
}
|
||
else return FALSE;
|
||
}
|
||
}
|
||
void CSlfIO::SetObjectReserved(int index,char* pEntry)
|
||
{
|
||
if(IsWis) return SetWisObjectReserved(index,pEntry);
|
||
else return SetSlfObjectReserved(index,pEntry);
|
||
}
|
||
void CSlfIO::GetObjectEntry(int index,Slf_OBJECT_ENTRY* pEntry)
|
||
{
|
||
if(IsWis) return GetWisObjectEntry(index,pEntry);
|
||
else {
|
||
Slf_TABLE_ENTRY my;
|
||
GetSlfObjectEntry(index,&my);
|
||
memmove((char *)pEntry->Name,my.Name,sizeof(pEntry->Name));
|
||
pEntry->Status=my.Status;
|
||
if(my.Type==CURVE_OBJECT||my.Type==TDT_OBJECT||my.Type==FMT_OBJECT) {
|
||
pEntry->Attribute=CHANNEL_OBJECT;
|
||
pEntry->SubAttribute=my.Type;
|
||
}
|
||
else if(my.Type==CARD_OBJECT) {
|
||
pEntry->Attribute=STREAM_OBJECT;
|
||
pEntry->SubAttribute=PARA_OBJECT;
|
||
}
|
||
else if(my.Type>CARD_OBJECT) {
|
||
pEntry->Attribute=TABLE_OBJECT;
|
||
pEntry->SubAttribute=my.Type-CARD_OBJECT;
|
||
}
|
||
}
|
||
}
|
||
void CSlfIO::GetObjectAttribute(int index,short* Attribute, short* SubAttribute)
|
||
{
|
||
if(IsWis) return GetWisObjectAttribute(index,Attribute,SubAttribute);
|
||
else return GetSlfObjectAttribute(index,Attribute,SubAttribute);
|
||
}
|
||
bool CSlfIO::GetObjectAttribute(const char* name,short* Attribute, short* SubAttribute)
|
||
{
|
||
if(IsWis) return GetWisObjectAttribute(name,Attribute,SubAttribute);
|
||
else return GetSlfObjectAttribute(name,Attribute,SubAttribute);
|
||
}
|
||
//Channel Operations
|
||
int CSlfIO::OpenChannel(const char *name)
|
||
{
|
||
if(IsWis) return OpenWisChannel(name);
|
||
else return OpenSlfChannel(name);
|
||
}
|
||
int CSlfIO::OpenChannel(const char *namee,short Attribute)
|
||
{
|
||
if(IsWis) return OpenWisChannel(namee,Attribute);
|
||
else return OpenSlfChannel(namee,Attribute);
|
||
}
|
||
DWORD CSlfIO::ComputerChannelLength(Slf_CHANNEL *pInfo,unsigned char nDimension)
|
||
{
|
||
return ComputerWisChannelLength(pInfo,nDimension);
|
||
}
|
||
DWORD CSlfIO::ComputerChannelLength(int index)
|
||
{
|
||
if(IsWis) return ComputerWisChannelLength(index);
|
||
else return ComputerSlfChannelLength(index);
|
||
}
|
||
int CSlfIO::GetChannelDefaultValue(Slf_CHANNEL* pInfo,unsigned char nDimension,char* buffer,DWORD buflen)
|
||
{
|
||
return GetWisChannelDefaultValue(pInfo,nDimension,buffer,buflen);
|
||
}
|
||
bool CSlfIO::SetChannelPointNum(int index, DWORD nPointNum, DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
|
||
{
|
||
return SetWisChannelPointNum(index,nPointNum,samples1,samples2,samples3,samples4);
|
||
}
|
||
DWORD CSlfIO::GetChannelPointNum(int index,DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
|
||
{
|
||
return GetWisChannelPointNum(index,samples1,samples2,samples3,samples4);
|
||
}
|
||
int CSlfIO::CreateChannel(short SubAttribute,const char *namee,Slf_CHANNEL* pInfo,bool bFailExist)
|
||
{
|
||
return CreateWisChannel(SubAttribute,namee,pInfo,bFailExist);
|
||
}
|
||
DWORD CSlfIO::SeekChannel(int index,DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
|
||
{
|
||
return SeekWisChannel(index,samples1,samples2,samples3,samples4);
|
||
}
|
||
DWORD CSlfIO::WriteChannel(int index,char* buffer,DWORD num, DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
|
||
{
|
||
return WriteWisChannel(index,buffer,num,samples1,samples2,samples3,samples4);
|
||
}
|
||
DWORD CSlfIO::ReadChannel(int index,char* buffer,DWORD num, DWORD samples1,DWORD samples2,DWORD samples3,DWORD samples4)
|
||
{
|
||
return ReadWisChannel(index,buffer,num,samples1,samples2,samples3,samples4);
|
||
}
|
||
bool CSlfIO::ExpandChannel(int index, unsigned char nDimension, DWORD nSamples, DWORD nTopSamples)
|
||
{
|
||
return ExpandWisChannel(index,nDimension,nSamples,nTopSamples);
|
||
}
|
||
bool CSlfIO::MoveChannel(int index, unsigned char nDimension, DWORD nStart, int nMove, DWORD nTotal)
|
||
{
|
||
return MoveWisChannel(index,nDimension,nStart,nMove,nTotal);
|
||
}
|
||
bool CSlfIO::OrderChannel(int index, unsigned char nDimension, int nMethod)
|
||
{
|
||
return OrderWisChannel(index,nDimension,nMethod);
|
||
}
|
||
bool CSlfIO::CorrectChannel(int index, unsigned char nDimension, float delta)
|
||
{
|
||
return CorrectWisChannel(index,nDimension,delta);
|
||
}
|
||
void CSlfIO::ChannelResamples(int index,float newDelta)
|
||
{
|
||
if(IsWis) return WisChannelResamples(index,newDelta);
|
||
else return SlfTableResamples(index,newDelta);
|
||
}
|
||
//Table Opeartions
|
||
|
||
int CSlfIO::OpenTable(const char*namee)
|
||
{
|
||
if(IsWis) return OpenWisTable(namee);
|
||
else return OpenSlfTable(namee);
|
||
}
|
||
int CSlfIO::CreateTable(short SubAttribute,const char* namee,DWORD length,bool bFailExist)
|
||
{
|
||
if(IsWis) return CreateWisTable(SubAttribute-CARD_OBJECT,namee,length,bFailExist);
|
||
else return CreateSlfTable(SubAttribute,namee,NULL,length,NULL,bFailExist);
|
||
}
|
||
int CSlfIO::CreateTable(short Attribute,const char* name,const char* hzname,DWORD FieldNum,Slf_OBJECT_FIELD *pField,bool bFailExist)
|
||
{
|
||
if(IsWis) {
|
||
int index=CreateWisTable(Attribute,name,0,bFailExist);
|
||
if(index>-1) {
|
||
Slf_TABLE_FIELD *pTable_Field=new Slf_TABLE_FIELD[FieldNum+1];
|
||
for(int i=0;i<FieldNum;i++) {
|
||
strncpy(pTable_Field[i].Name,pField[i].Name,16);
|
||
strncpy(pTable_Field[i].HZName,pField[i].HZName,16);
|
||
strncpy(pTable_Field[i].Unit,pField[i].Unit,16);
|
||
strncpy(pTable_Field[i].HZUnit,pField[i].HZUnit,16);
|
||
pTable_Field[i].RepCode=pField[i].RepCode;
|
||
pTable_Field[i].Length=pField[i].CodeLength;
|
||
pTable_Field[i].Reserved=0;
|
||
}
|
||
SetWisTableHead(index,0,FieldNum,pTable_Field);
|
||
delete pTable_Field;
|
||
}
|
||
return index;
|
||
}
|
||
else return CreateSlfTable(Attribute,name,hzname,FieldNum,pField,bFailExist);
|
||
}
|
||
bool CSlfIO::SeekTable(int index, int OffsetCount, DWORD dwMoveMode)
|
||
{
|
||
if(IsWis) return SeekWisTable(index,OffsetCount,dwMoveMode);
|
||
else return SeekSlfTable(index,OffsetCount,dwMoveMode);
|
||
}
|
||
int CSlfIO::GetTableRecordCount(int index)
|
||
{
|
||
if(IsWis) return GetWisTableRecordCount(index);
|
||
else return GetSlfTableRecordCount(index);
|
||
}
|
||
int CSlfIO::GetTableFieldCount(int index)
|
||
{
|
||
if(IsWis) return GetWisTableFieldCount(index);
|
||
else return GetSlfTableFieldCount(index);
|
||
}
|
||
int CSlfIO::SetTableHead(int index,DWORD RecordCount,DWORD FieldCount,Slf_TABLE_FIELD *FieldInfo)
|
||
{
|
||
if(IsWis) return SetWisTableHead(index,RecordCount,FieldCount,FieldInfo);
|
||
else {
|
||
Slf_OBJECT_FIELD *pf=new Slf_OBJECT_FIELD[FieldCount];
|
||
QString strMojibake = "屯"; //乱码判断
|
||
QByteArray ArrayMojibake = strMojibake.toLocal8Bit().data();
|
||
for(int i=0;i<FieldCount;i++) {
|
||
pf[i].ArrayNum=1;
|
||
pf[i].CodeLength=FieldInfo[i].Length;
|
||
pf[i].RepCode=FieldInfo[i].RepCode;
|
||
pf[i].DefVal=-9999.0;
|
||
|
||
if(strncmp(FieldInfo[i].Unit,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].Unit,"");
|
||
if(strncmp(FieldInfo[i].HZName,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].HZName,FieldInfo[i].Name);
|
||
if(strncmp(FieldInfo[i].HZUnit,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].HZUnit,FieldInfo[i].Unit);
|
||
|
||
int len=sizeof(pf[i].Name);
|
||
if(len>strlen(FieldInfo[i].Name)) len=strlen(FieldInfo[i].Name);
|
||
strncpy(pf[i].Name,FieldInfo[i].Name,len);
|
||
pf[i].Name[len]=0;
|
||
len=sizeof(pf[i].HZName);
|
||
if(len>strlen(FieldInfo[i].HZName)) len=strlen(FieldInfo[i].HZName);
|
||
strncpy(pf[i].HZName,FieldInfo[i].HZName,len);
|
||
pf[i].HZName[len]=0;
|
||
len=sizeof(pf[i].Unit);
|
||
if(len>strlen(FieldInfo[i].Unit)) len=strlen(FieldInfo[i].Unit);
|
||
strncpy(pf[i].Unit,FieldInfo[i].Unit,len);
|
||
pf[i].Unit[len]=0;
|
||
|
||
len=sizeof(pf[i].HZUnit);
|
||
if(len>strlen(FieldInfo[i].HZUnit)) len=strlen(FieldInfo[i].HZUnit);
|
||
strncpy(pf[i].HZUnit,FieldInfo[i].HZUnit,len);
|
||
pf[i].HZUnit[len]=0;
|
||
|
||
*(DWORD *)&pf[i].Reserved=FieldInfo[i].Reserved;
|
||
pf[i].SamplePoint=1;
|
||
pf[i].Rlev=1;
|
||
pf[i].Start=1;
|
||
pf[i].Vmax=-99999;
|
||
pf[i].Vmin=99999;
|
||
pf[i].Sequence=0;
|
||
}
|
||
SetSlfTableHead(index,RecordCount,FieldCount,pf);
|
||
delete []pf;
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
bool CSlfIO::SetTableRecordCount(int index,int Count)
|
||
{
|
||
if(IsWis) return SetWisTableRecordCount(index,Count);
|
||
else return SetSlfTableRecordCount(index,Count);
|
||
}
|
||
bool CSlfIO::ExpandTable(int index,DWORD BlockNum)
|
||
{
|
||
if(IsWis) return ExpandWisTable(index,BlockNum);
|
||
else return ExpandSlfTable(index,BlockNum);
|
||
}
|
||
|
||
bool CSlfIO::SetTableFieldInfo(int index,Slf_TABLE_FIELD *FieldInfo)
|
||
{
|
||
if(index<0) return 0;
|
||
if(IsWis) return SetWisTableFieldInfo(index,FieldInfo);
|
||
else {
|
||
int FieldCount=m_SlfObjectEntry[index].FieldNum;
|
||
Slf_OBJECT_FIELD *pf=new Slf_OBJECT_FIELD[FieldCount];
|
||
GetSlfTableFieldInfo(index,pf);
|
||
QString strMojibake = "屯"; //乱码判断
|
||
QByteArray ArrayMojibake = strMojibake.toLocal8Bit().data();
|
||
for(int i=0;i<FieldCount;i++) {
|
||
|
||
int len=strlen(FieldInfo[i].Name);
|
||
if(len>sizeof(pf[i].Name)) len=sizeof(pf[i].Name);
|
||
strncpy(pf[i].Name,FieldInfo[i].Name,len);
|
||
pf[i].Name[len]=0;
|
||
|
||
if(strncmp(FieldInfo[i].HZName,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].HZName,FieldInfo[i].Name);
|
||
|
||
len=strlen(FieldInfo[i].HZName);
|
||
if(len>sizeof(pf[i].HZName)) len=sizeof(pf[i].HZName);
|
||
strncpy(pf[i].HZName,FieldInfo[i].HZName,sizeof(pf[i].HZName));
|
||
pf[i].HZName[len]=0;
|
||
if(strncmp(FieldInfo[i].Unit,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].Unit,"");
|
||
|
||
len=strlen(FieldInfo[i].Unit);
|
||
if(len>sizeof(pf[i].Unit)) len=sizeof(pf[i].Unit);
|
||
strncpy(pf[i].Unit,FieldInfo[i].Unit,sizeof(pf[i].Unit));
|
||
pf[i].Unit[len]=0;
|
||
|
||
if(strncmp(FieldInfo[i].HZUnit,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].HZUnit,FieldInfo[i].Unit);
|
||
|
||
len=strlen(FieldInfo[i].HZUnit);
|
||
if(len>sizeof(pf[i].HZUnit)) len=sizeof(pf[i].HZUnit);
|
||
strncpy(pf[i].HZUnit,FieldInfo[i].HZUnit,sizeof(pf[i].HZUnit));
|
||
pf[i].HZUnit[len]=0;
|
||
}
|
||
SetSlfTableFieldInfo(index,pf,FALSE);
|
||
delete []pf;
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
bool CSlfIO::GetTableFieldInfo(int index,Slf_TABLE_FIELD *FieldInfo)
|
||
{
|
||
memset(FieldInfo,0,sizeof(Slf_TABLE_FIELD));
|
||
if(index<0) return 0;
|
||
if(IsWis) return GetWisTableFieldInfo(index,FieldInfo);
|
||
else {
|
||
int FieldCount=m_SlfObjectEntry[index].FieldNum;
|
||
Slf_OBJECT_FIELD *pf=new Slf_OBJECT_FIELD[FieldCount];
|
||
memset(pf,0,sizeof(Slf_OBJECT_FIELD)*FieldCount);
|
||
GetSlfTableFieldInfo(index,pf);
|
||
QString strMojibake = "屯"; //乱码判断
|
||
QByteArray ArrayMojibake = strMojibake.toLocal8Bit().data();
|
||
for(int i=0;i<FieldCount;i++) {
|
||
FieldInfo[i].Length=pf[i].CodeLength;
|
||
FieldInfo[i].RepCode=pf[i].RepCode;
|
||
|
||
strncpy(FieldInfo[i].Name,pf[i].Name,sizeof(FieldInfo[i].Name));
|
||
|
||
strncpy(FieldInfo[i].HZName,pf[i].HZName,sizeof(FieldInfo[i].HZName));
|
||
if(strncmp(FieldInfo[i].HZName,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].HZName,FieldInfo[i].Name);
|
||
|
||
if(strncmp(FieldInfo[i].Unit,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].Unit,"");
|
||
strncpy(FieldInfo[i].Unit,pf[i].Unit,sizeof(FieldInfo[i].Unit));
|
||
|
||
strncpy(FieldInfo[i].HZUnit,pf[i].HZUnit,sizeof(FieldInfo[i].HZUnit));
|
||
|
||
if(strncmp(FieldInfo[i].HZUnit,ArrayMojibake.data()/*"屯"*/,2)==0) strcpy(FieldInfo[i].HZUnit,FieldInfo[i].Unit);
|
||
FieldInfo[i].Reserved=*(DWORD *)&pf[i].Reserved;
|
||
}
|
||
delete []pf;
|
||
return 1;
|
||
}
|
||
}
|
||
int CSlfIO::GetTableRecordLength(int index)
|
||
{
|
||
if(IsWis) return GetWisTableRecordLength(index);
|
||
else return GetSlfTableRecordLength(index);
|
||
}
|
||
int CSlfIO::ReadTable(int index, int RecNo, void *buffer)
|
||
{
|
||
if(IsWis) return ReadWisTable(index,RecNo,buffer);
|
||
else {
|
||
return ReadSlfTable(index, RecNo, buffer,RecNo-1);
|
||
}
|
||
}
|
||
int CSlfIO::WriteTable(int index, int RecNo, void *buffer)
|
||
{
|
||
if(IsWis) return WriteWisTable(index,RecNo,buffer);
|
||
else return WriteSlfTable(index,RecNo,buffer,RecNo-1);
|
||
}
|
||
|
||
//Stream Operations
|
||
int CSlfIO::OpenStream(const char* namee)
|
||
{
|
||
if(IsWis) return OpenWisStream(namee);
|
||
else return OpenSlfStream(namee);
|
||
}
|
||
int CSlfIO::CreateStream(short SubAttribute,const char *namee,DWORD length,bool bFailExist)
|
||
{
|
||
if(IsWis) return CreateWisStream(SubAttribute,namee,length,bFailExist);
|
||
else return CreateSlfStream(SubAttribute,namee,length,bFailExist);
|
||
}
|
||
bool CSlfIO::SetStreamLength(int index, DWORD length)
|
||
{
|
||
if(IsWis) return SetWisStreamLength(index,length);
|
||
else return SetSlfStreamLength(index,length);
|
||
}
|
||
bool CSlfIO::ExpandStream(int index, DWORD BlockNum)
|
||
{
|
||
if(IsWis) return ExpandWisStream(index,BlockNum);
|
||
else return ExpandSlfStream(index,BlockNum);
|
||
}
|
||
bool CSlfIO::SeekStream(int index, int lMove, DWORD dwMoveMode)
|
||
{
|
||
if(IsWis) return SeekWisStream(index,lMove,dwMoveMode);
|
||
else return SeekSlfStream(index,lMove,dwMoveMode);
|
||
}
|
||
bool CSlfIO::ReadStream(int index, DWORD length, LPDWORD lpBytesRead, char *buffer)
|
||
{
|
||
if(IsWis) return ReadWisStream(index,length,lpBytesRead,buffer);
|
||
else return ReadSlfStream(index,length,lpBytesRead,buffer);
|
||
}
|
||
bool CSlfIO::WriteStream(int index, DWORD length, LPDWORD lpBytesWrite, const char *buffer)
|
||
{
|
||
if(IsWis) return WriteWisStream(index,length,lpBytesWrite,buffer);
|
||
else return WriteSlfStream(index,length,lpBytesWrite,buffer);
|
||
}
|
||
DWORD CSlfIO::GetStreamLength(int index)
|
||
{
|
||
if(IsWis) return GetWisStreamLength(index);
|
||
else return GetSlfStreamLength(index);
|
||
}
|
||
DWORD CSlfIO::GetObjectLength(char *name)
|
||
{
|
||
if(IsWis) return GetWisObjectLength(name);
|
||
else return GetSlfTableLength(name);
|
||
}
|
||
bool CSlfIO::CopyObjectToMem(Slf_OBJECT_ENTRY *my,char *name,char *buffer,int Len)
|
||
{
|
||
if(IsWis) return CopyWisObjectToMem(my,name,buffer,Len);
|
||
else {
|
||
Slf_TABLE_MESSAGE ss;
|
||
return CopySlfObjectToMem(&ss,name,buffer,Len);
|
||
}
|
||
}
|
||
bool CSlfIO::CopyFromFile(CSlfIO &Source,char *Name,char *NewObject)
|
||
{
|
||
if(IsWis) return CopyFromWisFile(Source,Name,NewObject);
|
||
else return CopyFromSLFFile(Source,Name,NewObject);
|
||
}
|
||
bool CSlfIO::CopyFromFile(CSlfIO &Source,char *Name)
|
||
{
|
||
if(IsWis) return CopyFromWisFile(Source,Name);
|
||
else return CopyFromSLFFile(Source,Name);
|
||
}
|
||
int CSlfIO::OpenSlfTable(int index,short att)
|
||
{
|
||
if(index<0) return -1;
|
||
short Source_Attribute=GetObjectType(index);
|
||
if(att!=-1&&Source_Attribute!=att) {
|
||
return -1;
|
||
}
|
||
if(index>-1) {
|
||
if(!Slf_Info_Head[index]) {
|
||
Slf_Info_Head[index]=new char[sizeof(Slf_TABLE_MESSAGE)];
|
||
}
|
||
Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
|
||
temp1->Table=m_SlfObjectEntry[index];
|
||
Slf_OBJECT_FIELD *FieldInfo=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
|
||
GetSlfTableFieldInfo(index,FieldInfo);
|
||
temp1->pField=FieldInfo;
|
||
}
|
||
return index;
|
||
}
|
||
int CSlfIO::OpenSlfTable(const char*name,short att)
|
||
{
|
||
int index=FindSlfObjectIndex(name);
|
||
if(index<0) return -1;
|
||
return OpenSlfTable(index,att);
|
||
}
|
||
int CSlfIO::CreateSlfTable(short Attribute,const char* name,const char* hzname,DWORD FieldNum,Slf_OBJECT_FIELD *pField,bool bFailExist)
|
||
{
|
||
int index=FindSlfObjectIndex(name);
|
||
if(index>-1) return index;
|
||
index=m_SlfHead.TableNumber;
|
||
m_SlfHead.TableNumber++;
|
||
WriteSlfHead();
|
||
m_SlfObjectEntry[index].RecondNum=1;
|
||
int len=strlen(name);
|
||
if(len>=64) len=63;
|
||
strncpy(m_SlfObjectEntry[index].Name,name,len);
|
||
m_SlfObjectEntry[index].Name[len]=0;
|
||
if(!hzname) {
|
||
strcpy(m_SlfObjectEntry[index].HZName,m_SlfObjectEntry[index].Name);
|
||
}
|
||
else {
|
||
int len=strlen(hzname);
|
||
if(len>=64) len=63;
|
||
strncpy(m_SlfObjectEntry[index].HZName,hzname,len);
|
||
m_SlfObjectEntry[index].HZName[len]=0;
|
||
}
|
||
m_SlfObjectEntry[index].SerialID=0;// 2 所属系列代码
|
||
strcpy(m_SlfObjectEntry[index].DataSource,"create");// 20 数据来源
|
||
m_SlfObjectEntry[index].Type=Attribute;// 2 表类型
|
||
m_SlfObjectEntry[index].Status=0;// 2 表删除标志
|
||
m_SlfObjectEntry[index].FieldNum=FieldNum;// 4 字段个数
|
||
m_SlfObjectEntry[index].Position=mFile->size();
|
||
m_SlfObjectEntry[index].DataRecord[0].DataPosition=m_SlfObjectEntry[index].Position+sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[index].FieldNum;// 4 原始数据体存储的位置
|
||
m_SlfObjectEntry[index].DataRecord[0].DataRecordNum=0;
|
||
mFile->resize(m_SlfObjectEntry[index].DataRecord[0].DataPosition);
|
||
for(int i=0;i<10;i++) {
|
||
m_SlfObjectEntry[index].DataRecord[i+1].DataPosition=0;
|
||
m_SlfObjectEntry[index].DataRecord[i+1].DataRecordNum=0;
|
||
}
|
||
m_SlfObjectEntry[index].IsSave=0;// 2 是否自动备份原始数据
|
||
m_SlfObjectEntry[index].ChangeNum=1;// 2 修改次数
|
||
/////////////////////////////////////////////
|
||
//
|
||
Slf_TABLE_History*pHistory=new Slf_TABLE_History[m_SlfObjectEntry[index].ChangeNum];// 76 修改历史信息描述结构变量数组
|
||
|
||
// m_SlfObjectEntry[index].pSLF_TABLE_History=pHistory;
|
||
|
||
for(int i=0;i<m_SlfObjectEntry[index].ChangeNum;i++) {
|
||
pHistory[i].StartRecord=0;
|
||
pHistory[i].EndRecord=0;
|
||
pHistory[i].Time=0;
|
||
strcpy(pHistory[i].UserName,"ww");
|
||
}
|
||
|
||
delete pHistory;
|
||
if(!Slf_Info_Head[index]) Slf_Info_Head[index]=new char[sizeof(Slf_TABLE_MESSAGE)];
|
||
WriteSlfObjectEntry(index);
|
||
if(pField) {
|
||
Slf_OBJECT_FIELD *pFieldInfo=new Slf_OBJECT_FIELD[FieldNum];
|
||
memmove(pFieldInfo,pField,sizeof(Slf_OBJECT_FIELD)*FieldNum);
|
||
SetSlfTableFieldInfo(index,pFieldInfo);
|
||
}
|
||
return index;
|
||
}
|
||
bool CSlfIO:: WriteSlfHistory(int index,Slf_TABLE_History*pHistory)
|
||
{
|
||
if(index<0) return 0;
|
||
unsigned int POS=sizeof(Slf_FILE_HEAD)+index*m_SlfHead.TableMessageLength+sizeof(Slf_TABLE_ENTRY);
|
||
if(m_SlfObjectEntry[index].ChangeNum>0) POS+=(m_SlfObjectEntry[index].ChangeNum-1)*sizeof(Slf_TABLE_History);
|
||
mFile->seek(POS);//,QFile::begin
|
||
for(int i=0;i<m_SlfObjectEntry[index].ChangeNum;i++) {
|
||
mFile->write((char *)&pHistory[i],sizeof(Slf_TABLE_History));
|
||
}
|
||
mFile->flush();
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: CloseSlfTable(int index)
|
||
{
|
||
if(index<0) return false;
|
||
if(Slf_Info_Head[index]) {
|
||
Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
|
||
delete []temp1->pField;
|
||
delete temp1;
|
||
Slf_Info_Head[index]=NULL;
|
||
}
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: SeekSlfTable(int index, int OffsetCount, DWORD dwMoveMode)
|
||
{
|
||
return 1;
|
||
}
|
||
int CSlfIO:: GetSlfTableRecordCount(int index)
|
||
{
|
||
int rec=0;
|
||
for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
|
||
rec+=m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;
|
||
}
|
||
return rec;
|
||
}
|
||
int CSlfIO:: SetSlfTableHead(int index,DWORD REC,DWORD FieldNum,Slf_OBJECT_FIELD *field)
|
||
{
|
||
if(index<0) return 0;
|
||
if(!field) return 0;
|
||
m_SlfObjectEntry[index].FieldNum=FieldNum;
|
||
if(m_SlfHead.TableNumber<=0) {
|
||
mFile->resize(sizeof(Slf_FILE_HEAD)+m_SlfHead.MaxTableNumber*m_SlfHead.TableMessageLength);
|
||
m_SlfHead.TableNumber++;
|
||
WriteSlfHead();
|
||
}
|
||
unsigned int pos=mFile->size();
|
||
m_SlfObjectEntry[index].RecondNum=(REC>0?1:0);
|
||
m_SlfObjectEntry[index].Position=pos;
|
||
m_SlfObjectEntry[index].DataRecord[0].DataPosition=pos+FieldNum*sizeof(Slf_OBJECT_FIELD);
|
||
m_SlfObjectEntry[index].DataRecord[0].DataRecordNum=REC;
|
||
WriteSlfObjectEntry(index);
|
||
Slf_OBJECT_FIELD *pFieldInfo=new Slf_OBJECT_FIELD[FieldNum];
|
||
memmove(pFieldInfo,field,sizeof(Slf_OBJECT_FIELD)*FieldNum);
|
||
SetSlfTableFieldInfo(index,pFieldInfo);
|
||
pos=m_SlfObjectEntry[index].DataRecord[0].DataPosition+GetSlfTableRecordLength(index,field)*REC;
|
||
mFile->resize(pos);
|
||
mFile->flush();
|
||
return m_SlfHead.TableNumber;
|
||
}
|
||
bool CSlfIO:: SetSlfTableRecordCount(int index,int Count)
|
||
{
|
||
if(index<0) return 0;
|
||
int leng=GetSlfTableLength(index);
|
||
int rec=GetSlfTableRecordCount(index);
|
||
int reclen=GetSlfTableRecordLength(index);
|
||
int len=0;
|
||
if(rec>Count) {
|
||
len=rec;
|
||
}
|
||
else len=Count;
|
||
unsigned long long lenn=len*reclen;
|
||
char *buf=new char[lenn+1];
|
||
memset(buf,0,lenn);
|
||
if(leng) {
|
||
ReadSlfTable(index,rec,buf);
|
||
DiscardSlfObjectData(index,false);
|
||
}
|
||
WriteSlfTable(index,Count,buf);
|
||
delete buf;
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: ExpandSlfTable(int index,int RecNum)
|
||
{
|
||
if(m_SlfObjectEntry[index].RecondNum>10)
|
||
{
|
||
int rec=GetSlfTableRecordCount(index);
|
||
SetSlfTableRecordCount(index,rec);
|
||
}
|
||
if(RecNum<0) {
|
||
Slf_OBJECT_FIELD *FieldInfo=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
|
||
GetSlfTableFieldInfo(index,FieldInfo);
|
||
int reclen=GetSlfTableRecordLength(index,FieldInfo);
|
||
for(int i=m_SlfObjectEntry[index].RecondNum;i>0;i--) {
|
||
m_SlfObjectEntry[index].DataRecord[i].DataPosition=m_SlfObjectEntry[index].DataRecord[i-1].DataPosition;
|
||
m_SlfObjectEntry[index].DataRecord[i].DataRecordNum=m_SlfObjectEntry[index].DataRecord[i-1].DataRecordNum;
|
||
}
|
||
m_SlfObjectEntry[index].DataRecord[0].DataPosition=mFile->size();
|
||
m_SlfObjectEntry[index].DataRecord[0].DataRecordNum=-RecNum;
|
||
mFile->resize(m_SlfObjectEntry[index].DataRecord[0].DataPosition+m_SlfObjectEntry[index].DataRecord[0].DataRecordNum*reclen);
|
||
m_SlfObjectEntry[index].RecondNum++;
|
||
FieldInfo[0].Start+=RecNum*FieldInfo[0].Rlev;
|
||
SetSlfTableFieldInfo(index,FieldInfo);
|
||
delete FieldInfo;
|
||
WriteSlfObjectEntry(index);
|
||
}
|
||
else {
|
||
int reclen=GetSlfTableRecordLength(index);
|
||
m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataRecordNum=RecNum;
|
||
m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataPosition=mFile->size();
|
||
mFile->resize(m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataPosition+reclen*RecNum);
|
||
m_SlfObjectEntry[index].RecondNum++;
|
||
WriteSlfObjectEntry(index);
|
||
}
|
||
return 1;
|
||
}
|
||
int CSlfIO:: GetSlfTableFieldCount(int index)
|
||
{
|
||
if(index<0) return 0;
|
||
if(!m_SlfObjectEntry) return 0;
|
||
return m_SlfObjectEntry[index].FieldNum;
|
||
}
|
||
Slf_OBJECT_FIELD * CSlfIO:: GetSlfTableFieldInfo(int index)
|
||
{
|
||
Slf_OBJECT_FIELD *FieldInfo=NULL;
|
||
if(index<0) return NULL;
|
||
if(!Slf_Info_Head[index]){
|
||
Slf_Info_Head[index]=new char[sizeof(Slf_TABLE_MESSAGE)];
|
||
Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
|
||
FieldInfo=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
|
||
GetSlfTableFieldInfo(index,FieldInfo);
|
||
temp1->pField=FieldInfo;
|
||
}
|
||
else {
|
||
Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
|
||
FieldInfo=temp1->pField;
|
||
}
|
||
return FieldInfo;
|
||
}
|
||
bool CSlfIO:: GetSlfTableFieldInfo(int index,Slf_OBJECT_FIELD *FieldInfo)
|
||
{
|
||
if(index<0) return 0;
|
||
if(!FieldInfo) return 0;
|
||
mFile->seek(m_SlfObjectEntry[index].Position);//,QFile::begin
|
||
for(int i=0;i<m_SlfObjectEntry[index].FieldNum;i++) {
|
||
mFile->read((char *)&FieldInfo[i],sizeof(Slf_OBJECT_FIELD));
|
||
}
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: SetSlfTableFieldInfo(int index,Slf_OBJECT_FIELD *FieldInfo,bool SetNewFieldInfo)
|
||
{
|
||
if(index<0) return 0;
|
||
if(!FieldInfo) return 0;
|
||
mFile->seek(m_SlfObjectEntry[index].Position);//,QFile::begin
|
||
for(int i=0;i<m_SlfObjectEntry[index].FieldNum;i++) {
|
||
mFile->write((char *)&FieldInfo[i],sizeof(Slf_OBJECT_FIELD));
|
||
}
|
||
mFile->flush();
|
||
if(Slf_Info_Head[index]&&SetNewFieldInfo)
|
||
{
|
||
Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
|
||
temp1->pField=FieldInfo;
|
||
}
|
||
return 1;
|
||
}
|
||
int CSlfIO:: GetSlfTableRecordLength(int index,Slf_OBJECT_FIELD *FieldInfo)
|
||
{
|
||
if(index<0) return 0;
|
||
int reclen=0;
|
||
int Flag=0;
|
||
if(!FieldInfo) {
|
||
if(!Slf_Info_Head[index]){
|
||
if(m_SlfObjectEntry[index].FieldNum<0||m_SlfObjectEntry[index].FieldNum>1024) return 0;
|
||
FieldInfo=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
|
||
GetSlfTableFieldInfo(index,FieldInfo);
|
||
Flag=1;
|
||
}
|
||
else {
|
||
Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
|
||
FieldInfo=temp1->pField;
|
||
}
|
||
}
|
||
for(int i=0;i<m_SlfObjectEntry[index].FieldNum;i++)
|
||
{
|
||
if(FieldInfo[i].Sequence) continue;
|
||
reclen+=FieldInfo[i].ArrayNum*FieldInfo[i].CodeLength*FieldInfo[i].SamplePoint;
|
||
}
|
||
if(Flag) delete []FieldInfo;
|
||
return reclen;
|
||
}
|
||
int CSlfIO:: GetSlfTableFieldOffset(int index,int FieldNo,Slf_OBJECT_FIELD *FieldInfo)
|
||
{
|
||
int reclen=0;
|
||
int Flag=0;
|
||
if(!FieldInfo) {
|
||
if(!Slf_Info_Head[index]){
|
||
FieldInfo=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
|
||
GetSlfTableFieldInfo(index,FieldInfo);
|
||
Flag=1;
|
||
}
|
||
else {
|
||
Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
|
||
FieldInfo=temp1->pField;
|
||
}
|
||
}
|
||
for(int i=0;i<FieldNo;i++) {
|
||
if(FieldInfo[i].Sequence) continue;
|
||
reclen+=FieldInfo[i].ArrayNum*FieldInfo[i].CodeLength*FieldInfo[i].SamplePoint;
|
||
}
|
||
if(Flag) delete []FieldInfo;
|
||
return reclen;
|
||
}
|
||
|
||
int CSlfIO:: ReadSlfTable(int index, int RecNum, void *buffer,int FirstRec)
|
||
{
|
||
int i=0;
|
||
if(RecNum<=0) {
|
||
RecNum=0;
|
||
for(i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
|
||
RecNum+=m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;
|
||
}
|
||
}
|
||
if(!buffer) return RecNum;
|
||
if(FirstRec<0) {
|
||
RecNum-=FirstRec;
|
||
FirstRec=-FirstRec;
|
||
}
|
||
unsigned int point;
|
||
int reclen=GetSlfTableRecordLength(index);
|
||
int len=0,pos=0;
|
||
int rec=0,rec1=0,rec2=0,rec3=0;
|
||
for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
|
||
rec1=rec;
|
||
rec3=rec;
|
||
rec+=m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;
|
||
rec2=rec;
|
||
if(rec<FirstRec) {
|
||
continue;
|
||
}
|
||
if(rec1<FirstRec) rec1=FirstRec;
|
||
if(rec>RecNum) {
|
||
rec=RecNum;
|
||
}
|
||
point=m_SlfObjectEntry[index].DataRecord[i].DataPosition+(rec1-rec3)*reclen;
|
||
mFile->seek(point);//,QFile::begin
|
||
char *buff=(char *)buffer;
|
||
len=(rec-rec1)*reclen;
|
||
mFile->read((char *)&buff[pos],len);
|
||
pos+=len;
|
||
if(rec2>RecNum) break;
|
||
}
|
||
return RecNum-FirstRec;
|
||
}
|
||
int CSlfIO:: DeleteSlfTableRecord(int index,int RecNum,int FirstRec)
|
||
{
|
||
unsigned int len=GetSlfTableLength(index);
|
||
int reclen=GetSlfTableRecordLength(index);
|
||
int rec=GetSlfTableRecordCount(index);
|
||
char *buff=new char[len+1];
|
||
ReadSlfTable(index,rec,buff);
|
||
SetSlfTableRecordCount(index,rec-(RecNum-FirstRec));
|
||
memmove(&buff[FirstRec*reclen],&buff[RecNum*reclen],(rec-RecNum)*reclen);
|
||
WriteSlfTable(index,rec-(RecNum-FirstRec),buff);
|
||
delete []buff;
|
||
return 1;
|
||
}
|
||
|
||
int CSlfIO:: ReadSlfTableFieldData(int index,int FieldNo,int RecNo,void *buffer,int FirstRec,int Count)
|
||
{
|
||
if(index<0) return 0;
|
||
Slf_OBJECT_FIELD *FieldInfo=GetSlfTableFieldInfo(index);
|
||
unsigned int point,pos=0;
|
||
int reclen=GetSlfTableRecordLength(index,FieldInfo);
|
||
int recpos=GetSlfTableFieldOffset(index,FieldNo,FieldInfo);
|
||
int len=FieldInfo[FieldNo].CodeLength*FieldInfo[FieldNo].SamplePoint*FieldInfo[FieldNo].ArrayNum,rec=0;
|
||
if(Count) len=Count*FieldInfo[FieldNo].CodeLength;
|
||
for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
|
||
for(int j=0;j<m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;j++) {
|
||
if(rec>=FirstRec&&rec<RecNo) {
|
||
point=m_SlfObjectEntry[index].DataRecord[i].DataPosition+j*reclen+recpos;
|
||
mFile->seek(point);
|
||
char *buff=(char *)buffer;
|
||
mFile->read((char *)&buff[pos],len);
|
||
pos+=len;
|
||
}
|
||
rec++;
|
||
}
|
||
}
|
||
return RecNo-FirstRec;
|
||
}
|
||
int CSlfIO:: FindSlfFieldNo(int index,char *FieldName)
|
||
{
|
||
if(index<0) return -1;
|
||
Slf_OBJECT_FIELD *FieldInfo=GetSlfTableFieldInfo(index);
|
||
for(int i=0;i<m_SlfObjectEntry[index].FieldNum;i++) {
|
||
if(stricmp(FieldInfo[i].Name,FieldName)==0||stricmp(FieldInfo[i].HZName,FieldName)==0) {
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
int CSlfIO:: WriteSlfTableFieldData(int index,int FieldNo,int RecNum,void *buffer,int FirstRec,int Count)
|
||
{
|
||
if(index<0) return 0;
|
||
int ma=GetSlfTableRecordCount(index);
|
||
if(RecNum>ma) SetSlfTableRecordCount(index,RecNum);
|
||
Slf_OBJECT_FIELD *FieldInfo=GetSlfTableFieldInfo(index);
|
||
unsigned int point,pos=0;
|
||
int reclen=GetSlfTableRecordLength(index,FieldInfo);
|
||
int recpos=GetSlfTableFieldOffset(index,FieldNo,FieldInfo);
|
||
int len=FieldInfo[FieldNo].CodeLength*FieldInfo[FieldNo].SamplePoint*FieldInfo[FieldNo].ArrayNum,rec=0;
|
||
if(Count) len=Count*FieldInfo[FieldNo].CodeLength;
|
||
for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
|
||
for(int j=0;j<m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;j++) {
|
||
if(rec>RecNum) break;
|
||
if(rec>=FirstRec&&rec<RecNum) {
|
||
point=m_SlfObjectEntry[index].DataRecord[i].DataPosition+j*reclen+recpos;
|
||
mFile->seek(point);//QFile::begin
|
||
char *buff=(char *)buffer;
|
||
mFile->write((char *)&buff[pos],len);
|
||
pos+=len;
|
||
}
|
||
rec++;
|
||
}
|
||
}
|
||
mFile->flush();
|
||
return RecNum-FirstRec;
|
||
}
|
||
|
||
int CSlfIO:: WriteSlfTable(int index, int EndRec, void *buffer,int FirstRec)
|
||
{
|
||
if(!buffer) return 0;
|
||
int reclen=GetSlfTableRecordLength(index);
|
||
if(FirstRec<0) {
|
||
if(m_SlfObjectEntry[index].RecondNum>10) {
|
||
int rec=GetSlfTableRecordCount(index);
|
||
SetSlfTableRecordCount(index,rec);
|
||
}
|
||
Slf_OBJECT_FIELD *FieldInfo=GetSlfTableFieldInfo(index);
|
||
for(int i=m_SlfObjectEntry[index].RecondNum;i>0;i--) {
|
||
m_SlfObjectEntry[index].DataRecord[i].DataPosition=m_SlfObjectEntry[index].DataRecord[i-1].DataPosition;
|
||
m_SlfObjectEntry[index].DataRecord[i].DataRecordNum=m_SlfObjectEntry[index].DataRecord[i-1].DataRecordNum;
|
||
}
|
||
m_SlfObjectEntry[index].DataRecord[0].DataPosition=mFile->size();
|
||
m_SlfObjectEntry[index].DataRecord[0].DataRecordNum=-FirstRec;
|
||
mFile->resize(m_SlfObjectEntry[index].DataRecord[0].DataPosition+m_SlfObjectEntry[index].DataRecord[0].DataRecordNum*reclen);//,CFile::begin);
|
||
m_SlfObjectEntry[index].RecondNum++;
|
||
WriteSlfObjectEntry(index);
|
||
FieldInfo[0].Start+=FirstRec*FieldInfo[0].Rlev;
|
||
SetSlfTableFieldInfo(index,FieldInfo);
|
||
EndRec=EndRec-FirstRec;
|
||
FirstRec=0;
|
||
}
|
||
int rec=GetSlfTableRecordCount(index);
|
||
if(EndRec>rec) {
|
||
if(m_SlfObjectEntry[index].RecondNum>10) {
|
||
SetSlfTableRecordCount(index,rec);
|
||
}
|
||
if(rec<=0) m_SlfObjectEntry[index].RecondNum=0;
|
||
m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataPosition=mFile->size();
|
||
m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataRecordNum=EndRec-rec;
|
||
mFile->resize(m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataPosition+m_SlfObjectEntry[index].DataRecord[m_SlfObjectEntry[index].RecondNum].DataRecordNum*reclen);//,CFile::begin);
|
||
m_SlfObjectEntry[index].RecondNum++;
|
||
WriteSlfObjectEntry(index);
|
||
}
|
||
unsigned int point;
|
||
int len=0,pos=0;
|
||
rec=0;
|
||
int rec1=0,rec2=0,rec3=0;
|
||
for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
|
||
rec1=rec;
|
||
rec3=rec;
|
||
rec+=m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;
|
||
rec2=rec;
|
||
if(rec<FirstRec) {
|
||
continue;
|
||
}
|
||
if(rec1<FirstRec) rec1=FirstRec;
|
||
if(rec>EndRec) {
|
||
rec=EndRec;
|
||
}
|
||
len=(rec-rec1)*reclen;
|
||
point=m_SlfObjectEntry[index].DataRecord[i].DataPosition+(rec1-rec3)*reclen;
|
||
mFile->seek(point);//,QFile::begin
|
||
char *buff=(char *)buffer;
|
||
mFile->write((char *)&buff[pos],len);
|
||
pos+=len;
|
||
if(rec2>EndRec) break;
|
||
}
|
||
mFile->flush();
|
||
return EndRec-FirstRec;
|
||
}
|
||
void CSlfIO:: InitSlf(int BlockLen,int MaxObjectNumber, int MachineType)
|
||
{
|
||
/////////////////////////////////////
|
||
// set head
|
||
memset(&m_SlfHead,0,sizeof(Slf_HEAD));
|
||
strcpy(m_SlfHead.Version,"Slf 3.1");
|
||
m_SlfHead.BinaryType=MachineType;// 4 二进制数据标准
|
||
m_SlfHead.TableNumber=0;// 4 已存储表个数
|
||
m_SlfHead.MaxTableNumber=MaxObjectNumber;// 4 预留最大表个数
|
||
// m_SlfHead.FileSize;// 4 文件大小
|
||
m_SlfHead.TableMessageLength=BlockLen;// 4 表基本信息长度
|
||
struct tm *newtime;
|
||
time_t ltime;
|
||
char buff[80];
|
||
time( <ime );
|
||
|
||
// Obtain coordinated universal time:
|
||
m_SlfHead.TimeCreate = (__time32_t)ltime ; // C4996
|
||
// Note: _gmtime64 is deprecated; consider using _gmtime64_s
|
||
strcpy(m_SlfHead.WellMessage.Reserved,"WANGWEI");
|
||
if(!Slf_Info_Head) Slf_Info_Head=new char *[m_SlfHead.MaxTableNumber];
|
||
for(int i=0;i<m_SlfHead.MaxTableNumber;i++) Slf_Info_Head[i]=NULL;
|
||
|
||
if(!m_SlfObjectEntry)m_SlfObjectEntry=new Slf_TABLE_ENTRY[m_SlfHead.MaxTableNumber];
|
||
memset(m_SlfObjectEntry,0,sizeof(Slf_TABLE_ENTRY)*m_SlfHead.MaxTableNumber);
|
||
WriteSlfHead();
|
||
WriteSlfObjectEntry();
|
||
}
|
||
void CSlfIO:: SetSlfMessage(Slf_FILE_MESSAGE mssage)
|
||
{
|
||
memmove(&m_SlfHead.WellMessage,&mssage,sizeof(Slf_FILE_MESSAGE));
|
||
/*
|
||
m_SlfHead.WellMessage.Kelly=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Kelly));
|
||
m_SlfHead.WellMessage.Bit_Diameter[0]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Diameter[0]));
|
||
m_SlfHead.WellMessage.Bit_Depth[0]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Depth[0] ));
|
||
m_SlfHead.WellMessage.Bit_Diameter[1]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Diameter[1] ));
|
||
m_SlfHead.WellMessage.Bit_Depth[1]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Depth[1] ));
|
||
m_SlfHead.WellMessage.Bit_Diameter[2]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Diameter[2]));
|
||
m_SlfHead.WellMessage.Bit_Depth[2]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Depth[2] ));
|
||
m_SlfHead.WellMessage.Bit_Diameter[3]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Diameter[3]));
|
||
m_SlfHead.WellMessage.Bit_Depth[3]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bit_Depth[3] ));
|
||
m_SlfHead.WellMessage.Bushing_Inside_Diameter[0]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Inside_Diameter[0]) );
|
||
m_SlfHead.WellMessage.Bushing_Detpth[0]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Detpth[0]));
|
||
m_SlfHead.WellMessage.Bushing_Inside_Diameter[1]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Inside_Diameter[1]) );
|
||
m_SlfHead.WellMessage.Bushing_Detpth[1]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Detpth[1]));
|
||
m_SlfHead.WellMessage.Bushing_Inside_Diameter[2]=(ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Inside_Diameter[2]) ));
|
||
m_SlfHead.WellMessage.Bushing_Detpth[2]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Detpth[2]));
|
||
m_SlfHead.WellMessage.Bushing_Outside_Diameter[0]=(ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Outside_Diameter[0])));
|
||
m_SlfHead.WellMessage.Bushing_Outside_Diameter[1]=(ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Outside_Diameter[1])));
|
||
m_SlfHead.WellMessage.Bushing_Outside_Diameter[2]=ConvertDataByString(QString::number(m_SlfHead.WellMessage.Bushing_Outside_Diameter[2]));
|
||
*/
|
||
WriteSlfHead();
|
||
}
|
||
void CSlfIO:: GetSlfMessage(Slf_FILE_MESSAGE &mssage)
|
||
{
|
||
if(strstr(m_SlfHead.Version,"Slf 3.0")) {
|
||
if(m_SlfHead.WellMessage.Xcoor==0&&m_SlfHead.WellMessage.Ycoor==0) {
|
||
// m_SlfHead.WellMessage.Xcoor=m_SlfHead.WellMessage.Xcoor1;
|
||
// m_SlfHead.WellMessage.Ycoor=m_SlfHead.WellMessage.Ycoor1;
|
||
}
|
||
}
|
||
memmove(mssage.AreaName,&m_SlfHead.WellMessage,sizeof(Slf_FILE_MESSAGE));
|
||
/*
|
||
mssage.Kelly=ConvertDataByFloat(mssage.Kelly).toFloat();
|
||
mssage.Bit_Diameter[0]=ConvertDataByFloat(mssage.Bit_Diameter[0] ).toFloat();
|
||
mssage.Bit_Depth[0]=ConvertDataByFloat(mssage.Bit_Depth[0] ).toFloat();
|
||
mssage.Bit_Diameter[1]=ConvertDataByFloat(mssage.Bit_Diameter[1] ).toFloat();
|
||
mssage.Bit_Depth[1]=ConvertDataByFloat(mssage.Bit_Depth[1] ).toFloat();
|
||
mssage.Bit_Diameter[2]=ConvertDataByFloat(mssage.Bit_Diameter[2]).toFloat();
|
||
mssage.Bit_Depth[2]=ConvertDataByFloat(mssage.Bit_Depth[2] ).toFloat();
|
||
mssage.Bit_Diameter[3]=ConvertDataByFloat(mssage.Bit_Diameter[3]).toFloat();
|
||
mssage.Bit_Depth[3]=ConvertDataByFloat(mssage.Bit_Depth[3] ).toFloat();
|
||
mssage.Bushing_Inside_Diameter[0]=ConvertDataByFloat(mssage.Bushing_Inside_Diameter[0] ).toFloat();
|
||
mssage.Bushing_Detpth[0]=ConvertDataByFloat(mssage.Bushing_Detpth[0]).toFloat();
|
||
mssage.Bushing_Inside_Diameter[1]=ConvertDataByFloat(mssage.Bushing_Inside_Diameter[1] ).toFloat();
|
||
mssage.Bushing_Detpth[1]=ConvertDataByFloat(mssage.Bushing_Detpth[1]).toFloat();
|
||
mssage.Bushing_Inside_Diameter[2]=(ConvertDataByFloat(mssage.Bushing_Inside_Diameter[2] )).toFloat();
|
||
mssage.Bushing_Detpth[2]=ConvertDataByFloat(mssage.Bushing_Detpth[2]).toFloat();
|
||
mssage.Bushing_Outside_Diameter[0]=(ConvertDataByFloat(mssage.Bushing_Outside_Diameter[0] )).toFloat();
|
||
mssage.Bushing_Outside_Diameter[1]=(ConvertDataByFloat(mssage.Bushing_Outside_Diameter[1] )).toFloat();
|
||
mssage.Bushing_Outside_Diameter[2]=ConvertDataByFloat(mssage.Bushing_Outside_Diameter[2] ).toFloat();
|
||
*/
|
||
}
|
||
int CSlfIO:: ReadSlfHead()
|
||
{
|
||
mFile->seek(0);
|
||
int len=sizeof(Slf_FILE_HEAD);
|
||
mFile->read((char *)&m_SlfHead,len);
|
||
return 1;
|
||
}
|
||
int CSlfIO:: WriteSlfHead()
|
||
{
|
||
mFile->seek(0);
|
||
if(m_SlfHead.MaxTableNumber<=0) {
|
||
AfxMessageBox("文件头错误！");
|
||
return 0;
|
||
|
||
}
|
||
mFile->write((char *)&m_SlfHead,sizeof(Slf_FILE_HEAD));
|
||
mFile->flush();
|
||
return 1;
|
||
}
|
||
int CSlfIO:: ReadSlfObjectEntry()
|
||
{
|
||
for(int i=0;i<m_SlfHead.TableNumber;i++) {
|
||
int a=sizeof(Slf_TABLE_ENTRY);
|
||
int x=mFile->pos();
|
||
mFile->seek(sizeof(Slf_FILE_HEAD)+i*m_SlfHead.TableMessageLength);
|
||
mFile->read((char *)&m_SlfObjectEntry[i],sizeof(Slf_TABLE_ENTRY));
|
||
}
|
||
return -1;
|
||
}
|
||
int CSlfIO:: WriteSlfObjectEntry()
|
||
{
|
||
for(int i=0;i<m_SlfHead.TableNumber;i++) {
|
||
WriteSlfObjectEntry(i);
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
bool CSlfIO:: OpenSlf(const char* LogName,unsigned int nOpenFlags,int BlockLen,int MaxObjectNumber, int MachineType)
|
||
{
|
||
strcpy(m_LogFileName,LogName);
|
||
return OpenSlf(nOpenFlags,BlockLen,MaxObjectNumber,MachineType);
|
||
}
|
||
bool CSlfIO::OpenSlf(unsigned int nOpenFlags,int BlockLen,int MaxObjectNumber, int MachineType)
|
||
{
|
||
IsWis=false;
|
||
if(nOpenFlags==modeCreate)
|
||
{
|
||
mFile=new QFile(m_LogFileName);
|
||
mFile->open(QIODevice::ReadWrite);
|
||
InitSlf(BlockLen, MaxObjectNumber, MachineType);
|
||
mFile->flush();
|
||
mFile->resize(sizeof(Slf_FILE_HEAD)+m_SlfHead.MaxTableNumber*m_SlfHead.TableMessageLength);//,CFile::begin);
|
||
return TRUE;
|
||
}
|
||
else {
|
||
QFile f;
|
||
if(f.exists(m_LogFileName)) {
|
||
mFile=new QFile(m_LogFileName);
|
||
mFile->open(QIODevice::ReadWrite);
|
||
ReadSlfHead();
|
||
/* if(m_SlfHead.MaxTableNumber<=0) {
|
||
m_SlfHead.MaxTableNumber=1024;
|
||
m_SlfHead.TableMessageLength=1024;
|
||
m_SlfHead.TableNumber=1024;
|
||
}
|
||
*/
|
||
if(m_SlfHead.MaxTableNumber<=0) {
|
||
InitSlf(BlockLen, MaxObjectNumber, MachineType);
|
||
mFile->flush();
|
||
mFile->resize(sizeof(Slf_FILE_HEAD)+m_SlfHead.MaxTableNumber*m_SlfHead.TableMessageLength);//,CFile::begin);
|
||
return true;
|
||
}
|
||
Slf_Info_Head=new char *[m_SlfHead.MaxTableNumber];
|
||
for(int i=0;i<m_SlfHead.MaxTableNumber;i++) Slf_Info_Head[i]=NULL;
|
||
|
||
m_SlfObjectEntry=new Slf_TABLE_ENTRY[m_SlfHead.MaxTableNumber];
|
||
memset(m_SlfObjectEntry,0,sizeof(Slf_TABLE_ENTRY)*m_SlfHead.MaxTableNumber);
|
||
|
||
ReadSlfObjectEntry();
|
||
for(int i=0;i<m_SlfHead.TableNumber;i++)
|
||
{
|
||
strupr(m_SlfObjectEntry[i].Name);
|
||
/* if(strlen(m_SlfObjectEntry[i].Name)==0)
|
||
{
|
||
int a=1;
|
||
m_SlfHead.TableNumber=i;
|
||
strcpy(m_SlfHead.Version,"Slf 3.1");
|
||
WriteSlfHead();
|
||
break;
|
||
}
|
||
*/
|
||
}
|
||
}
|
||
else {
|
||
mFile=new QFile(m_LogFileName);
|
||
mFile->open(QIODevice::ReadWrite);
|
||
InitSlf(BlockLen, MaxObjectNumber, MachineType);
|
||
mFile->flush();
|
||
mFile->resize(sizeof(Slf_FILE_HEAD)+m_SlfHead.MaxTableNumber*m_SlfHead.TableMessageLength);//,CFile::begin);
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
void CSlfIO:: GetSlfHead(Slf_FILE_HEAD* pHead)
|
||
{
|
||
*pHead=m_SlfHead;
|
||
// return -1;
|
||
}
|
||
DWORD CSlfIO::GetSlfTableLength(char *name)//长度
|
||
{
|
||
int index=FindSlfObjectIndex(name);
|
||
if(index>-1) return GetSlfTableLength(index);
|
||
else return 0;
|
||
}
|
||
DWORD CSlfIO::GetSlfTableLength(int index)//长度
|
||
{
|
||
if(index<0) return 0;
|
||
int rec=0;
|
||
int reclen=GetSlfTableRecordLength(index);
|
||
for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
|
||
rec+=m_SlfObjectEntry[index].DataRecord[i].DataRecordNum;
|
||
}
|
||
return rec*reclen;//+sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[index].FieldNum;
|
||
}
|
||
//Object Operations
|
||
int CSlfIO::FindSlfObjectIndex(const char* namee,int status)
|
||
{
|
||
if(!m_SlfObjectEntry) return -1;
|
||
char name[128];
|
||
strcpy(name,namee);
|
||
for(int i=0;i<m_SlfHead.TableNumber;i++) {
|
||
if(stricmp(name,m_SlfObjectEntry[i].Name)==0||stricmp(name,m_SlfObjectEntry[i].HZName)==0) {
|
||
if(status==-1) return i;
|
||
if(status==m_SlfObjectEntry[i].Status) return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
int CSlfIO:: FindSlfObjectName(char* name,short Attribute, short SubAttribute, int status,int otype)
|
||
{
|
||
for(int i=0;i<m_SlfHead.TableNumber;i++)
|
||
{
|
||
if(stricmp(name,m_SlfObjectEntry[i].Name)==0||stricmp(name,m_SlfObjectEntry[i].HZName)==0)
|
||
{
|
||
if(Attribute>-1)
|
||
{
|
||
if(m_SlfObjectEntry[i].Type==Attribute)
|
||
{
|
||
if(SubAttribute>-1)
|
||
{
|
||
if(m_SlfObjectEntry[i].Type==SubAttribute)
|
||
{
|
||
if(status>-1)
|
||
{
|
||
if(otype>-1) {
|
||
if(m_SlfObjectEntry[i].Status>=status) return i;
|
||
}
|
||
else if(m_SlfObjectEntry[i].Status==status) return i;
|
||
continue;//else return -1;
|
||
}
|
||
else return i;
|
||
}
|
||
continue;//else return -1;
|
||
}
|
||
else if(status>-1)
|
||
{
|
||
if(otype>-1) {
|
||
if(m_SlfObjectEntry[i].Status>=status) return i;
|
||
}
|
||
else if(m_SlfObjectEntry[i].Status==status) return i;
|
||
continue;//else return -1;
|
||
}
|
||
else return i;
|
||
}
|
||
else if(otype>-1) {
|
||
if(m_SlfObjectEntry[i].Type>=Attribute) return i;
|
||
}
|
||
continue;//else return -1;
|
||
}
|
||
else if(SubAttribute>-1)
|
||
{
|
||
if(m_SlfObjectEntry[i].Type==SubAttribute)
|
||
{
|
||
if(status>-1)
|
||
{
|
||
if(m_SlfObjectEntry[i].Status==status) return i;
|
||
continue;//else return -1;
|
||
}
|
||
else return i;
|
||
}
|
||
continue;//else return -1;
|
||
}
|
||
else if(status>-1)
|
||
{
|
||
if(m_SlfObjectEntry[i].Status==status) return i;
|
||
continue;//else return -1;
|
||
}
|
||
else return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
bool CSlfIO:: DeleteSlfObject(const char* name)
|
||
{
|
||
int index=FindSlfObjectIndex(name);
|
||
if(index<0) return 0;
|
||
m_SlfObjectEntry[index].Status=OBJECT_DELETE;
|
||
WriteSlfObjectEntry(index);
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: WriteSlfObjectEntry(int index,Slf_TABLE_ENTRY *obj)
|
||
{
|
||
if(index<0) return 0;
|
||
mFile->seek(sizeof(Slf_FILE_HEAD)+index*m_SlfHead.TableMessageLength);//,QFile::begin
|
||
if(obj)
|
||
{
|
||
mFile->write((char *)obj,sizeof(Slf_TABLE_ENTRY));
|
||
memmove(&m_SlfObjectEntry[index],obj,sizeof(Slf_TABLE_ENTRY));
|
||
}
|
||
else mFile->write((char *)&m_SlfObjectEntry[index],sizeof(Slf_TABLE_ENTRY));
|
||
if(Slf_Info_Head[index]) {
|
||
Slf_TABLE_MESSAGE *temp1=(Slf_TABLE_MESSAGE *)Slf_Info_Head[index];
|
||
temp1->Table=m_SlfObjectEntry[index];
|
||
}
|
||
mFile->flush();
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: DiscardSlfObject(const char* name)
|
||
{
|
||
int index=FindSlfObjectIndex(name,-1);
|
||
if(index<0) return false;
|
||
return DiscardSlfObject(index);
|
||
}
|
||
bool CSlfIO:: DiscardSlfObjectData(int index,bool DeleteField)
|
||
{
|
||
if(index<0) return 0;
|
||
int dlen=0;
|
||
int reclen=GetSlfTableRecordLength(index);
|
||
for(int i=0;i<m_SlfObjectEntry[index].RecondNum;i++) {
|
||
DWORD point,point1;
|
||
point1=m_SlfObjectEntry[index].DataRecord[i].DataPosition;
|
||
point =point1+m_SlfObjectEntry[index].DataRecord[i].DataRecordNum*reclen;
|
||
unsigned int len=mFile->size();
|
||
dlen=m_SlfObjectEntry[index].DataRecord[i].DataRecordNum*reclen;
|
||
if(len<point)
|
||
{
|
||
break;
|
||
}
|
||
DWORD size=len-point;
|
||
while((int)size<0)
|
||
{
|
||
size/=2;
|
||
}
|
||
int le=size;
|
||
char *buffer=new char[size+1];
|
||
while(point<len){
|
||
if(point+le>len)
|
||
{
|
||
le=len-point;
|
||
}
|
||
mFile->seek(point);
|
||
mFile->read(buffer,le);
|
||
mFile->seek(point1);
|
||
mFile->write(buffer,le);
|
||
point+=le;
|
||
point1+=le;
|
||
}
|
||
mFile->flush();
|
||
delete []buffer;
|
||
|
||
mFile->resize(len-dlen);
|
||
for(int k=0;k<m_SlfHead.TableNumber;k++) {
|
||
if(m_SlfObjectEntry[k].Position>m_SlfObjectEntry[index].DataRecord[i].DataPosition)
|
||
{
|
||
m_SlfObjectEntry[k].Position-=dlen;
|
||
}
|
||
for(int j=0;j<m_SlfObjectEntry[k].RecondNum;j++)
|
||
{
|
||
if(m_SlfObjectEntry[k].DataRecord[j].DataPosition>m_SlfObjectEntry[index].DataRecord[i].DataPosition)
|
||
{
|
||
m_SlfObjectEntry[k].DataRecord[j].DataPosition-=dlen;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if(DeleteField){
|
||
DWORD point,point1;
|
||
point1=m_SlfObjectEntry[index].Position;
|
||
point =point1+sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[index].FieldNum;
|
||
unsigned int len=mFile->size();
|
||
DWORD size=len-point;
|
||
while((int)size<0)
|
||
{
|
||
size/=2;
|
||
}
|
||
int le=size;
|
||
char *buffer=new char[size+1];
|
||
while(point<len){
|
||
if(point+le>len)
|
||
{
|
||
le=len-point;
|
||
}
|
||
mFile->seek(point);
|
||
mFile->read(buffer,le);
|
||
mFile->seek(point1);
|
||
mFile->write(buffer,le);
|
||
point+=le;
|
||
point1+=le;
|
||
}
|
||
mFile->flush();
|
||
delete []buffer;
|
||
mFile->resize(len-sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[index].FieldNum);
|
||
dlen=sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[index].FieldNum;
|
||
for(int k=0;k<m_SlfHead.TableNumber;k++) {
|
||
if(m_SlfObjectEntry[k].Position>m_SlfObjectEntry[index].Position)
|
||
{
|
||
m_SlfObjectEntry[k].Position-=dlen;
|
||
}
|
||
for(int j=0;j<m_SlfObjectEntry[k].RecondNum;j++) {
|
||
if(m_SlfObjectEntry[k].DataRecord[j].DataPosition>m_SlfObjectEntry[index].Position)
|
||
{
|
||
m_SlfObjectEntry[k].DataRecord[j].DataPosition-=dlen;
|
||
}
|
||
}
|
||
}
|
||
m_SlfObjectEntry[index].Position=mFile->size();
|
||
}
|
||
else if(!DeleteField) {
|
||
m_SlfObjectEntry[index].DataRecord[0].DataPosition=mFile->size();;
|
||
}
|
||
m_SlfObjectEntry[index].DataRecord[0].DataRecordNum=0;
|
||
m_SlfObjectEntry[index].RecondNum=0;
|
||
WriteSlfObjectEntry();
|
||
return 1;
|
||
}
|
||
|
||
bool CSlfIO:: DiscardSlfObject(int index)
|
||
{
|
||
if(index<0) return FALSE;
|
||
m_SlfObjectEntry[index].Status=OBJECT_DISCARD;
|
||
WriteSlfObjectEntry(index);
|
||
char Name[200];
|
||
strcpy(Name,"Discard_");
|
||
strcat(Name,m_SlfObjectEntry[index].Name);
|
||
RenameSlfObject(index,Name);
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: RenameSlfObject(const char* oldName,const char* newName)
|
||
{
|
||
int index=FindSlfObjectIndex(oldName);
|
||
if(index<0) return 0;
|
||
return RenameSlfObject(index,newName);
|
||
}
|
||
bool CSlfIO:: RenameSlfObject(int index,const char* newName)
|
||
{
|
||
if(index<0) return 0;
|
||
if(FindSlfObjectIndex(newName)>-1&&strcmp(m_SlfObjectEntry[index].Name,newName)==0) return false;
|
||
strcpy(m_SlfObjectEntry[index].Name,newName);
|
||
strcpy(m_SlfObjectEntry[index].HZName,newName);
|
||
WriteSlfObjectEntry(index);
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: CopySlfObject(const char* oldName,const char* newName, bool bFailExist)
|
||
{
|
||
int index=FindSlfObjectIndex(oldName);
|
||
if(index<0) {
|
||
return 0;
|
||
}
|
||
int reclen=GetSlfTableRecordLength(index);
|
||
unsigned int leng=GetSlfTableLength((char *)oldName);
|
||
if(leng<1) {
|
||
return 0;
|
||
}
|
||
int ind=FindSlfObjectIndex(newName);
|
||
if(ind>=0) {
|
||
if(bFailExist) return 1;
|
||
else DiscardSlfObjectData(ind);
|
||
}
|
||
else ind=m_SlfHead.TableNumber++;
|
||
m_SlfObjectEntry[ind]=m_SlfObjectEntry[index];
|
||
strcpy(m_SlfObjectEntry[ind].Name,newName);
|
||
strcpy(m_SlfObjectEntry[ind].HZName,newName);
|
||
unsigned int Pos=mFile->size();
|
||
m_SlfObjectEntry[ind].Position=Pos;
|
||
m_SlfObjectEntry[ind].RecondNum=1;
|
||
m_SlfObjectEntry[ind].DataRecord[0].DataRecordNum=0;
|
||
m_SlfObjectEntry[ind].DataRecord[0].DataPosition=Pos+
|
||
sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[ind].FieldNum;
|
||
Slf_OBJECT_FIELD *pf=new Slf_OBJECT_FIELD[m_SlfObjectEntry[ind].FieldNum];
|
||
GetSlfTableFieldInfo(index,pf);
|
||
if(Slf_Info_Head[ind]) {
|
||
SetSlfTableFieldInfo(ind,pf,1);
|
||
}
|
||
else {
|
||
SetSlfTableFieldInfo(ind,pf);
|
||
delete []pf;
|
||
}
|
||
WriteSlfObjectEntry(ind);
|
||
WriteSlfHead();
|
||
char *buf=new char[leng+1];
|
||
int RecNum=ReadSlfTable(index,0,buf);
|
||
WriteSlfTable(ind,RecNum,buf);
|
||
delete []buf;
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: UndeleteSlfObject(const char* name)
|
||
{
|
||
int index=FindSlfObjectIndex(name,OBJECT_DELETE);
|
||
if(index<0) return 0;
|
||
m_SlfObjectEntry[index].Status=OBJECT_NORMAL;
|
||
WriteSlfObjectEntry(index);
|
||
return 1;
|
||
}
|
||
WORD CSlfIO:: GetSlfObjectCount()
|
||
{
|
||
return m_SlfHead.TableNumber;
|
||
}
|
||
void CSlfIO:: GetAllSlfObjectEntry(Slf_TABLE_ENTRY* pEntry,WORD count)
|
||
{
|
||
if(count<=0) count=m_SlfHead.MaxTableNumber;
|
||
memmove(pEntry,m_SlfObjectEntry,sizeof(Slf_TABLE_ENTRY)*count);
|
||
}
|
||
void CSlfIO:: GetSlfObjectEntry(int index,Slf_TABLE_ENTRY* pEntry)
|
||
{
|
||
if(index>-1) *pEntry=m_SlfObjectEntry[index];
|
||
}
|
||
void CSlfIO:: SetSlfObjectReserved(int index,char * pEntry)
|
||
{
|
||
if(index>-1&&pEntry) {
|
||
int len=strlen(pEntry);
|
||
if(len>=32) len=31;
|
||
memmove(m_SlfObjectEntry[index].DataSource,pEntry,len);
|
||
m_SlfObjectEntry[index].DataSource[len]=0;
|
||
WriteSlfObjectEntry(index);
|
||
}
|
||
}
|
||
void CSlfIO:: GetSlfObjectAttribute(int index,short* Attribute, short* SubAttribute)
|
||
{
|
||
if(index>=0) {
|
||
*SubAttribute=m_SlfObjectEntry[index].Type;
|
||
*Attribute=1;
|
||
if(m_SlfObjectEntry[index].Type==CURVE_OBJECT||m_SlfObjectEntry[index].Type==TDT_OBJECT||m_SlfObjectEntry[index].Type==FMT_OBJECT) {
|
||
*Attribute=CHANNEL_OBJECT;
|
||
*SubAttribute=m_SlfObjectEntry[index].Type;
|
||
}
|
||
else if(m_SlfObjectEntry[index].Type==CARD_OBJECT) {
|
||
*Attribute=STREAM_OBJECT;
|
||
*SubAttribute=PARA_OBJECT;
|
||
}
|
||
else if(m_SlfObjectEntry[index].Type>CARD_OBJECT) {
|
||
*Attribute=TABLE_OBJECT;
|
||
*SubAttribute=m_SlfObjectEntry[index].Type-CARD_OBJECT;
|
||
}
|
||
}
|
||
}
|
||
bool CSlfIO:: GetSlfObjectEntry(const char* name,Slf_TABLE_ENTRY* pEntry)
|
||
{
|
||
int index=FindSlfObjectIndex(name);
|
||
if(index<0) return 0;
|
||
*pEntry=m_SlfObjectEntry[index];
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: GetSlfObjectAttribute(const char* name,short* Attribute, short* SubAttribute)
|
||
{
|
||
int index=FindSlfObjectIndex(name);
|
||
if(index<0) return 0;
|
||
GetSlfObjectAttribute(index,Attribute,SubAttribute);
|
||
return 1;
|
||
}
|
||
|
||
int CSlfIO:: OpenSlfStream(const char* name)
|
||
{
|
||
int index=FindSlfObjectName((char *)name,CARD_OBJECT);
|
||
if(index<0)return -1;
|
||
return OpenSlfTable(name);
|
||
}
|
||
int CSlfIO:: CreateSlfStream(short SubAttribute,const char *name,DWORD length,bool bFailExist,const char *hzname)
|
||
{
|
||
Slf_OBJECT_FIELD field;
|
||
memset((char *)&field,0,sizeof(Slf_OBJECT_FIELD));
|
||
field.ArrayNum=1;
|
||
field.CodeLength=1;
|
||
field.RepCode=6;
|
||
field.SamplePoint=1;//length;
|
||
field.Rlev=1;
|
||
field.Start=0;
|
||
field.Sequence=0;
|
||
int index=CreateSlfTable(CARD_OBJECT,name,hzname,1,&field,bFailExist);
|
||
if(index>-1) SetSlfTableRecordCount(index,length);
|
||
return index;
|
||
}
|
||
bool CSlfIO:: ExpandSlfStream(int index, DWORD BlockNum)
|
||
{
|
||
return 1;
|
||
}
|
||
void CSlfIO:: CloseSlfStream(int index)
|
||
{
|
||
}
|
||
bool CSlfIO:: SetSlfStreamLength(int index, DWORD length)
|
||
{
|
||
return SetSlfTableRecordCount(index,length);
|
||
}
|
||
bool CSlfIO:: SeekSlfStream(int index, int lMove, DWORD dwMoveMode)
|
||
{
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: ReadSlfStream(int index, DWORD length, LPDWORD lpBytesRead, char *buffer)
|
||
{
|
||
*lpBytesRead=ReadSlfTable(index, length, buffer,0);
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: WriteSlfStream(int index, DWORD length, LPDWORD lpBytesWrite, const char *buffer)
|
||
{
|
||
*lpBytesWrite=WriteSlfTable(index, length,(void *) buffer,0);
|
||
// SetSlfTableRecordCount(index,length);
|
||
return 1;
|
||
}
|
||
DWORD CSlfIO::GetSlfStreamLength(int index)
|
||
{
|
||
return GetSlfTableLength(index);
|
||
}
|
||
int CSlfIO:: ReadSlfStreamInfo(int index)
|
||
{
|
||
return 1;
|
||
}
|
||
int CSlfIO:: WriteSlfStreamInfo(int index)
|
||
{
|
||
return 1;
|
||
}
|
||
int CSlfIO::OpenSlfChannel(const char *name)
|
||
{
|
||
int index=FindSlfObjectName((char *)name);
|
||
if(index<0) return -1;
|
||
int curvetype=GetObjectType(name);
|
||
if(curvetype>=CARD_OBJECT||curvetype==0) return -1;
|
||
return OpenSlfTable(name);
|
||
}
|
||
int CSlfIO::OpenSlfChannel(const char *name,short Attribute)
|
||
{
|
||
int index=FindSlfObjectName((char *)name);
|
||
if(index<0) return -1;
|
||
int curvetype=GetObjectType(name);
|
||
if(curvetype>=CARD_OBJECT||curvetype==0) return -1;
|
||
return OpenSlfTable(name);
|
||
}
|
||
DWORD CSlfIO::ComputerSlfChannelLength(int index)
|
||
{
|
||
return GetSlfTableRecordLength(index);
|
||
}
|
||
bool CSlfIO::CorrectSlfTableField(int index, unsigned char nDimension, float delta)
|
||
{
|
||
if(index<0) return 0;
|
||
Slf_OBJECT_FIELD *pFieldInfo=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
|
||
GetSlfTableFieldInfo(index,pFieldInfo);
|
||
pFieldInfo[nDimension].Start+=delta;
|
||
SetSlfTableFieldInfo(index,pFieldInfo,0);
|
||
delete []pFieldInfo;
|
||
return 1;
|
||
}
|
||
bool CSlfIO::CopySlfObjectToMem(Slf_TABLE_MESSAGE *my,char *name,char *buffer,int Len)
|
||
{
|
||
int index=FindSlfObjectName(name);
|
||
if(index<0) return NULL;
|
||
memmove(&my->Table,&m_SlfObjectEntry[index],sizeof(Slf_TABLE_ENTRY));
|
||
GetSlfTableFieldInfo(index,my->pField);
|
||
ReadSlfTable(index,0,buffer,0);
|
||
return TRUE;
|
||
}
|
||
|
||
bool CSlfIO::CopyFromSLFFile(Slf_TABLE_MESSAGE *my,char *buffer,int Len)
|
||
{
|
||
int index=FindSlfObjectName(my->Table.Name);
|
||
if(index>=0) return FALSE;
|
||
memmove(&m_SlfObjectEntry[m_SlfHead.TableNumber],&my->Table,sizeof(Slf_TABLE_ENTRY));
|
||
int rec=GetSlfTableRecordCount(m_SlfHead.TableNumber);
|
||
m_SlfObjectEntry[m_SlfHead.TableNumber].Position=mFile->size();
|
||
m_SlfObjectEntry[m_SlfHead.TableNumber].RecondNum=1;
|
||
m_SlfObjectEntry[m_SlfHead.TableNumber].DataRecord[0].DataPosition=
|
||
m_SlfObjectEntry[m_SlfHead.TableNumber].Position+m_SlfObjectEntry[m_SlfHead.TableNumber].FieldNum*sizeof(Slf_OBJECT_FIELD);
|
||
m_SlfObjectEntry[m_SlfHead.TableNumber].DataRecord[0].DataRecordNum=rec;
|
||
SetSlfTableFieldInfo(m_SlfHead.TableNumber,my->pField);
|
||
WriteSlfTable(m_SlfHead.TableNumber,rec,buffer);
|
||
m_SlfHead.TableNumber++;
|
||
WriteSlfHead();
|
||
WriteSlfObjectEntry();
|
||
return TRUE;
|
||
}
|
||
|
||
bool CSlfIO::CopyFromSLFFile(CSlfIO &Source,char *Name,char *newName)
|
||
{
|
||
if(!Source.mFile) return FALSE;
|
||
if(Source.IsWis) return FALSE;
|
||
int len=Source.GetSlfTableLength(Name);
|
||
if(len==0) return FALSE;
|
||
char *buf=new char[len+1];
|
||
if(!buf) return FALSE;
|
||
int index=Source.FindSlfObjectIndex(Name);
|
||
Slf_TABLE_MESSAGE obje;
|
||
int FieldNum=Source.GetSlfTableFieldCount(index);
|
||
obje.pField=new Slf_OBJECT_FIELD[FieldNum];
|
||
if(Source.GetSlfObjectEntry(Name,&obje.Table)&&Source.GetSlfTableFieldInfo(index,obje.pField)) {
|
||
if(Source.CopySlfObjectToMem(&obje,Name,buf,len)) {
|
||
strcpy(obje.Table.Name,newName);
|
||
if(CopyFromSLFFile(&obje,buf,len)) {
|
||
delete obje.pField;
|
||
delete buf;
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
delete obje.pField;
|
||
delete buf;
|
||
return FALSE;
|
||
}
|
||
|
||
bool CSlfIO::CopyFromSLFFile(CSlfIO &Source,char *Name)
|
||
{
|
||
if(!Source.mFile) return FALSE;
|
||
if(Source.IsWis) return FALSE;
|
||
int len=Source.GetSlfTableLength(Name);
|
||
if(len==0) return FALSE;
|
||
char *buf=new char[len+1];
|
||
if(!buf) return FALSE;
|
||
int index=Source.FindSlfObjectIndex(Name);
|
||
Slf_TABLE_MESSAGE obje;
|
||
int FieldNum=Source.GetSlfTableFieldCount(index);
|
||
obje.pField=new Slf_OBJECT_FIELD[FieldNum];
|
||
if(Source.GetSlfObjectEntry(Name,&obje.Table)&&Source.GetSlfTableFieldInfo(index,obje.pField)) {
|
||
if(Source.CopySlfObjectToMem(&obje,Name,buf,len)) {
|
||
if(CopyFromSLFFile(&obje,buf,len)) {
|
||
delete obje.pField;
|
||
delete buf;
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
delete obje.pField;
|
||
delete buf;
|
||
return FALSE;
|
||
}
|
||
void CSlfIO::SlfTableResamples(int index,float newDelta)
|
||
{
|
||
if(index<0) return;
|
||
int reclen=GetSlfTableRecordLength(index);
|
||
unsigned int leng=GetSlfTableLength(index);
|
||
int rec=GetSlfTableRecordCount(index);
|
||
if(leng<1) return;
|
||
Slf_OBJECT_FIELD *pf=new Slf_OBJECT_FIELD[m_SlfObjectEntry[index].FieldNum];
|
||
GetSlfTableFieldInfo(index,pf);
|
||
if(pf->Rlev==newDelta) {
|
||
delete []pf;
|
||
return;
|
||
}
|
||
char oldname[200];
|
||
strcpy(oldname,m_SlfObjectEntry[index].Name);
|
||
strcat(oldname,".OLD");
|
||
int ind=FindSlfObjectIndex(oldname);
|
||
if(ind>=0) {
|
||
DiscardSlfObjectData(ind);
|
||
}
|
||
else {
|
||
ind=m_SlfHead.TableNumber++;
|
||
}
|
||
m_SlfObjectEntry[ind]=m_SlfObjectEntry[index];
|
||
memmove(m_SlfObjectEntry[index].Name,oldname,sizeof(m_SlfObjectEntry[index].Name));
|
||
memmove(m_SlfObjectEntry[index].HZName,oldname,sizeof(m_SlfObjectEntry[index].HZName));
|
||
unsigned int Pos=mFile->size();
|
||
m_SlfObjectEntry[ind].Position=Pos;
|
||
m_SlfObjectEntry[ind].RecondNum=1;
|
||
m_SlfObjectEntry[ind].DataRecord[0].DataPosition=Pos+
|
||
sizeof(Slf_OBJECT_FIELD)*m_SlfObjectEntry[ind].FieldNum;
|
||
float orlev=pf->Rlev;
|
||
m_SlfObjectEntry[ind].DataRecord[0].DataRecordNum=(rec*pf->Rlev)/newDelta+0.5;
|
||
pf->Rlev=newDelta;
|
||
SetSlfTableFieldInfo(ind,pf);
|
||
|
||
//char *obuf=new char[reclen*m_SlfObjectEntry[ind].DataRecord[0].DataRecordNum+1];
|
||
//char *buf=new char[leng+1];
|
||
DWORD MaxLen=reclen*m_SlfObjectEntry[ind].DataRecord[0].DataRecordNum+1;
|
||
if(MaxLen<leng+1)MaxLen=leng+1;
|
||
char *obuf=new char[MaxLen+10];
|
||
char *buf=new char[MaxLen+10];
|
||
int RecNum=ReadSlfTable(index,0,buf);
|
||
float dep,yy1,yy2,yy;
|
||
int k1,k2;
|
||
DWORD num,num1;
|
||
int Pos1=0;
|
||
for(DWORD i=0;i<m_SlfObjectEntry[ind].DataRecord[0].DataRecordNum;i++) {
|
||
dep=i*newDelta;
|
||
k1=dep/orlev+0.5;
|
||
k2=dep/orlev+1.5;
|
||
|
||
while(dep < k1*orlev)
|
||
k1--;
|
||
while(dep > k2*orlev)
|
||
k2++;
|
||
while( (k2 - 1)*orlev > dep)
|
||
k2--;
|
||
while( (k1 + 1)*orlev < dep)
|
||
k1++;
|
||
if(k1*reclen+1>=MaxLen) k1=MaxLen-1;
|
||
if(k2*reclen+1>=MaxLen) k2=k1;
|
||
if(k1<0) k1=0;
|
||
if(k2<0) k2=0;
|
||
Pos1=0;
|
||
for(int k=0;k<m_SlfObjectEntry[ind].FieldNum;k++)
|
||
{
|
||
if(pf[k].Sequence) continue;
|
||
for(int j=0;j<pf[k].ArrayNum*pf[k].SamplePoint;j++) {
|
||
Pos=k1*reclen+Pos1+j*pf[k].CodeLength;
|
||
GetData(pf[k].CodeLength,&buf[Pos],&yy1);
|
||
Pos=k2*reclen+Pos1+j*pf[k].CodeLength;
|
||
GetData(pf[k].CodeLength,&buf[Pos],&yy2);
|
||
if(k1==k2)yy=yy1;
|
||
else yy=yy1+(yy2-yy1)*(dep-k1*orlev)/((k2-k1)*orlev);
|
||
Pos=i*reclen+Pos1+j*pf[k].CodeLength;
|
||
SetData(pf[k].CodeLength,&obuf[Pos],&yy);
|
||
}
|
||
Pos1+=pf[k].ArrayNum*pf[k].SamplePoint*pf[k].CodeLength;
|
||
}
|
||
}
|
||
WriteSlfTable(ind,m_SlfObjectEntry[ind].DataRecord[0].DataRecordNum,obuf);
|
||
Slf_TABLE_ENTRY ol=m_SlfObjectEntry[index];
|
||
m_SlfObjectEntry[index]=m_SlfObjectEntry[ind];
|
||
strcpy(m_SlfObjectEntry[ind].Name,ol.Name);
|
||
strcpy(m_SlfObjectEntry[ind].HZName,ol.HZName);
|
||
m_SlfObjectEntry[ind].RecondNum=ol.RecondNum;
|
||
for(int i=0;i<ol.RecondNum;i++) {
|
||
m_SlfObjectEntry[ind].DataRecord[i].DataPosition=ol.DataRecord[i].DataPosition;
|
||
m_SlfObjectEntry[ind].DataRecord[i].DataRecordNum=ol.DataRecord[i].DataRecordNum;
|
||
}
|
||
m_SlfObjectEntry[ind].Position=ol.Position;
|
||
WriteSlfObjectEntry();
|
||
WriteSlfHead();
|
||
delete []buf;
|
||
delete []obuf;
|
||
delete []pf;
|
||
}
|
||
void CSlfIO::MoveSlfTable(int index,int RecFirst,int RecEnd,int Move)
|
||
{
|
||
if(index<0) return;
|
||
int rec=GetSlfTableRecordCount(index);
|
||
int reclen=GetSlfTableRecordLength(index);
|
||
unsigned int leng=GetSlfTableLength(index);
|
||
Slf_OBJECT_FIELD *pf=GetSlfTableFieldInfo(index);
|
||
if(RecFirst==0&&RecEnd==rec) {
|
||
pf[0].Start+=Move*pf[0].Rlev;
|
||
SetSlfTableFieldInfo(index,pf);
|
||
}
|
||
else {
|
||
char *buf=new char[leng+1];
|
||
ReadSlfTable(index,RecEnd,buf,RecFirst);
|
||
int nrecf=RecFirst+Move;
|
||
int nrece=RecEnd+Move;
|
||
WriteSlfTable(index,nrece,buf,nrecf);
|
||
delete []buf;
|
||
}
|
||
}
|
||
void CSlfIO::SetObjectName(const char *Name,const char *Alias,const char *Unit,const char *AliasUnit,short Attribute, short SubAttribute, int status,int otype)
|
||
{
|
||
int index=FindObjectName((char *)&Name,Attribute,SubAttribute,status,otype);
|
||
if(index>-1) {
|
||
SetObjectName(index,NULL,Alias,Unit,AliasUnit);
|
||
}
|
||
}
|
||
void CSlfIO::SetObjectName(int index, const char *Name,const char *Alias,const char *Unit,const char *AliasUnit)
|
||
{
|
||
if(IsWis) {
|
||
if(Name) {
|
||
int len=sizeof(m_ObjectEntry[index].Name);
|
||
if(len>strlen(Name)) len=strlen(Name);
|
||
memmove(m_ObjectEntry[index].Name,Name,len);
|
||
if(len<sizeof(m_ObjectEntry[index].Name))m_ObjectEntry[index].Name[sizeof(Name)]=0;
|
||
WriteObjectEntry();
|
||
}
|
||
if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT) {
|
||
Slf_CHANNEL info;
|
||
ReadChannelInfo(index,&info);
|
||
if(Unit){
|
||
int len=sizeof(info.Unit);
|
||
if(len>strlen(Unit)) len=strlen(Unit);
|
||
memmove(info.Unit,Unit,len);
|
||
if(len<sizeof(info.Unit)) info.Unit[len]=0;
|
||
}
|
||
if(Alias){
|
||
int len=sizeof(info.AliasName);
|
||
if(len>strlen(Unit)) len=strlen(Alias);
|
||
memmove(info.AliasName,Alias,len);
|
||
if(len<sizeof(info.AliasName)) info.AliasName[len]=0;
|
||
}
|
||
if(AliasUnit){
|
||
int len=sizeof(sizeof(info.AliasUnit));
|
||
if(len>strlen(AliasUnit)) len=strlen(AliasUnit);
|
||
memmove(info.AliasUnit,AliasUnit,len);
|
||
if(len<sizeof(info.AliasUnit)) info.AliasUnit[len]=0;
|
||
}
|
||
WriteChannelInfo(index,&info);
|
||
}
|
||
else {
|
||
}
|
||
}
|
||
else {
|
||
if(Name) {
|
||
int len=sizeof(m_SlfObjectEntry[index].Name);
|
||
if(len>strlen(Name)) len=strlen(Name);
|
||
memmove(m_SlfObjectEntry[index].Name,Name,len);
|
||
if(len<sizeof(m_SlfObjectEntry[index].Name))m_SlfObjectEntry[index].Name[len]=0;
|
||
}
|
||
|
||
if(Alias) {
|
||
int len=sizeof(m_SlfObjectEntry[index].HZName);
|
||
if(len>strlen(Alias)) len=strlen(Alias);
|
||
memmove(m_SlfObjectEntry[index].HZName,Alias,len);
|
||
if(len<sizeof(m_SlfObjectEntry[index].HZName))m_SlfObjectEntry[index].HZName[len]=0;
|
||
}
|
||
if(Unit){
|
||
int len=sizeof(m_SlfObjectEntry[index].Unit);
|
||
if(len>strlen(Unit)) len=strlen(Unit);
|
||
memmove(m_SlfObjectEntry[index].Unit,Unit,len);
|
||
if(len<sizeof(m_SlfObjectEntry[index].Unit))m_SlfObjectEntry[index].Unit[len]=0;
|
||
}
|
||
if(AliasUnit) {
|
||
int len=sizeof(m_SlfObjectEntry[index].HZUnit);
|
||
if(len>strlen(AliasUnit)) len=strlen(AliasUnit);
|
||
memmove(m_SlfObjectEntry[index].HZUnit,AliasUnit,len);
|
||
if(len<sizeof(m_SlfObjectEntry[index].HZUnit))m_SlfObjectEntry[index].HZUnit[len]=0;
|
||
}
|
||
WriteSlfObjectEntry();
|
||
}
|
||
}
|
||
|
||
void CSlfIO::GetObjectName(int index, char *Name,char *Unit,char *Alias,char *AliasUnit)
|
||
{
|
||
if(IsWis) {
|
||
memmove(Name,m_ObjectEntry[index].Name,sizeof(m_ObjectEntry[index].Name));
|
||
Name[sizeof(m_ObjectEntry[index].Name)]=0;
|
||
if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT) {
|
||
Slf_CHANNEL info;
|
||
ReadChannelInfo(index,&info);
|
||
if(Unit)memmove(Unit,info.Unit,sizeof(info.Unit));
|
||
if(Alias)memmove(Alias,info.AliasName,sizeof(info.AliasName));
|
||
if(AliasUnit)memmove(AliasUnit,info.AliasUnit,sizeof(info.AliasUnit));
|
||
}
|
||
else {
|
||
if(Unit)Unit[0]=0;
|
||
if(Alias)Alias[0]=0;
|
||
if(AliasUnit)AliasUnit[0]=0;
|
||
}
|
||
}
|
||
else {
|
||
memmove(Name,m_SlfObjectEntry[index].Name,sizeof(m_SlfObjectEntry[index].Name));
|
||
if(Alias)memmove(Alias,m_SlfObjectEntry[index].HZName,sizeof(m_SlfObjectEntry[index].HZName));
|
||
if(Unit)memmove(Unit,m_SlfObjectEntry[index].Unit,sizeof(m_SlfObjectEntry[index].Unit));
|
||
if(AliasUnit) memmove(AliasUnit,m_SlfObjectEntry[index].HZUnit,sizeof(m_SlfObjectEntry[index].HZUnit));
|
||
}
|
||
}
|
||
//whp add
|
||
short CSlfIO::GetObjectType(int index)
|
||
{
|
||
if(IsWis) return GetWisObjectType(index);
|
||
else return GetSlfObjectType(index);
|
||
}
|
||
short CSlfIO::GetObjectType(const char* name)
|
||
{
|
||
if(IsWis) return GetWisObjectType(name);
|
||
else return GetSlfObjectType(name);
|
||
}
|
||
short CSlfIO:: GetSlfObjectType(int index)
|
||
{
|
||
if(index>=0)return m_SlfObjectEntry[index].Type;
|
||
else return -1;
|
||
}
|
||
short CSlfIO:: GetSlfObjectType(const char* name)
|
||
{
|
||
int index=FindSlfObjectIndex(name);
|
||
if(index<0) return -1;
|
||
return GetSlfObjectType(index);
|
||
}
|
||
short CSlfIO::GetWisObjectType(int index)
|
||
{
|
||
if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT&&m_ObjectEntry[index].SubAttribute==CURVE_OBJECT)return CURVE_OBJECT;
|
||
if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT&&m_ObjectEntry[index].SubAttribute==WAVE_OBJECT)return WAVE_OBJECT;
|
||
if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT&&m_ObjectEntry[index].SubAttribute==FMT_OBJECT)return FMT_OBJECT;
|
||
if(m_ObjectEntry[index].Attribute==CHANNEL_OBJECT&&m_ObjectEntry[index].SubAttribute==TDT_OBJECT)return TDT_OBJECT;
|
||
if(m_ObjectEntry[index].Attribute==STREAM_OBJECT)return CARD_OBJECT;
|
||
else return 0;
|
||
}
|
||
short CSlfIO::GetWisObjectType(const char* name)
|
||
{
|
||
int index=FindWisObjectIndex(name);
|
||
if(index>-1) {
|
||
return GetWisObjectType(index);
|
||
}
|
||
else return -1;
|
||
}
|
||
//whp add 2011.12.18
|
||
bool CSlfIO::UndeleteSlfObject(int index)
|
||
{
|
||
if(index<0) return 0;
|
||
m_SlfObjectEntry[index].Status=OBJECT_NORMAL;
|
||
WriteSlfObjectEntry(index);
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: UnDeleteObject(int index)
|
||
{
|
||
if(IsWis) return 0;
|
||
else return UndeleteSlfObject(index);
|
||
}
|
||
void CSlfIO::GetSlfObjectBaseInf(int index,Slf_OBJECT_BASE_INF* pBaseInf)
|
||
{
|
||
if(index>-1)
|
||
{
|
||
memmove(pBaseInf->Name,m_SlfObjectEntry[index].Name,sizeof(m_SlfObjectEntry[index].Name));
|
||
memmove(pBaseInf->HZName,m_SlfObjectEntry[index].HZName,sizeof(m_SlfObjectEntry[index].HZName));
|
||
memmove(pBaseInf->Unit,m_SlfObjectEntry[index].Unit,sizeof(m_SlfObjectEntry[index].Unit));
|
||
memmove(pBaseInf->HZUnit,m_SlfObjectEntry[index].HZUnit,sizeof(m_SlfObjectEntry[index].HZUnit));
|
||
memmove(pBaseInf->DataSource,m_SlfObjectEntry[index].DataSource,sizeof(m_SlfObjectEntry[index].DataSource));
|
||
memmove(pBaseInf->LogCopanyName,m_SlfObjectEntry[index].LogCopanyName,sizeof(m_SlfObjectEntry[index].LogCopanyName));
|
||
memmove(pBaseInf->LoggingTeam,m_SlfObjectEntry[index].LoggingTeam,sizeof(m_SlfObjectEntry[index].LoggingTeam));
|
||
memmove(pBaseInf->Operator,m_SlfObjectEntry[index].Operator,sizeof(m_SlfObjectEntry[index].Operator));
|
||
memmove(&pBaseInf->LoggingDate,&m_SlfObjectEntry[index].LoggingDate,sizeof(m_SlfObjectEntry[index].LoggingDate));
|
||
}
|
||
}
|
||
bool CSlfIO:: GetSlfObjectBaseInf(const char* name,Slf_OBJECT_BASE_INF* pBaseInf)
|
||
{
|
||
int index=FindSlfObjectIndex(name);
|
||
if(index<0) return 0;
|
||
memmove(pBaseInf->Name,m_SlfObjectEntry[index].Name,sizeof(m_SlfObjectEntry[index].Name));
|
||
memmove(pBaseInf->HZName,m_SlfObjectEntry[index].HZName,sizeof(m_SlfObjectEntry[index].HZName));
|
||
memmove(pBaseInf->Unit,m_SlfObjectEntry[index].Unit,sizeof(m_SlfObjectEntry[index].Unit));
|
||
memmove(pBaseInf->HZUnit,m_SlfObjectEntry[index].HZUnit,sizeof(m_SlfObjectEntry[index].HZUnit));
|
||
memmove(pBaseInf->DataSource,m_SlfObjectEntry[index].DataSource,sizeof(m_SlfObjectEntry[index].DataSource));
|
||
memmove(pBaseInf->LogCopanyName,m_SlfObjectEntry[index].LogCopanyName,sizeof(m_SlfObjectEntry[index].LogCopanyName));
|
||
memmove(pBaseInf->LoggingTeam,m_SlfObjectEntry[index].LoggingTeam,sizeof(m_SlfObjectEntry[index].LoggingTeam));
|
||
memmove(pBaseInf->Operator,m_SlfObjectEntry[index].Operator,sizeof(m_SlfObjectEntry[index].Operator));
|
||
memmove(&pBaseInf->LoggingDate,&m_SlfObjectEntry[index].LoggingDate,sizeof(m_SlfObjectEntry[index].LoggingDate));
|
||
return 1;
|
||
}
|
||
bool CSlfIO:: WriteSlfObjectBaseInf(int index,Slf_OBJECT_BASE_INF *pBaseInf)
|
||
{
|
||
if(index<0) return 0;
|
||
memmove(m_SlfObjectEntry[index].Name,pBaseInf->Name,sizeof(pBaseInf->Name));
|
||
memmove(m_SlfObjectEntry[index].HZName,pBaseInf->HZName,sizeof(pBaseInf->HZName));
|
||
memmove(m_SlfObjectEntry[index].Unit,pBaseInf->Unit,sizeof(pBaseInf->Unit));
|
||
memmove(m_SlfObjectEntry[index].HZUnit,pBaseInf->HZUnit,sizeof(pBaseInf->HZUnit));
|
||
memmove(m_SlfObjectEntry[index].DataSource,pBaseInf->DataSource,sizeof(pBaseInf->DataSource));
|
||
memmove(m_SlfObjectEntry[index].LogCopanyName,pBaseInf->LogCopanyName,sizeof(pBaseInf->LogCopanyName));
|
||
memmove(m_SlfObjectEntry[index].LoggingTeam,pBaseInf->LoggingTeam,sizeof(pBaseInf->LoggingTeam));
|
||
memmove(m_SlfObjectEntry[index].Operator,pBaseInf->Operator,sizeof(pBaseInf->Operator));
|
||
memmove(&m_SlfObjectEntry[index].LoggingDate,&pBaseInf->LoggingDate,sizeof(pBaseInf->LoggingDate));
|
||
WriteSlfObjectEntry(index,&m_SlfObjectEntry[index]);
|
||
return 1;
|
||
}
|
||
char* CSlfIO::GetSlfFileName()
|
||
{
|
||
return m_LogFileName;
|
||
}
|
||
void WriteShiftMessage(CSlfIO&mem,CString &szBuffer,QString name,QString card)
|
||
{
|
||
CString szBuffer1="";
|
||
DWORD bytes_write;
|
||
char cardname[200]="Run_depth_Records";
|
||
if(!card.isEmpty()) strcpy(cardname,card.toStdString().c_str());
|
||
int index_result = mem.CreateStream(PARA_OBJECT,cardname,16384,FALSE);
|
||
int len=mem.GetStreamLength(index_result);
|
||
if(len>0) {
|
||
char *buff=new char[len+1];
|
||
DWORD lb=0;
|
||
mem.ReadStream(index_result,len,&lb,buff);
|
||
QString cs=szBuffer.GetString();
|
||
QDateTime current_date_time =QDateTime::currentDateTime();
|
||
QString strStartTime = current_date_time.toString("dd-MM-yyyy hh:mm:ss");
|
||
if(!card.isEmpty()) szBuffer1=name+" "+strStartTime+"\r\n"+cs+"\r\nEND\r\n"+buff;
|
||
else {
|
||
QString css=name+" ";
|
||
css+=strStartTime+"\r\n";
|
||
css+=cs+"END\r\n";
|
||
int len=strlen(buff);
|
||
if(len>0)
|
||
{
|
||
buff[len]=0;
|
||
QString csss=buff;
|
||
szBuffer1=csss+"\r\n"+css;
|
||
}
|
||
else szBuffer1=css;
|
||
}
|
||
cs=szBuffer1.GetString();
|
||
len=strlen(cs.toStdString().c_str());
|
||
mem.WriteStream(index_result,len+1,&lb,szBuffer1.GetString());
|
||
delete buff;
|
||
}
|
||
}
|
||
|
||
#ifndef WIN32
|
||
char *strupr(char *str){
|
||
char *orign=str;
|
||
for (; *str!='\0'; str++)
|
||
*str = toupper(*str);
|
||
return orign;
|
||
}
|
||
#endif
|
||
|
||
|
||
QDataStream & operator << (QDataStream & out, const tagSlf_FILE_HEAD & aSlf_FILE_HEAD) {
|
||
out << aSlf_FILE_HEAD.Version ;
|
||
return out;
|
||
}
|