logplus/Slfio/include/slf.h

#ifndef __SlfIO_H__
#define __SlfIO_H__    


//#define Slf_LIB

#include <fcntl.h>
#include <QFile>
#include <time.h>
#include "CStringType.h"
#include "SlfioExport.h"
#define REPR_INT     1
#define REPR_SHORT   2
#define REPR_LONG    3
#define REPR_FLOAT   4
#define REPR_DOUBLE  5
#define REPR_STRING  6
#define REPR_CHAR    7
#define REPR_UCHAR   8
#define REPR_USHORT  9
#define REPR_UINT   10
#define REPR_ULONG  11

#define CHANNEL_OBJECT    0x0001
#define TABLE_OBJECT      0x0002
#define STREAM_OBJECT     0x0003

#define OBJECT_NORMAL      0x0000
#define OBJECT_DISCARD    0x0001
#define OBJECT_DELETE     0x0002

#define CURVE_OBJECT    0x0001
#define WAVE_OBJECT     0x0002
#define FMT_OBJECT      0x0003
#define TDT_OBJECT      0x0004
#define CARD_OBJECT      0x0005
#define TABLEE_OBJECT      0x0006

#define PARA_OBJECT     0x0001
#define BINARY_OBJECT   0x0002


#define RESULT_OBJECT   CARD_OBJECT+0x0001
#define CORE_OBJECT     CARD_OBJECT+0x0002
#define LITH_OBJECT     CARD_OBJECT+0x0003
#define FRAC_MODEL_OBJECT   CARD_OBJECT+0x0004
#define FRAC_LEVEL_OBJECT   CARD_OBJECT+0x0005
#define CORE_PHYSICS_OBJECT CARD_OBJECT+0x0006
#define GEO_LOGGING_OBJECT  CARD_OBJECT+0x0007
#define SWALL_CORE_OBJECT   CARD_OBJECT+0x0008
#define LITH_SECT_OBJECT    CARD_OBJECT+0x0009
#define FMT_MODEL_OBJECT    CARD_OBJECT+0x000A
#define FMT_RESULT_OBJECT   CARD_OBJECT+0x000B
#define RFT_RESULT_OBJECT   CARD_OBJECT+0x000C
#define STATIC_OBJECT       CARD_OBJECT+0x000D
#define DYNAMIC_OBJECT      CARD_OBJECT+0x000E
#define NEWRESULT_OBJECT     CARD_OBJECT+0x000F
#define GUJING_OBJECT     CARD_OBJECT+0x0010

#ifndef TRUE
#define	TRUE    1
#define	FALSE   0
#endif

#ifndef WIN32
typedef unsigned int       __time32_t;
#define stricmp strcasecmp
char *strupr(char *str);
#define	_MAX_PATH	256
#endif

CString SLFIO_EXPORT MemName(CString wellname,CString Curve);
int SLFIO_EXPORT IsMappingMem(const char *MemName);
bool SLFIO_EXPORT MappingMem(HANDLE *hHandle,LPSTR *hMem,int len,const char *name);
void SLFIO_EXPORT CloseView(HANDLE hMapObject,LPVOID lpvMem);

SLFIO_EXPORT extern const char *Rep_STR[];
SLFIO_EXPORT extern int RepSize[12];
SLFIO_EXPORT time_t StringToTime(char * szTime);
SLFIO_EXPORT int Slf_Int(float depth,float stdep,float rlev);

#ifdef _UNIX_ 
 #define MACHINE_TYPE 1
#else
 #define MACHINE_TYPE 0
#endif
union MyDataTypeEnum {
	int *vint;
	short *vshort;
	unsigned int *vlong;
	float *vfloat;
	double *vdouble;
	char*  vchar;
	char *VCHAR;
	unsigned char *vuchar;
	unsigned short *vushort;
	unsigned int *vuint;
	unsigned int *vulong;
};

typedef struct tagSlf_HEAD
{
//	char  Version[10];
	WORD  MachineType;  // 0-PC  1-SUN   2-IBM	3-HP
	WORD  MaxObjectNumber;
	WORD  ObjectNumber;
	WORD  BlockLen;
	DWORD EntryOffset;
	DWORD DataOffset;
	DWORD FileSize;
	__time32_t TimeCreate;
	char  Reserved[32];
}Slf_HEAD;

