You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
801 lines
47 KiB
801 lines
47 KiB
#include "FileStream.h"
|
|
#include <time.h>
|
|
#include <memory.h>
|
|
#include <vector>
|
|
#include <algorithm>
|
|
/*******************************************************************************
|
|
类ParamObject实现代码
|
|
*******************************************************************************/
|
|
|
|
static std::string tolowerstring(std::string& str)
|
|
{
|
|
transform(str.begin(), str.end(), str.begin(), ::towlower);
|
|
return str;
|
|
}
|
|
|
|
ParamObject::ParamObject()
|
|
{
|
|
curr_pos=0;
|
|
}
|
|
ParamObject::~ParamObject()
|
|
{
|
|
curr_pos=0;
|
|
}
|
|
//将另外一个对象的所有参数加到这个对象中
|
|
void ParamObject ::AppendForm(ParamObject *other)
|
|
{
|
|
if(other!=NULL)
|
|
{
|
|
//将新对象有效字节数拷贝到本对象中
|
|
mParamsBuffer.AppendBlobContent(other->mParamsBuffer.GetBlobPtr(),other->mParamsBuffer.GetBlobLength());
|
|
|
|
//生成参数新的索引
|
|
|
|
std::map<std::string,unsigned long>::iterator itrOther;
|
|
std::map<std::string,unsigned long>::iterator itrFind;
|
|
for(itrOther= other->paramNames.begin(); itrOther!=other->paramNames.end(); )
|
|
{
|
|
//将每一个参数的名字和它对应字符流中超始位置放到map中
|
|
//如果本对象已有此参数，就将本对象中参数置为PARAMS_UNVALID_TYPE无效节点
|
|
itrFind = paramNames.find(itrOther->first);
|
|
if( itrFind!= paramNames.end())
|
|
{
|
|
//将本对象中已有的同名称节点设置为无效节点
|
|
ParamNode *pNode;
|
|
pNode = (ParamNode *)( (unsigned char*)mParamsBuffer.GetBlobPtr()+ itrFind->second );
|
|
pNode->type = PARAMS_UNVALID_TYPE;
|
|
|
|
//并更新它的位置信息
|
|
itrFind->second = mParamsBuffer.GetBlobLength() + itrOther->second ;
|
|
}
|
|
else
|
|
{
|
|
paramNames.insert(std::map<std::string,unsigned long>::value_type(itrOther->first,mParamsBuffer.GetBlobLength()+itrOther->second ));
|
|
}
|
|
itrOther++;
|
|
}
|
|
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
void ParamObject::ReName(const char *src_paramname, const char *dst_paramname)
|
|
{
|
|
std::map<std::string,unsigned long>::iterator itr;
|
|
|
|
//如果dst_paramname已经存在，则不允许改成dst_paramname
|
|
itr = paramNames.find(dst_paramname);
|
|
if(itr!=paramNames.end())
|
|
{
|
|
throw ERPException(EERROR,SYSTEM_ERROR,"can,t rename [%s] to [%s] , param [%s] exist!",src_paramname,dst_paramname,dst_paramname);
|
|
}
|
|
|
|
itr = paramNames.find(src_paramname);
|
|
if(itr==paramNames.end())
|
|
{
|
|
throw ERPException(EERROR,SYSTEM_ERROR,"can,t rename [%s] to [%s] , param [%s] not exist!",src_paramname,dst_paramname,src_paramname);
|
|
}
|
|
|
|
|
|
|
|
unsigned int node_start_pos;
|
|
ParamNode rNode;
|
|
|
|
BlobBuffer TmpParamsBuffer;
|
|
//先计算位置，找到原结点的数据
|
|
node_start_pos = itr->second;
|
|
memcpy((unsigned char*)&rNode, (unsigned char*)mParamsBuffer.GetBlobPtr()+node_start_pos, sizeof(ParamNode));
|
|
|
|
paramNames.erase(itr);
|
|
|
|
|
|
//更新索引值
|
|
//paramNames.Insert(key,length);
|
|
paramNames.insert(std::map<std::string,unsigned long>::value_type(dst_paramname,node_start_pos));
|
|
|
|
//更新数据值
|
|
|
|
strncpy(rNode.name, dst_paramname,sizeof(rNode.name));
|
|
memcpy((unsigned char*)mParamsBuffer.GetBlobPtr()+node_start_pos, (unsigned char*)&rNode ,sizeof(ParamNode));
|
|
|
|
}
|
|
|
|
/*
|
|
----刷新数据，重新排列，清空无效节点,
|
|
分配一块大内存，然后把数据一个一个拷过去
|
|
*/
|
|
void ParamObject::Refresh()
|
|
{
|
|
if(getParamCount()<1)
|
|
return;
|
|
|
|
BlobBuffer TmpParamsBuffer;
|
|
|
|
unsigned int start_pos =0;
|
|
unsigned int end_pos =0;
|
|
ParamNode *pNode;
|
|
|
|
//BiNode *pFindBiNode;
|
|
for( ; start_pos< mParamsBuffer.GetBlobLength() ; start_pos = end_pos)
|
|
{
|
|
//计算位置
|
|
pNode = (ParamNode *)( (unsigned char*)mParamsBuffer.GetBlobPtr() +start_pos );
|
|
end_pos += sizeof(ParamNode)+pNode->length;
|
|
|
|
//如果是有效节点，就生成新的参数索引，并拷贝数据进临时缓冲中
|
|
if(pNode->type!=PARAMS_UNVALID_TYPE)
|
|
{
|
|
//首先更新所有有效结点的索引
|
|
itr = paramNames.find(pNode->name);
|
|
if(itr != paramNames.end())
|
|
itr->second = TmpParamsBuffer.GetBlobLength();
|
|
|
|
//再拷贝数据到新的大内存中--
|
|
TmpParamsBuffer.AppendBlobContent(mParamsBuffer.GetBlobPtr()+start_pos , end_pos-start_pos);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mParamsBuffer.SetBlobContent(TmpParamsBuffer.GetBlobPtr(),TmpParamsBuffer.GetBlobLength() );
|
|
First();
|
|
}
|
|
//---删除某个参数-----------
|
|
void ParamObject::remove(const char *paramName)
|
|
{
|
|
std::map<std::string,unsigned long>::iterator itr;
|
|
itr = paramNames.find(paramName);
|
|
if(itr==paramNames.end())
|
|
{
|
|
return;
|
|
}
|
|
|
|
unsigned int node_start_pos;
|
|
ParamNode rNode;
|
|
|
|
BlobBuffer TmpParamsBuffer;
|
|
//先计算位置
|
|
node_start_pos = itr->second;
|
|
memcpy((unsigned char*)&rNode, (unsigned char*)mParamsBuffer.GetBlobPtr()+node_start_pos, sizeof(ParamNode));
|
|
|
|
TmpParamsBuffer.SetBlobContent(mParamsBuffer.GetBlobPtr(),node_start_pos);
|
|
TmpParamsBuffer.AppendBlobContent(mParamsBuffer.GetBlobPtr()+ node_start_pos+sizeof(ParamNode)+ rNode.length,mParamsBuffer.GetBlobLength()-rNode.length);
|
|
mParamsBuffer.SetBlobContent(TmpParamsBuffer.GetBlobPtr(),TmpParamsBuffer.GetBlobLength());
|
|
|
|
paramNames.erase(itr);
|
|
|
|
|
|
//重建此参数后面所有参数的参数索引
|
|
ParamNode *pNode;
|
|
for( ; node_start_pos<mParamsBuffer.GetBlobLength(); )
|
|
{
|
|
//计算位置
|
|
pNode = (ParamNode *)( (unsigned char*)mParamsBuffer.GetBlobPtr()+node_start_pos );
|
|
std::map<std::string,unsigned long>::iterator itr;
|
|
itr = paramNames.find(pNode->name);
|
|
if(itr!= paramNames.end())
|
|
{
|
|
itr->second = node_start_pos;
|
|
}
|
|
node_start_pos += sizeof(ParamNode)+pNode->length;
|
|
}
|
|
|
|
|
|
}
|
|
//清空参数对象中的内容
|
|
void ParamObject::Clear()
|
|
{
|
|
paramNames.clear();
|
|
mParamsBuffer.ClearContent();
|
|
curr_pos=0;
|
|
}
|
|
//保存整型参数
|
|
void ParamObject::putInteger(const char *paramName,int paramValue)
|
|
{
|
|
char sValue[64];
|
|
sprintf(sValue, "%d",paramValue );
|
|
putString( paramName,sValue,PARAMS_INTEGER);
|
|
}
|
|
|
|
void ParamObject::putIntegerNull(const char *paramName,int paramValue)
|
|
{
|
|
char sValue[64];
|
|
if( paramValue==0 )
|
|
sValue[0] = '\0';
|
|
else
|
|
sprintf(sValue, "%d",paramValue );
|
|
putString( paramName,sValue,PARAMS_INTEGER );
|
|
}
|
|
|
|
//保存长整型参数
|
|
void ParamObject::putLong(const char *paramName,long paramValue)
|
|
{
|
|
char sValue[64];
|
|
sprintf(sValue, "%ld",paramValue );
|
|
putString( paramName,sValue ,PARAMS_LONG);
|
|
}
|
|
|
|
//保存浮点型串参数
|
|
void ParamObject::putFloat(const char *paramName,float paramValue,
|
|
const int Precision)
|
|
{
|
|
char sFmtString[25];
|
|
char sValue[64];
|
|
sprintf(sFmtString, "%%.%df",Precision );
|
|
sprintf(sValue, sFmtString,paramValue );
|
|
putString( paramName,sValue,PARAMS_FLOAT);
|
|
}
|
|
|
|
//保存双精度参数
|
|
void ParamObject::putDouble(const char *paramName,double paramValue,
|
|
const int Precision)
|
|
{
|
|
char sFmtString[25];
|
|
char sValue[64];
|
|
|
|
sprintf(sFmtString, "%%.%dlf",Precision );
|
|
sprintf(sValue, sFmtString,paramValue );
|
|
putString( paramName,sValue,PARAMS_DOUBLE);
|
|
}
|
|
|
|
/*
|
|
保存字符串参数到对象中，
|
|
注，对于字符串参数，02版本为了提高效率，将'\0'字符也存储到序列中了
|
|
这样的话在GetString时就可以不用拷贝字符串单独处理
|
|
*/
|
|
|
|
void ParamObject::putString(const char *paramName,const char *paramValue,unsigned char dataType/*=PARAMS_STRING*/)
|
|
{
|
|
unsigned int start_pos;
|
|
|
|
std::map<std::string,unsigned long>::iterator itr;
|
|
itr = paramNames.find(paramName);
|
|
if(itr!= paramNames.end())
|
|
{
|
|
start_pos =itr->second;
|
|
|
|
ParamNode *pNode;
|
|
pNode = (ParamNode *)( (unsigned char*)mParamsBuffer.GetBlobPtr() +start_pos );
|
|
pNode->type = PARAMS_UNVALID_TYPE; //将原有节点设置为无效节点
|
|
paramNames.erase(itr);
|
|
}
|
|
|
|
putStream(paramName,(const unsigned char *)paramValue,strlen(paramValue),false,dataType);
|
|
}
|
|
|
|
//保存参数流到对象中
|
|
void ParamObject::putStream(const char *paramName,const unsigned char *paramValue,unsigned int len
|
|
,bool redu_check,const unsigned char dataType)
|
|
{
|
|
if(redu_check)
|
|
{
|
|
std::map<std::string,unsigned long>::iterator itr;
|
|
itr = paramNames.find(paramName);
|
|
if(itr!=paramNames.end() && dataType==PARAMS_STREAM)
|
|
{
|
|
throw ERPException(EERROR,SYSTEM_ERROR,"已经有参数流[%s]，不能重复存放此参数流！",paramName);
|
|
}
|
|
}
|
|
|
|
//新建索引
|
|
//paramNames.Insert(key,length);
|
|
unsigned long size = mParamsBuffer.GetBlobLength();
|
|
paramNames.insert(std::map<std::string,unsigned long>::value_type(paramName,size));
|
|
|
|
ParamNode cNode;
|
|
memset(&cNode,'\0',sizeof(ParamNode));
|
|
memset(cNode.name,'\0',sizeof(cNode.name));
|
|
cNode.length = len;
|
|
cNode.type = dataType;
|
|
strncpy(cNode.name, paramName, sizeof(cNode.name));
|
|
|
|
mParamsBuffer.AppendBlobContent((unsigned char *)&cNode,sizeof(ParamNode));
|
|
mParamsBuffer.AppendBlobContent(paramValue,cNode.length);
|
|
}
|
|
|
|
|
|
void ParamObject::putBlob(const char *paramName,BlobBuffer &blob)
|
|
{
|
|
putStream(paramName,blob.GetBlobPtr() ,blob.GetBlobLength(),true,PARAMS_BLOB );
|
|
}
|
|
|
|
/*
|
|
//保存序列参数
|
|
void ParamObject::putDataSet(const char *paramName,DataSet &dataset)
|
|
{
|
|
BlobBuffer blobBuffer;
|
|
dataset.Serialize(blobBuffer) ;
|
|
|
|
putStream( paramName,blobBuffer.GetBlobPtr(),blobBuffer.GetBlobLength(),true,PARAMS_DATASET );
|
|
}
|
|
*/
|
|
//支持参数对象嵌套
|
|
void ParamObject::putParamObject(const char *paramName,ParamObject &object)
|
|
{
|
|
BlobBuffer blobBuffer;
|
|
object.SaveToBlob(blobBuffer);
|
|
putStream( paramName,blobBuffer.GetBlobPtr(),blobBuffer.GetBlobLength(),true,PARAMS_ParamObject );
|
|
}
|
|
|
|
//读取整型参数
|
|
int ParamObject::getInteger(const char *paramName)
|
|
{
|
|
return(atoi(getString(paramName,PARAMS_INTEGER).c_str()));
|
|
}
|
|
|
|
//读取长整型参数
|
|
long ParamObject::getLong(const char *paramName)
|
|
{
|
|
return(atol(getString(paramName,PARAMS_LONG).c_str()));
|
|
}
|
|
|
|
//取指定参数在对象中的指针位置
|
|
int ParamObject::getParamPos(const char *paramName,unsigned char **stream,unsigned int &length,unsigned char &pNodeType,const unsigned char dataType)
|
|
{
|
|
unsigned int pos;
|
|
*stream =0;
|
|
|
|
std::map<std::string,unsigned long>::iterator itr;
|
|
std::string sName(paramName);
|
|
itr = paramNames.find(sName);
|
|
if(itr== paramNames.end())
|
|
{
|
|
return 0;
|
|
}
|
|
pos =itr->second;
|
|
|
|
ParamNode *pNode;
|
|
pNode = (ParamNode *)( (unsigned char*)mParamsBuffer.GetBlobPtr()+pos );
|
|
|
|
if (0 == strcmp(pNode->name, paramName))
|
|
{
|
|
*stream = (unsigned char *)mParamsBuffer.GetBlobPtr() + pos + sizeof(ParamNode);
|
|
pNodeType = pNode->type;
|
|
|
|
length = pNode->length;
|
|
}
|
|
else
|
|
length = 0;
|
|
|
|
return (0==*stream)? 0:1;
|
|
}
|
|
|
|
//读字符串型参数，不需考虑结束符'\0'，因为put的时候已将结束符'\0'存入
|
|
std::string ParamObject::getString(const char *paramName,unsigned char dataType/*=PARAMS_STRING*/)
|
|
{
|
|
std::string sTemp="";
|
|
unsigned char tail_char;
|
|
unsigned int length;
|
|
unsigned char NodeType;
|
|
unsigned char *pParamPos;
|
|
if(0!= getParamPos(paramName,&pParamPos,length,NodeType,dataType))
|
|
{
|
|
//因PutStream时未处理字符串的结束符'\0'，在这里需要加上
|
|
tail_char = *(pParamPos + length);
|
|
*(pParamPos + length) ='\0';
|
|
sTemp = (char *)(pParamPos);
|
|
*(pParamPos + length) =tail_char;
|
|
}
|
|
else
|
|
throw ERPException(EERROR,SYSTEM_ERROR,"parameter[%s]not found！",paramName);
|
|
|
|
return sTemp;
|
|
}
|
|
|
|
|
|
bool ParamObject::getBlob(const char *paramName, BlobBuffer &blob,bool bException)
|
|
{
|
|
unsigned int length=0;
|
|
unsigned char *pParamPos = getBlobEx(paramName, length);
|
|
if (NULL == pParamPos)
|
|
{
|
|
if (0 == length)
|
|
{
|
|
if (bException)
|
|
throw ERPException(EERROR, SYSTEM_ERROR, "blob parameter[%s]not found！", paramName);
|
|
else
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (bException)
|
|
throw ERPException(EERROR, SYSTEM_ERROR, "not a blob parameter[%s]！", paramName);
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
blob.SetBlobContent(pParamPos, length);
|
|
return true;
|
|
}
|
|
|
|
unsigned char *ParamObject::getBlobEx(const char *paramName, unsigned int &length)
|
|
{
|
|
unsigned char NodeType;
|
|
unsigned char *pParamPos;
|
|
if (0 != getParamPos(paramName, &pParamPos, length, NodeType, PARAMS_BLOB))
|
|
{
|
|
if (PARAMS_BLOB == NodeType)
|
|
{
|
|
return pParamPos;
|
|
}
|
|
else
|
|
return NULL;
|
|
}
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
//判断是否有送某参数
|
|
bool ParamObject::isExist(const char *paramName)
|
|
{
|
|
//return paramNames.Find(DataSet::MyHash(paramName,strlen(paramName)));
|
|
return (paramNames.find(paramName)!=paramNames.end());
|
|
|
|
}
|
|
//读浮点型参数
|
|
float ParamObject::getFloat(const char *paramName )
|
|
{
|
|
return (float)(atof(getString(paramName,PARAMS_FLOAT).c_str()));
|
|
}
|
|
|
|
//读双精度参数
|
|
double ParamObject::getDouble(const char *paramName )
|
|
{
|
|
return(atof(getString(paramName,PARAMS_DOUBLE).c_str()));
|
|
}
|
|
|
|
|
|
/*
|
|
//读取序列参数
|
|
void ParamObject::getDataSet(const char *paramName,DataSet &dataset )
|
|
{
|
|
unsigned int len;
|
|
unsigned char NodeType;
|
|
unsigned char *stream;
|
|
if(getParamPos(paramName,&stream,len,NodeType,PARAMS_DATASET))
|
|
{
|
|
if(PARAMS_DATASET==NodeType)
|
|
{
|
|
try
|
|
{
|
|
dataset.UnSerialize(stream,len);
|
|
dataset.setName(paramName);
|
|
}
|
|
catch(ERPException &e )
|
|
{
|
|
char c_time[128];
|
|
tm *temptm;
|
|
time_t temptime;
|
|
temptime= time(0);
|
|
temptm = localtime(&temptime);
|
|
sprintf(c_time,"%d年%02d月%02d日 %02d:%02d:%02d",
|
|
temptm->tm_year+1900,temptm->tm_mon+1,temptm->tm_mday,
|
|
temptm->tm_hour,temptm->tm_min,temptm->tm_sec);
|
|
WriteLog("ParamObject.log","a+",c_time,dataset.GetFieldNames().c_str());
|
|
sprintf(c_time,"%d%02d%02d%02d%02d%02d_异常数据.log",
|
|
temptm->tm_year+1900,temptm->tm_mon+1,temptm->tm_mday,
|
|
temptm->tm_hour,temptm->tm_min,temptm->tm_sec );
|
|
SaveToFile(c_time);
|
|
throw e;
|
|
}
|
|
}
|
|
else
|
|
throw ERPException(EERROR,SYSTEM_ERROR,"DataSet parameter[%s]not found！",paramName);
|
|
}
|
|
else
|
|
{
|
|
throw ERPException(EERROR,SYSTEM_ERROR,"DataSet parameter[%s]not found！",paramName);
|
|
}
|
|
}
|
|
*/
|
|
//读取嵌套的参数对象
|
|
void ParamObject::getParamObject(const char *paramName,ParamObject &obj)
|
|
{
|
|
unsigned int len;
|
|
unsigned char NodeType;
|
|
unsigned char *stream;
|
|
if(getParamPos(paramName,&stream,len,NodeType,PARAMS_ParamObject))
|
|
{
|
|
if(PARAMS_ParamObject==NodeType)
|
|
{
|
|
try
|
|
{
|
|
obj.LoadFromStream((const unsigned char *)stream,len);
|
|
}
|
|
catch(ERPException &e )
|
|
{
|
|
char c_time[128];
|
|
tm *temptm;
|
|
time_t temptime;
|
|
temptime= time(0);
|
|
temptm = localtime(&temptime);
|
|
sprintf(c_time,"%d年%02d月%02d日 %02d:%02d:%02d",
|
|
temptm->tm_year+1900,temptm->tm_mon+1,temptm->tm_mday,
|
|
temptm->tm_hour,temptm->tm_min,temptm->tm_sec);
|
|
sprintf(c_time,"%d%02d%02d%02d%02d%02d_异常数据.log",
|
|
temptm->tm_year+1900,temptm->tm_mon+1,temptm->tm_mday,
|
|
temptm->tm_hour,temptm->tm_min,temptm->tm_sec );
|
|
SaveToFile(c_time);
|
|
throw e;
|
|
}
|
|
}
|
|
else
|
|
throw ERPException(EERROR,SYSTEM_ERROR,"ParamObject parameter[%s]not found！",paramName);
|
|
}
|
|
else
|
|
{
|
|
throw ERPException(EERROR,SYSTEM_ERROR,"ParamObject parameter[%s]not found！",paramName);
|
|
}
|
|
}
|
|
|
|
//当前参数指向第一个参数
|
|
void ParamObject::First()
|
|
{
|
|
curr_pos=0;
|
|
}
|
|
//当前参数指向下一个参数
|
|
void ParamObject::Next()
|
|
{
|
|
if(curr_pos>=mParamsBuffer.GetBlobLength())
|
|
return;
|
|
|
|
ParamNode *pNode;
|
|
pNode = (ParamNode *)( (unsigned char*)mParamsBuffer.GetBlobPtr()+curr_pos );
|
|
curr_pos +=sizeof(ParamNode)+pNode->length;
|
|
if(pNode->type==PARAMS_UNVALID_TYPE)
|
|
Next();
|
|
}
|
|
//判断是否已到了结尾
|
|
int ParamObject::Eof()
|
|
{
|
|
return (mParamsBuffer.GetBlobLength()==curr_pos)? 1:0;
|
|
}
|
|
//得到当前参数的名称
|
|
std::string ParamObject::getParamName()
|
|
{
|
|
ParamNode *pNode;
|
|
pNode = (ParamNode *)( (unsigned char*)mParamsBuffer.GetBlobPtr()+curr_pos );
|
|
return (pNode->name);
|
|
}
|
|
//得到当前参数的名称
|
|
int ParamObject::getParamType()
|
|
{
|
|
ParamNode *pNode;
|
|
pNode = (ParamNode *)( (unsigned char*)mParamsBuffer.GetBlobPtr()+curr_pos );
|
|
return (pNode->type);
|
|
}
|
|
//得到当前参数的值
|
|
int ParamObject::getParamValue(unsigned char **value)
|
|
{
|
|
ParamNode *pNode;
|
|
pNode = (ParamNode *)( (unsigned char*)mParamsBuffer.GetBlobPtr()+curr_pos );
|
|
if(pNode->length<1)
|
|
{
|
|
throw ERPException(EERROR,SYSTEM_ERROR,"该参数不存在！");
|
|
}
|
|
*value=new unsigned char[pNode->length];
|
|
memcpy((unsigned char *)*value,(unsigned char *)mParamsBuffer.GetBlobPtr()+curr_pos+sizeof(ParamNode),pNode->length);
|
|
return pNode->length;
|
|
}
|
|
|
|
void ParamObject::getParamValue(BlobBuffer *pBlob,unsigned char fillEndChar)
|
|
{
|
|
ParamNode *pNode;
|
|
pNode = (ParamNode *)( (unsigned char*)mParamsBuffer.GetBlobPtr()+curr_pos );
|
|
if(pNode->length<1)
|
|
{
|
|
throw ERPException(EERROR,SYSTEM_ERROR,"该参数不存在！");
|
|
}
|
|
pBlob->SetBlobContent((unsigned char *)mParamsBuffer.GetBlobPtr()+curr_pos+sizeof(ParamNode),pNode->length);
|
|
if(1==fillEndChar)
|
|
pBlob->AppendBlobContentChar('\0');
|
|
}
|
|
//得到当前的参数的字符串值，如果当前参数是流就返回空
|
|
std::string ParamObject::getParamValue()
|
|
{
|
|
ParamNode *pNode;
|
|
pNode =(ParamNode *)( (unsigned char*)mParamsBuffer.GetBlobPtr()+curr_pos );
|
|
if(PARAMS_STREAM==pNode->type)
|
|
return "流";
|
|
|
|
return std::string((char*)mParamsBuffer.GetBlobPtr() + curr_pos + sizeof(ParamNode), pNode->length);
|
|
|
|
/* std::vector<char> buffer(pNode->length + 1);
|
|
std::memcpy(buffer.data(), (char*)mParamsBuffer.GetBlobPtr() + curr_pos + sizeof(ParamNode), pNode->length);
|
|
std::memset(buffer.data() + pNode->length, '\0', 1);
|
|
|
|
return buffer.data();
|
|
*/
|
|
}
|
|
//--返回实际字节流指针-----
|
|
const unsigned char *ParamObject::getBytePtr()
|
|
{
|
|
return mParamsBuffer.GetBlobPtr();
|
|
}
|
|
//---返回实际字节流大小----
|
|
unsigned int ParamObject::getByteLength()
|
|
{
|
|
return mParamsBuffer.GetBlobLength();
|
|
}
|
|
//返回当胶字节总长度
|
|
unsigned int ParamObject::getAllByteLength()
|
|
{
|
|
return mParamsBuffer.GetBlobBufferLength();
|
|
}
|
|
//clone
|
|
void ParamObject::Clone(ParamObject *pObject)
|
|
{
|
|
mParamsBuffer.SetBlobContent(pObject->mParamsBuffer.GetBlobPtr(),pObject->mParamsBuffer.GetBlobLength());
|
|
|
|
curr_pos =0; //当前指针位置
|
|
InitParamNames();
|
|
}
|
|
|
|
//从Blob对象中反序列化
|
|
void ParamObject::LoadFromBlob(BlobBuffer &blob)
|
|
{
|
|
LoadFromStream(blob.GetBlobPtr(),blob.GetBlobLength());
|
|
}
|
|
|
|
//序列化到Blob对象中
|
|
void ParamObject::SaveToBlob(BlobBuffer &blob)
|
|
{
|
|
blob.SetBlobContent(mParamsBuffer.GetBlobPtr(),mParamsBuffer.GetBlobLength());
|
|
}
|
|
|
|
|
|
/*/////////////////////////////////////////////////////////////////////////////
|
|
load param from the stream buffer
|
|
initial the paramnames
|
|
/////////////////////////////////////////////////////////////////////////////*/
|
|
void ParamObject::LoadFromStream(const unsigned char*in_buffer,unsigned int len)
|
|
{
|
|
mParamsBuffer.SetBlobContent(in_buffer,len);
|
|
curr_pos = 0; //当前指针位置
|
|
InitParamNames();
|
|
}
|
|
//load the ParamObject from the file which has the ParamObject format
|
|
void ParamObject::LoadFromFile(const char *file_name)
|
|
{
|
|
mParamsBuffer.LoadBlobFromFile(file_name);
|
|
curr_pos = 0; //当前指针位置
|
|
InitParamNames();
|
|
}
|
|
//save the ParamObject as the ParamObject format
|
|
void ParamObject::SaveToFile(const char *file_name)
|
|
{
|
|
mParamsBuffer.SaveBlobToFile(file_name);
|
|
}
|
|
|
|
/*/////////////////////////////////////////////////////////////////////////////
|
|
----regenerate the param names and the index ---
|
|
////////////////////////////////////////////////////////////////////////////*/
|
|
void ParamObject::InitParamNames()
|
|
{
|
|
ParamNode *pNode;
|
|
curr_pos=0;
|
|
paramNames.clear();
|
|
//unsigned int key;
|
|
std::map<std::string,unsigned long>::iterator itr;
|
|
while(curr_pos< mParamsBuffer.GetBlobLength())
|
|
{
|
|
pNode =(ParamNode *)( (unsigned char*)mParamsBuffer.GetBlobPtr()+curr_pos );
|
|
/*
|
|
key = DataSet::MyHash(pNode->name,strlen(pNode->name));
|
|
if(paramNames.Find(key))
|
|
paramNames.Delete(key);
|
|
paramNames.Insert(key,curr_pos);
|
|
*/
|
|
itr = paramNames.find(pNode->name);
|
|
if(itr != paramNames.end())
|
|
paramNames.erase(itr);
|
|
paramNames.insert(std::map<std::string,unsigned long>::value_type(pNode->name,curr_pos));
|
|
|
|
curr_pos+=sizeof(ParamNode)+pNode->length;
|
|
}
|
|
curr_pos=0;
|
|
}
|
|
//返回参数个数，如果有多次putstring同一个参数，则size无意义，
|
|
unsigned int ParamObject::getParamCount()
|
|
{
|
|
return paramNames.size();
|
|
}
|
|
|
|
void ParamObject::WriteLog(const char *file_name,const char *open_flag, const char *head_title,const char *text)
|
|
{
|
|
FILE *fp;
|
|
|
|
fp = fopen(file_name,open_flag);
|
|
fprintf(fp,"%s\n",head_title);
|
|
if(NULL==text)
|
|
{
|
|
First();
|
|
while( !Eof() )
|
|
{
|
|
fprintf(fp," %s=%s\n",getParamName().c_str(), getParamValue().c_str());
|
|
Next();
|
|
}
|
|
}
|
|
else
|
|
fprintf(fp," %s=%s\n",getParamName().c_str(),text);
|
|
|
|
fclose(fp);
|
|
}
|
|
|
|
|
|
CFileStream::CFileStream(const CFileStream &other)
|
|
{
|
|
|
|
}
|
|
|
|
CFileStream &CFileStream::operator=(const CFileStream &)
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
CFileStream::CFileStream()
|
|
{
|
|
|
|
}
|
|
|
|
CFileStream::~CFileStream()
|
|
{
|
|
|
|
}
|
|
//加入文件
|
|
bool CFileStream::PutFile(const char *fileName, BlobBuffer &blob)
|
|
{
|
|
//改为不区分大小写吧，soui ui库大小写比较乱．．.
|
|
std::string file_name(fileName);
|
|
file_name = tolowerstring(file_name);
|
|
|
|
this->putBlob(file_name.c_str(), blob);
|
|
return true;
|
|
}
|
|
|
|
//加入文件
|
|
bool CFileStream::GetFile(const char *fileName, BlobBuffer &blob)
|
|
{
|
|
//改为不区分大小写吧，soui ui库大小写比较乱．．.
|
|
std::string file_name(fileName);
|
|
file_name = tolowerstring(file_name);
|
|
|
|
#ifdef _DEBUG
|
|
return getBlob(file_name.c_str(), blob, true);
|
|
#else
|
|
return getBlob(file_name.c_str(), blob, false);
|
|
#endif
|
|
}
|
|
|
|
int CFileStream::GetFileCount()
|
|
{
|
|
return getParamCount();
|
|
}
|
|
|
|
const unsigned char *CFileStream::GetAllBasePtr()
|
|
{
|
|
return getBytePtr(); //返回内部字节流的指针
|
|
}
|
|
|
|
|
|
unsigned long CFileStream::GetFileSize(const char *fileName)
|
|
{
|
|
unsigned int length = 0;
|
|
if (NULL != getBlobEx(fileName, length))
|
|
return length;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
const unsigned char *CFileStream::GetFilePtr(const char *fileName)
|
|
{
|
|
unsigned int length = 0;
|
|
unsigned char *pParamPos = getBlobEx(fileName, length);
|
|
return pParamPos;
|
|
}
|
|
|
|
unsigned int CFileStream::GetAllSize()
|
|
{
|
|
return getByteLength();
|
|
}
|
|
|