typedef struct tagSlf_OBJECT_ENTRY
{
	char   Name[16];
	int   Status;
	short  Attribute;		
	short  SubAttribute;	
	DWORD  Position;
	DWORD  BlockNum;
	__time32_t TimeCreate;
	__time32_t TimeWrite;
	char  Reserved[32];
}Slf_OBJECT_ENTRY;

typedef struct tagSlf_FILE_MESSAGE
{
	//起始位置	变量名称	字节长度	描  述
	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];//	备注
	char Reserved[10];//	备注
}Slf_FILE_MESSAGE;

typedef struct tagSlf_FILE_HEAD
{
//起始位置	变量名称	字节长度	描  述
	char    Version[12];//	12	版本号
	DWORD	BinaryType;//	4	二进制数据标准
	DWORD	TableNumber;//	4	已存储表个数
	DWORD	MaxTableNumber;//	4	预留最大表个数
	DWORD	TableMessageLength;//	4	表基本信息长度
	__time32_t	TimeCreate;//	32	文件产生时间
/////////////////////////////////////
	Slf_FILE_MESSAGE WellMessage;
}Slf_FILE_HEAD;

QDataStream & operator << (QDataStream & out, const tagSlf_FILE_HEAD & aSlf_FILE_HEAD); 

//QDataStream & operator >> (QDataStream & in, Slf_FILE_HEAD & aSlf_FILE_HEAD) { 

//} 
typedef struct tagSlf_DATAPOS_RECORDNUM
{
	DWORD	DataPosition;//	4	原始数据体存储的位置
	DWORD	DataRecordNum;//	4	原始表数据体记录数
}Slf_DATAPOS_RECORDNUM;

typedef struct tagSlf_SLF_TABLE_History
{
//起始位置	变量名称	字节数	描  述
	DWORD StartRecord;//	4	表体更改起始记录号
	DWORD EndRecord;//	4;	表体更改终止记录号
	char  UserName[64];//	64	修改者
	__time32_t Time;//	4	修改时间
}Slf_TABLE_History;

typedef struct tagSlf_TABLE_ENTRY
{
//起始位置	变量名称	字节数	描  述
	char	Name[64];//	64	表名称
	char	HZName[64];//	64	表别名
	char	Unit[32];//	64	表别名
	char	HZUnit[32];//	64	表别名
	char	DataSource[32];//	20	数据来源
	short	Type;//	2	表类型
	short	Status;//	2	表删除标志
	DWORD	SerialID;//	2	所属系列代码
	DWORD	FieldNum;//	4	字段个数
	DWORD	Position;//	4	表字段所存储的位置
	Slf_DATAPOS_RECORDNUM DataRecord[11];
	int     Type1; //子类型
	short	IsSave;//	2	是否自动备份原始数据
	short	ChangeNum;//	2	修改次数
	int     RecondNum; // 数据块数
	char    LogCopanyName[64];//公司名
	char	LoggingTeam[32];//测井队
	char    Operator[32];//操作员
	unsigned int	LoggingDate;//测井时间
//	Slf_TABLE_History*pSLF_TABLE_History;//	76	修改历史信息描述结构变量数组
}Slf_TABLE_ENTRY;
typedef struct tagSlf_OBJECT_BASE_INF
{
//起始位置	变量名称	字节数	描  述
	char	Name[64];//	64	表名称
	char	HZName[64];//	64	表别名
	char	Unit[32];//	64	表别名
	char	HZUnit[32];//	64	表别名
	char	DataSource[32];//	20	数据来源
	char    LogCopanyName[64];//公司名
	char	LoggingTeam[32];//测井队
	char    Operator[32];//操作员
	unsigned int	LoggingDate;//测井时间
}Slf_OBJECT_BASE_INF;
typedef struct tagSlf_OBJECT_FIELD
{
	//起始位置	变量名称	字节长度	描  述
	char	Name[64];//	64	字段名称
	char	HZName[64];//	64	别名
	char	Unit[32];//	32	字段单位
	char	HZUnit[32];//	32	单位别名
	short	RepCode;//	2	字段数据类型
	short	CodeLength;//	2	字段数据类型长度
	short	Sequence;//	2	是否连续控制
	float	Start;//	4	字段起始值
	float	End;//	4	字段起始值
	float	Rlev;//	4	字段采样间隔
	int	    SamplePoint;//	4	一个阵列的横向采样样本点数
	int	    ArrayNum;//	4	阵列数
	float	Vmin;//	4	字段最大值
	float	Vmax;//	4	字段最小值
	float	DefVal;//	4	缺省值
	char	Reserved[26];//	30	备用
}Slf_OBJECT_FIELD;

typedef struct tagSlf_CHANNEL_DIMENSION
{
	char   Name[8];
	char   Unit[8];
	char   AliasName[16];
	float  StartVal;
	float  Delta;
	DWORD  Samples;
	DWORD  MaxSamples;
	DWORD  Size;
	WORD   RepCode;
	WORD   Reserved;
}Slf_CHANNEL_DIMENSION;

typedef struct tagSlf_CHANNEL
{
	char   Unit[8];
	char   AliasName[16];
	char   AliasUnit[16];
	WORD   RepCode;	
	WORD   CodeLen;			  
	float  MinVal;			  
	float  MaxVal;			  
	WORD   Reserved;
	WORD   NumOfDimension;
	Slf_CHANNEL_DIMENSION DimInfo[4];
}Slf_CHANNEL;

typedef struct tagSlf_TABLE_MESSAGE
{
	Slf_TABLE_ENTRY Table;
	Slf_OBJECT_FIELD *pField;
}Slf_TABLE_MESSAGE;

typedef struct tagSlf_STREAM
{
	DWORD Length;
	DWORD Offset;
}Slf_STREAM;

typedef struct tagSlf_TABLE_FIELD_OLD
{
	char   Name[16];
	char   HZName[16];
	WORD   RepCode;
	WORD   Length;
	DWORD  Reserved;//0-数据，1-枚举
} Slf_TABLE_FIELD_OLD;

typedef struct tagSlf_TABLE_FIELD
{
	char   Name[16];
	char   HZName[16];
	WORD   RepCode;
	WORD   Length;
	DWORD  Reserved;//0-数据，1-枚举
////////扩展
	char   Unit[16];
	char   HZUnit[16];
} Slf_TABLE_FIELD;

typedef struct tagSlf_TABLE
{
	DWORD  RecordCount;
	DWORD  FieldCount;
	DWORD  Length;
//	Slf_TABLE_FIELD *pField;
}Slf_TABLE;
typedef struct tagSlf_TABLE_HEAD
{
	DWORD  RecordCount;
	DWORD  FieldCount;
}Slf_TABLE_HEAD;


typedef struct tagSlf_TABLE_DATA
{
 int Num;
 float *pData;
} TABLE_DATE;

class SLFIO_EXPORT CSlfIO
{
public:
	enum OpenFlags 
	{
		typeBinary =   (int)0x8000, // derived classes only
		shareDenyNone =     0x0040,
		modeRead =          0x0000|typeBinary,
		modeWrite =         0x0001|typeBinary,
		modeReadWrite =     0x0002|typeBinary,
		shareCompat =       0x0000,
		shareExclusive =    0x0010,
		shareDenyWrite =    0x0020,
		shareDenyRead =     0x0030,
		modeNoInherit =     0x0080,
		modeCreate =        0x1000|modeReadWrite,
		modeNoTruncate =    0x2000,
		typeText =          0x4000 // typeText and typeBinary are used in
		//_O_CREAT
	};
	QFile             *mFile;
	bool IsWis;
protected:
// attributes
	char              m_LogFileName[_MAX_PATH];
//	HANDLE            m_hFile;  
	char **           Slf_Info_Head;
public:
	Slf_HEAD          m_Head;
	Slf_OBJECT_ENTRY* m_ObjectEntry;
// attributes
//	CDefaultTableManager *m_DefaultTableManager;
public:
// operation
	void  Init(int BlockLen,int MaxObjectNumber, int MachineType);
	void  InitTable(int SystemCode,bool bCreate=FALSE);
	int   ReadHead();
	int   WriteHead();
	int   ReadObjectEntry();
	int   WriteObjectEntry();
	bool  ExpandObject(int index, DWORD BlockNum);
	int   FindFreeSpace(DWORD BlockNum,int nExceptIndex=-1);
public:
//Slf Operatons
	CSlfIO(); 
	CSlfIO(const char* LogName,int FileType=0); 
	~CSlfIO();
	bool  Open(const char* LogName,unsigned int nOpenFlags,int BlockLen = 1024,int MaxObjectNumber=1024, int MachineType=MACHINE_TYPE,int FileType=0);
	bool  Open(unsigned int nOpenFlags,int BlockLen = 1024,int MaxObjectNumber=1024, int MachineType=MACHINE_TYPE,int FileType=0);
	void  Close();
	void  Pack();
	DWORD GetObjectLength(char *name);
	bool  CopyObjectToMem(Slf_OBJECT_ENTRY *my,char *name,char *buffer,int Len);
	float  GetData(int RepCode,char *buffer,float *yy);
	void  SetData(int RepCode,char *buffer,float *yy);
	void  Convert(char*,DWORD,WORD);
    int   mod(int,int);
//Object Operations
	int   FindObjectIndex(const char* name);
	int   FindObjectName(char* name,short Attribute=-1, short SubAttribute=-1, int status=0,int otype=-1);
	bool  DeleteObject(const char* name);
	bool  DiscardObject(const char* name);
	bool  DiscardObject(int index);
	bool  RenameObject(const char* oldName,const char* newName);
	bool  CopyObject(const char* oldName,const char* newName, bool bFailExist = TRUE);
	bool  UnDeleteObject(const char* name);
	WORD  GetObjectCount();
	void  SetObjectName(const  char *Name,const  char *Alias=NULL,const  char *Unit=NULL,const  char *AliasUnit=NULL,short Attribute=-1, short SubAttribute=-1, int status=-1,int otype=-1);
	void  SetObjectName(int index, const  char *Name=NULL,const  char *Alias=NULL,const  char *Unit=NULL,const  char *AliasUnit=NULL);
	void  GetObjectName(int index, char *Name,char *Unit=NULL,char *Alias=NULL,char *AliasUnit=NULL);
	void  GetAllObjectEntry(Slf_OBJECT_ENTRY* pEntry,WORD count);
	void  GetObjectEntry(int index,Slf_OBJECT_ENTRY* pEntry);
	void  SetObjectReserved(int index,char * pEntry);
	void  GetObjectAttribute(int index,short* Attribute, short* SubAttribute);
  	bool  GetObjectEntry(const char* name,Slf_OBJECT_ENTRY* pEntry);
	bool  GetObjectAttribute(const char* name,short* Attribute, short* SubAttribute);
	Slf_OBJECT_FIELD * GetSlfTableFieldInfo(int index);
//Channel Operations
	int   OpenChannel(const char *name);
	int   OpenChannel(const char *name,short Attribute);
	DWORD ComputerChannelLength(Slf_CHANNEL* pInfo,unsigned char nDimension);
	DWORD ComputerChannelLength(int index);
	int   GetChannelDefaultValue(Slf_CHANNEL* pInfo,unsigned char nDimension,char* buffer,DWORD buflen);
	bool  SetChannelPointNum(int index, DWORD nPointNum, DWORD samples1=0,DWORD samples2=0,DWORD samples3=0,DWORD samples4=0);
	DWORD GetChannelPointNum(int index,DWORD samples1=0,DWORD samples2=0,DWORD samples3=0,DWORD samples4=0);
	int   CreateChannel(short SubAttribute,const char *name,Slf_CHANNEL* pInfo,bool bFailExist=FALSE);
	DWORD SeekChannel(int index,DWORD samples1=0,DWORD samples2=0,DWORD samples3=0,DWORD samples4=0);
	DWORD WriteChannel(int index,char* buffer,DWORD num, DWORD samples1=0,DWORD samples2=0,DWORD samples3=0,DWORD samples4=0);
	DWORD ReadChannel(int index,char* buffer,DWORD num, DWORD samples1=0,DWORD samples2=0,DWORD samples3=0,DWORD samples4=0);
	bool  ExpandChannel(int index, unsigned char nDimension, DWORD nSamples, DWORD nTopSamples);
	bool  MoveChannel(int index, unsigned char nDimension, DWORD nStart, int nMove, DWORD nTotal);
	bool  OrderChannel(int index, unsigned char nDimension, int nMethod=1);
	bool  CorrectChannel(int index, unsigned char nDimension, float delta);
	void  ChannelResamples(int index,float newDelta);
	void  CloseChannel(int index);
	bool  InitChannelValue(int index);
	int   ReadChannelInfo(int index,Slf_CHANNEL *Info=NULL);
	int   WriteChannelInfo(int index,Slf_CHANNEL *Info=NULL);
	int   GetMaxObjectNumber();
	int   GetObjectStatus(int index);

//Table Opeartions

	int   OpenTable(const char*name);
	int   CreateTable(short SubAttribute,const char* name,DWORD length=8192,bool bFailExist=TRUE);
	bool  CloseTable(int index);
	bool  SeekTable(int index, int OffsetCount=0, DWORD dwMoveMode=0);
	int   GetTableRecordCount(int index);
	int   SetTableHead(int index,DWORD REC,DWORD COUNT,Slf_TABLE_FIELD *field=NULL);
	bool  SetTableRecordCount(int index,int Count);
	bool  ExpandTable(int index,DWORD BlockNum);
	int   GetTableFieldCount(int index);
	bool  GetTableFieldInfo(int index,Slf_TABLE_FIELD *FieldInfo);
	bool  SetTableFieldInfo(int index,Slf_TABLE_FIELD *FieldInfo);
	int   GetTableRecordLength(int index);
	int   ReadTable(int index, int RecNo, void *buffer);
	int   WriteTable(int index, int RecNo, void *buffer);
	int	  SetWisTableFieldInfo(int index,Slf_TABLE_FIELD *FieldInfo);
	void  InitSlf(int BlockLen,int MaxObjectNumber, int MachineType);
	int   ReadSlfHead();
	int   WriteSlfHead();
	int   ReadSlfObjectEntry();
	int   WriteSlfObjectEntry();

	bool  OpenSlf(const char* LogName,unsigned int nOpenFlags,int BlockLen = 1024,int MaxObjectNumber=1024, int MachineType=MACHINE_TYPE);
	bool  OpenSlf(unsigned int nOpenFlags,int BlockLen = 1024,int MaxObjectNumber=1024, int MachineType=MACHINE_TYPE);
	void  GetSlfHead(Slf_FILE_HEAD* pHead);
	DWORD GetSlfTableLength(char *name);
//Object Operations
	int   FindSlfObjectName(char* name,short Attribute=-1, short SubAttribute=-1, int status=0,int otype=-1);
	bool  DeleteSlfObject(const char* name);
	bool  DiscardSlfObject(const char* name);
	bool  DiscardSlfObject(int index);
	bool  RenameSlfObject(const char* oldName,const char* newName);
	bool  CopySlfObject(const char* oldName,const char* newName, bool bFailExist = TRUE);
	bool  UndeleteSlfObject(const char* name);
	WORD  GetSlfObjectCount();
	void  GetAllSlfObjectEntry(Slf_TABLE_ENTRY* pEntry,WORD count);
	void  GetSlfObjectEntry(int index,Slf_TABLE_ENTRY* pEntry);
	void  SetSlfObjectReserved(int index,char * pEntry);
	void  GetSlfObjectAttribute(int index,short* Attribute, short* SubAttribute);
  	bool  GetSlfObjectEntry(const char* name,Slf_TABLE_ENTRY* pEntry);
	bool  GetSlfObjectAttribute(const char* name,short* Attribute, short* SubAttribute);
	DWORD GetSlfTableLength(int index);
	int OpenSlfTable(int index,short att=-1);
	int   OpenSlfTable(const char*name,short att=-1);
	int   CreateSlfTable(short SubAttribute,const char* name,const char* hzname=NULL,DWORD FieldNum=1,Slf_OBJECT_FIELD *pField=NULL,bool bFailExist=TRUE);
	bool  CloseSlfTable(int index);
	bool  SeekSlfTable(int index, int OffsetCount=0, DWORD dwMoveMode=0);
	int   GetSlfTableRecordCount(int index);
	int   SetSlfTableHead(int index,DWORD REC,DWORD COUNT,Slf_OBJECT_FIELD *field);
	bool  SetSlfTableRecordCount(int index,int Count);
	bool  ExpandSlfTable(int index,int RecNum);
	int   GetSlfTableFieldCount(int index);
	bool  GetSlfTableFieldInfo(int index,Slf_OBJECT_FIELD *FieldInfo);
	bool  SetSlfTableFieldInfo(int index,Slf_OBJECT_FIELD *FieldInfo,bool SetNewFieldInfo=TRUE);
	int   GetSlfTableRecordLength(int index,Slf_OBJECT_FIELD *FieldInfo=NULL);
	int   GetSlfTableFieldOffset(int index,int FieldNo,Slf_OBJECT_FIELD *FieldInfo=NULL);
	int   ReadSlfTable(int index, int EndRec, void *buffer,int FirstRec=0);
	int   WriteSlfTable(int index, int EndRec, void *buffer,int FirstRec=0);
	bool  WriteSlfObjectEntry(int index,Slf_TABLE_ENTRY *obj=NULL);
	bool  DiscardSlfObjectData(int index,bool DeleteField=TRUE);
	int   FindSlfFieldNo(int index,char *FieldName);
//Stream Operations	
	int   OpenStream(const char* name);
	int   CreateStream(short SubAttribute,const char *name,DWORD length=16384,bool bFailExist=TRUE);
	bool  ExpandStream(int index, DWORD BlockNum);
	void  CloseStream(int index);
	bool  SetStreamLength(int index, DWORD length);
	bool  SeekStream(int index, int lMove=0, DWORD dwMoveMode=0);
	bool  ReadStream(int index, DWORD length, LPDWORD lpBytesRead, char *buffer);
	bool  WriteStream(int index, DWORD length, LPDWORD lpBytesWrite, const char *buffer);
	DWORD GetStreamLength(int index);
	int   ReadStreamInfo(int index);
	int   WriteStreamInfo(int index);
	bool CopyFromWisFile(CSlfIO &Source,char *Name,char *NewName);
	bool CopyFromWisFile(CSlfIO &Source,char *Name);
	bool  WriteWisStream(int index, DWORD length, LPDWORD lpBytesWrite, const char *buffer);
	DWORD GetWisStreamLength(int index);
	void  WisPack();
	void  GetData(int RepCode,char *buffer,char *format,char *buf);
	bool  CopyFromFile(CSlfIO &Source,char *Name);
	bool  CopyFromFile(CSlfIO &Source,char *Name,char *NewObject);
	Slf_FILE_HEAD m_SlfHead;
	Slf_DATAPOS_RECORDNUM datarecord;
	Slf_TABLE_History History;
	Slf_TABLE_ENTRY *m_SlfObjectEntry;
	Slf_OBJECT_FIELD *objhead;
	bool WriteSlfHistory(int index,Slf_TABLE_History*pHistory);
	void SetSlfMessage(Slf_FILE_MESSAGE mssage);

	int   OpenSlfStream(const char* name);
	int   CreateSlfStream(short SubAttribute,const char *name,DWORD length=8192,bool bFailExist=TRUE,const char *hzname=NULL);
	bool  ExpandSlfStream(int index, DWORD BlockNum);
	void  CloseSlfStream(int index);
	bool  SetSlfStreamLength(int index, DWORD length);
	bool  SeekSlfStream(int index, int lMove=0, DWORD dwMoveMode=0);
	bool  ReadSlfStream(int index, DWORD length, LPDWORD lpBytesRead, char *buffer);
	bool  WriteSlfStream(int index, DWORD length, LPDWORD lpBytesWrite, const char *buffer);
	DWORD GetSlfStreamLength(int index);
	int   ReadSlfStreamInfo(int index);
	int   WriteSlfStreamInfo(int index);

	int   OpenSlfChannel(const char *name);
	int   OpenSlfChannel(const char *name,short Attribute);
	DWORD ComputerSlfChannelLength(int index);
	bool  CorrectSlfTableField(int index, unsigned char nDimension, float delta);
	void  ChannelSlfResamples(int index,float newDelta);

	void  InitWis(int BlockLen,int MaxObjectNumber, int MachineType);
	int   ReadWisHead();
	int   WriteWisHead();
	int   ReadWisObjectEntry();
	int   WriteWisObjectEntry();
	int   WriteWisObjectEntry(int index,Slf_OBJECT_ENTRY *mEntry=NULL);
	bool  ExpandWisObject(int index, DWORD BlockNum);
	int   WisFindFreeSpace(DWORD BlockNum,int nExceptIndex=-1);
public:
//Slf Operatons
	bool  OpenWis(unsigned int nOpenFlags,int BlockLen = 1024,int MaxObjectNumber=1024, int MachineType=MACHINE_TYPE);
	void  GetWisHead(Slf_HEAD* pHead);
	DWORD GetWisObjectLength(char *name);
	bool  CopyWisObjectToMem(Slf_OBJECT_ENTRY *my,char *name,char *buffer,int Len);
	bool  CopyFromWisFile(Slf_OBJECT_ENTRY *my,char *buffer,int Len);
//Object Operations
	int   FindWisObjectName(char* name,short Attribute=-1, short SubAttribute=-1, int status=0);
	bool  DeleteWisObject(const char* name);
	bool  DiscardWisObject(const char* name);
	bool  DiscardWisObject(int index);
	bool  RenameWisObject(const char* oldName,const char* newName);
	bool  CopyWisObject(const char* oldName,const char* newName, bool bFailExist = TRUE);
	bool  UnDeleteWisObject(const char* name);
	WORD  GetWisObjectCount();
	void  GetAllWisObjectEntry(Slf_OBJECT_ENTRY* pEntry,WORD count);
	void  GetWisObjectEntry(int index,Slf_OBJECT_ENTRY* pEntry);
	void  SetWisObjectReserved(int index,char * pEntry);
	void  GetWisObjectAttribute(int index,short* Attribute, short* SubAttribute);
  	bool  GetWisObjectEntry(const char* name,Slf_OBJECT_ENTRY* pEntry);
	bool  GetWisObjectAttribute(const char* name,short* Attribute, short* SubAttribute);

//Channel Operations
	int   OpenWisChannel(const char *name);
	int   OpenWisChannel(const char *name,short Attribute);
	DWORD ComputerWisChannelLength(Slf_CHANNEL* pInfo,unsigned char nDimension);
	DWORD ComputerWisChannelLength(int index);
	int   GetWisChannelDefaultValue(Slf_CHANNEL* pInfo,unsigned char nDimension,char* buffer,DWORD buflen);
	bool  SetWisChannelPointNum(int index, DWORD nPointNum, DWORD samples1=0,DWORD samples2=0,DWORD samples3=0,DWORD samples4=0);
	DWORD GetWisChannelPointNum(int index,DWORD samples1=0,DWORD samples2=0,DWORD samples3=0,DWORD samples4=0);
	int   CreateWisChannel(short SubAttribute,const char *name,Slf_CHANNEL* pInfo,bool bFailExist=FALSE);
	DWORD SeekWisChannel(int index,DWORD samples1=0,DWORD samples2=0,DWORD samples3=0,DWORD samples4=0);
	DWORD WriteWisChannel(int index,char* buffer,DWORD num, DWORD samples1=0,DWORD samples2=0,DWORD samples3=0,DWORD samples4=0);
	DWORD ReadWisChannel(int index,char* buffer,DWORD num, DWORD samples1=0,DWORD samples2=0,DWORD samples3=0,DWORD samples4=0);
	bool  ExpandWisChannel(int index, unsigned char nDimension, DWORD nSamples, DWORD nTopSamples);
	bool  MoveWisChannel(int index, unsigned char nDimension, DWORD nStart, int nMove, DWORD nTotal);
	bool  OrderWisChannel(int index, unsigned char nDimension, int nMethod=1);
	bool  CorrectWisChannel(int index, unsigned char nDimension, float delta);
	void  WisChannelResamples(int index,float newDelta);
	int   ReadWisChannelInfo(int index,Slf_CHANNEL *Info=NULL);
	int   WriteWisChannelInfo(int index,Slf_CHANNEL *Info=NULL);
	int   CreateWisStream(short SubAttribute,const char *name,DWORD length=8192,bool bFailExist=TRUE);
//Table Opeartions
	bool  SeekWisStream(int index, int lMove=0, DWORD dwMoveMode=0);
	bool  ReadWisStream(int index, DWORD length, LPDWORD lpBytesRead, char *buffer);
	bool  SetWisStreamLength(int index, DWORD length);
	bool  ExpandWisStream(int index, DWORD BlockNum);
	int	  OpenWisStream(const char* namee);
	int   OpenWisTable(const char*name);
	int   CreateWisTable(short SubAttribute,const char* name,DWORD length=8192,bool bFailExist=TRUE);
	bool  SeekWisTable(int index, int OffsetCount=0, DWORD dwMoveMode=0);
	int   GetWisTableRecordCount(int index);
	int   SetWisTableHead(int index,DWORD REC,DWORD COUNT,Slf_TABLE_FIELD *field=NULL);
	bool  SetWisTableRecordCount(int index,int Count);
	bool  ExpandWisTable(int index,DWORD BlockNum);
	int   GetWisTableFieldCount(int index);
	bool  GetWisTableFieldInfo(int index,Slf_TABLE_FIELD *FieldInfo);
	int   GetWisTableRecordLength(int index);
	int   ReadWisTable(int index, int count, void *buffer);
	int   WriteWisTable(int index, int count, void *buffer);
	int	  ReadWisStreamInfo(int index);
	int	  WriteWisStreamInfo(int index);

	void  SlfPack();
	bool  CopySlfObjectToMem(Slf_TABLE_MESSAGE *my,char *name,char *buffer,int Len);
	bool  CopyFromSLFFile(Slf_TABLE_MESSAGE *my,char *buffer,int Len);
	bool  CopyFromSLFFile(CSlfIO &Source,char *Name);
	bool  CopyFromSLFFile(CSlfIO &Source,char *Name,char *NewName);
	void  MoveSlfTable(int index,int RecFist,int RecEnd,int Move);
	void  SlfTableResamples(int index,float newDelta);
	int   ReadSlfTableFieldData(int index,int FieldNo,int RecNum,void *buffer,int FirstRec=0,int Count=0);
	int   WriteSlfTableFieldData(int index,int FieldNo,int RecNum,void *buffer,int FirstRec=0,int Count=0);
	int   DeleteSlfTableRecord(int index,int RecNum,int FirstRec);
	void  GetSlfMessage(Slf_FILE_MESSAGE &mssage);
	//whp add
	short GetObjectType(int index);
	short GetObjectType(const char* name);
	short  GetWisObjectType(int index);
	short  GetWisObjectType(const char* name);
	short  GetSlfObjectType(int index);
	short  GetSlfObjectType(const char* name);
	bool  RenameWisObject(int index,const char* newNamee);
	bool  RenameSlfObject(int index,const char* newNamee);
	bool  RenameObject(int index,const char* newNamee);
	void  Clear();
	int   FindWisObjectIndex(const char* namee,int status=0);
	int   FindSlfObjectIndex(const char* namee,int status=0);
	int   CreateTable(short Attribute,const char* name,const char* hzname,DWORD FieldNum=0,Slf_OBJECT_FIELD *pField=NULL,bool bFailExist=NULL);
	HANDLE mHandle;
	int* m_Value;
	//whp add 2011.12.18
	bool  UndeleteSlfObject(int index);//如果有多个同名的删除对象，可以选择恢复
	bool  UnDeleteObject(int index);
	void  GetSlfObjectBaseInf(int index,Slf_OBJECT_BASE_INF* pBaseInf);
  	bool  GetSlfObjectBaseInf(const char* name,Slf_OBJECT_BASE_INF* pBaseInf);
	bool  WriteSlfObjectBaseInf(int index,Slf_OBJECT_BASE_INF *obj);
	bool  IsObject(int index);
	bool  BackUpFile();
	bool IsChange;
	char *GetSlfFileName();
	int isShengLi;
};
void SLFIO_EXPORT WriteShiftMessage(CSlfIO&mem,CString &szBuffer,QString name,QString card=QString());
float SLFIO_EXPORT ConvertDataByString(QString szText);
QString SLFIO_EXPORT ConvertDataByFloat(float fValue);
#endif  // __SlfIO_H__