xcommon.cpp

符合移动协议的见空系统,很有使用简直,希望多下载

	}
	return i;
}
int  SimFileMap::PrintSortData(LPCSTR lpFilename,bool flag)
{
    FILE *fp = fopen(lpFilename,"w");
    int i;
	for(i=0;i<m_iCount;i++)
	{
		if(flag)
			fprintf(fp,"%s\n",*(m_pSearchArray[i]));
		else
			fprintf(fp,"%s\n",*(m_pSearchArray[m_iCount-i-1]));
	}
	fclose(fp);
	return i;
}
char *SimFileMap::GetLine(char* OutLine,int line_no)
{
	if(line_no<m_iCount&&line_no>=0)
	{
		strcpy(OutLine,m_pHead[line_no]);
		return OutLine;
	}
	else
	{
		OutLine[0]=0;
		return NULL;
	}
}
char *SimFileMap::GetLineContent(char* OutLine,int line_no)
{
	if(line_no<m_iCount&&line_no>=0)
	{
		char *p1 = strchr(m_pHead[line_no],'\t');
		if(p1)
			strcpy(OutLine,p1);
		else
			strcpy(OutLine,m_pHead[line_no]);
		return OutLine;
	}
	else
	{
		return NULL;
	}
}
long SimFileMap::GetOffset(int line_no)
{
	if(line_no>=m_iCount || line_no<0)
		return -1;
	return m_pOffsetArray[line_no];
}
char* SimFileMap::GetLine(char *OutLine)
{
	if(m_iCurrentPos<m_iCount)
	{
		strcpy(OutLine,m_pHead[m_iCurrentPos++]);
		return OutLine;
	}
	return NULL;
}
char* SimFileMap::GetLine(int lno)
{
	if(lno<m_iCount&&lno>=0)
		return m_pHead[lno];
	else
		return NULL;
}
char* SimFileMap::GetLine()
{
	if(m_iCurrentPos<m_iCount)
		return m_pHead[m_iCurrentPos++];
	else
		return NULL;
}
char* SimFileMap::replace_line(int line_num,char* new_line)
{
	if(line_num>=m_iCount)
		return NULL;
	delete []m_pHead[line_num];
	m_pHead[line_num]=new char[strlen(new_line)+2];
	strcpy(m_pHead[line_num],new_line);
	return m_pHead[line_num];
}
int SimFileMap::Load(CWorkFile &WK,REMOVEBLANK flag)
{
	char InLine[12000],*temp;
	WK.rewind();
	m_iMaxCount=WK.file_line_cnt(0);
	long CurrOff=0;
	m_pHead=new  char*[m_iMaxCount];	
	m_pOffsetArray = new int[m_iMaxCount];
	m_pSearchArray =new char**[m_iMaxCount];
	WK.rewind();
	int len;
	while(WK.GetLine(InLine))
	{
		if((flag==REM_BLK)&&(!InLine[0]))
			continue;
		len=strlen(InLine);
		temp=new char[len+2];
		strcpy(temp,InLine);
		m_pHead[m_iCount]=temp;
		m_pSearchArray[m_iCount]=&m_pHead[m_iCount];
		m_pOffsetArray[m_iCount]=CurrOff;
		CurrOff+=len+2;
		m_iCount++;
	}
	WK.rewind();
	return m_iCount;
}
void SimFileMap::rewind()
{
	m_iCurrentPos=0;
}
int SimFileMap::LineCount()
{
	return m_iCount;
}
int SimFileMap::Load(ifstream &fs,REMOVEBLANK flag)
{
	char InLine[MAX_LINE];
	char 	*temp;
	int	 l;
	long	CurrOff=0;
	if ( fs.bad() )
		return NULL;
	m_iMaxCount=1024*100;
	m_pHead=new  char*[m_iMaxCount];
	m_pOffsetArray = new int[m_iMaxCount];
	m_pSearchArray=new char**[m_iMaxCount];	
	m_iCount=0;
	while(fs.getline(InLine,MAX_LINE))
	{
		if((flag==REM_BLK)&&(!InLine[0]))
			continue;
		l=strlen(InLine);
		temp=new char[l+2];
		strcpy(temp,InLine);
		m_pHead[m_iCount]=temp;
		m_pSearchArray[m_iCount]=&m_pHead[m_iCount];
		m_pOffsetArray[m_iCount]=CurrOff;
		CurrOff+=l+2;
		m_iCount++;
		
	}	
	return m_iCount;
}
int SimFileMap::RemainColumn(int n,const char *pszDelimiter)
{
	char szTemp[1024];
	int i;
	for(i=0;i<m_iCount;i++)
	{
		if(ExtractColumn(m_pHead[i],n,szTemp,pszDelimiter))
			replace_line(i,szTemp);
		else
			return 0;
	}
	return 1;
}
int SimFileMap::Load(FILE *fp,REMOVEBLANK flag)
{
	char InLine[MAX_LINE];
	char 	*Check,*temp;
	
	long	cnt=0,CurrOff=0;
	if ( !fp )
		return NULL;	
	while (fgets (InLine, MAX_LINE, fp))
	{
		if(flag==REM_BLK && InLine[0]==0x0d)
			continue;
		++cnt;
	}
	::rewind (fp);
    m_iMaxCount = cnt;
	m_pHead=new  char*[m_iMaxCount];
	m_pOffsetArray = new int[m_iMaxCount];
	m_pSearchArray=new char**[m_iMaxCount];
	m_iCount=0;
	while(!feof(fp))
	{
		Check = fgets (InLine, MAX_LINE, fp);
		if (Check)
		{
			ChopEnd(InLine);			
			if(flag==REM_BLK&&!InLine[0])
				continue;
			temp=new char[strlen(InLine)+2];
			strcpy(temp,InLine);
			m_pHead[m_iCount]=temp;
			m_pSearchArray[m_iCount]=&m_pHead[m_iCount];
			m_pOffsetArray[m_iCount]=CurrOff;
			CurrOff+=(strlen(temp)+2);
			m_iCount++;
		}
		else
		{
			InLine[0] = 0;
		}
//		running_msg(m_iCount,100);
	}
	return m_iCount;
}

SimFileMap::~SimFileMap()
{
	FreeMainArray();
  FreeStruct();
}
int compare_map(const void * argc1,const void *argc2);
int compare_search(const void * argc1,const void * argc2);
void SimFileMap::SortMap()
{
	qsort( (void*)m_pSearchArray,(size_t)m_iCount,sizeof(char**),compare_map);
}
int compare_map2(const void * argc1,const void *argc2)
{
	return strcmp((*(char**)argc1),(*(char**)argc2)  );
}
void SimFileMap::ForceSort()
{
	qsort( (void*)m_pHead,(size_t)m_iCount,sizeof(char*),compare_map2);
}
int compare_map(const void * argc1,const void *argc2)
{
	return strcmp(     *(*(char***)argc1),*(*(char***)argc2)  );
}
int compare_search(const void * argc1,const void * argc2)
{
	return strcmp(   *(char**)argc1,*(*(char***)argc2)  );
}


int SimFileMap::SearchPreviousString(const char* Line,int Len,int CurrentLineNo)
{
	if(CurrentLineNo>=m_iCount || CurrentLineNo <0)
		return -1;
	for(int i=CurrentLineNo;i>=0;i--)
	{
		if(!strncmp(m_pHead[i],Line,Len))
			return i;
	}
	return -1;
}


int SimFileMap::BinSearch(char *pszKey,int &nNearLineNo)
{
	int nStartLineNo = 0,nEndLineNo = m_iCount-1,nMidLineNo,nCompResult;
	while(nEndLineNo >= nStartLineNo)
	{
		nMidLineNo = (nEndLineNo + nStartLineNo)/2;
		nCompResult = stricmp(*m_pSearchArray[nMidLineNo],pszKey);
		if(nCompResult > 0)
			nEndLineNo = nMidLineNo -1;
		else if(nCompResult < 0)
			nStartLineNo = nMidLineNo +1;
		else
		{
			nNearLineNo = nMidLineNo;
			return 1;
		}
	}
	nNearLineNo = nEndLineNo;
	return 0;
}
void SimFileMap::ShowProgress(const char* lpMsg,int iInterval,int iLen)
{
	static char szMsg[500];
	static iCounter = 0;
	if(lpMsg == NULL)
	{
		iCounter = 0;
		return;
	}
	if(!(iCounter % iInterval))
	{
		strncpy(szMsg,lpMsg,iLen);
		szMsg[iLen] = 0;
		cerr<<"["<<iCounter<<"]"<<szMsg<<"\r";
	}
	iCounter++;

}
int SimFileMap::BinSearchLarge(char *pszKey,int &nNearLineNo)
{
	int nStartLineNo = 0,nEndLineNo = m_iCount-1,nMidLineNo,nCompResult;
	while(nEndLineNo >= nStartLineNo)
	{
		nMidLineNo = (nEndLineNo + nStartLineNo)/2;
		nCompResult = strcmp(*m_pSearchArray[nMidLineNo],pszKey);
		if(nCompResult > 0)
			nEndLineNo = nMidLineNo -1;
		else if(nCompResult < 0)
			nStartLineNo = nMidLineNo +1;
		else
		{
			nNearLineNo = nMidLineNo;
			return 1;
		}
	}
	nNearLineNo = nStartLineNo;
	return 0;
}
int   SimFileMap::DeleteLine(int iLineNo)
{
    if(iLineNo >= m_iCount)
        return -1;
    char **pTempHead = m_pHead;
    delete []pTempHead[iLineNo];
    memcpy(pTempHead + iLineNo,pTempHead + iLineNo + 1,sizeof(char*) * (m_iCount - iLineNo - 1));
    m_iCount--;
    pTempHead[m_iCount] = NULL;
    return m_iCount;
}
bool  SimFileMap::Swap(SimFileMap & Map)
{
    char **pT1;
    char ***pT2;
    int  iT,*pT3;

    pT1 = m_pHead;
    m_pHead = Map.m_pHead;
    Map.m_pHead = pT1;

    pT3 = m_pOffsetArray;
    m_pOffsetArray = Map.m_pOffsetArray;
    Map.m_pOffsetArray = pT3;

    pT2 = m_pSearchArray;
    m_pSearchArray = Map.m_pSearchArray;
    Map.m_pSearchArray = pT2;

    iT = m_iCount;
    m_iCount  = Map.m_iCount;
    Map.m_iCount = iT;

    iT = m_iCurrentPos;
    m_iCurrentPos = Map.m_iCurrentPos;
    Map.m_iCurrentPos = iT;

    iT = m_iMaxCount;
    m_iMaxCount = Map.m_iMaxCount;
    Map.m_iMaxCount = iT;
    
    return true;
}
int   SimFileMap::AppendTail(int  iLineNo,LPCSTR lpStr)
{
    char szBuf[_2K];
    sprintf(szBuf,"%s%s",m_pHead[iLineNo],lpStr);
    delete []m_pHead[iLineNo];
    m_pHead[iLineNo] = strdup(szBuf);
    return 1;
}
int   SimFileMap::AppendTail(LPCSTR lpStr)
{
    char szBuf[_4K];
    sprintf(szBuf,"%s%s",m_pHead[m_iCount - 1],lpStr);
    delete []m_pHead[m_iCount - 1];
    m_pHead[m_iCount - 1] = strdup(szBuf);
    return 1;
}
int   SimFileMap::GetLastLine(LPSTR lpStr)
{
    strcpy(lpStr,m_pHead[m_iCount - 1]);
    return m_iCount;
}
int   SimFileMap::ReplaceLastLine(LPCSTR lpStr)
{
    delete []m_pHead[m_iCount - 1];
    m_pHead[m_iCount - 1] = strdup(lpStr);
    return m_iCount;
}
int   SimFileMap::InsertLine(int iLineNo,LPCSTR lpStr)
{
    if(iLineNo > m_iCount)
        return -1;
    char **pOldHead = m_pHead;
    m_iCount++;
    char **pNewHead = new char*[m_iCount];
    memcpy(pNewHead,pOldHead,sizeof(char*)*(iLineNo));
    pNewHead[iLineNo] = strdup(lpStr);
    memcpy(pNewHead + iLineNo + 1,pOldHead + iLineNo,sizeof(char*) * (m_iCount - iLineNo - 1));
    delete []pOldHead;
    m_pHead = pNewHead;
    return m_iCount;
}
void   SimFileMap::Input(LPCSTR lpStr)
{
    if(m_iCount + 1 >= m_iMaxCount)
        ExpandMainArray();
    m_pHead[m_iCount] = strdup(lpStr);
	//m_pSearchArray[m_iCount]=&m_pHead[m_iCount];
	m_iCount++;
}
void   SimFileMap::ExpandMainArray(int  iIncrement)
{
    m_iMaxCount+=iIncrement;
    char **pTmpHead = new char*[m_iMaxCount];
    memcpy(pTmpHead,m_pHead,sizeof(char*)*m_iCount);
	delete []m_pHead;
    m_pHead = pTmpHead;
}

int SimFileMap::SearchAfterwardString(char *Line,int Len,int CurrentLineNo)
{
	if(CurrentLineNo>=m_iCount || CurrentLineNo <0)
		return -1;
	for(int i=CurrentLineNo;i<m_iCount;i++)
	{
		if(!strncmp(m_pHead[i],Line,Len))
			return i;
	}
	return -1;
}
int SimFileMap::SearchAfterwardLessString(char *Line,int Len,int CurrentLineNo)
{
	if(CurrentLineNo>=m_iCount || CurrentLineNo <0)
		return 0;
	for(int i=CurrentLineNo;i<m_iCount;i++)
	{
		if(strncmp(m_pHead[i],Line,Len)<=0)
			return i;
	}
	return -1;
}
int SimFileMap::search_next_str(int start_line,char* next_str,char* end_str)
{
	int i=start_line;
	char *str1;
	str1=GetLine(i);
	while( (i<m_iCount)&& (  strcmp( str1,end_str)  )   )
	{
		if(!strcmp( str1,next_str ))
			return i;
		
		i++;
		str1=GetLine(i);
	}
	return -1;
}
void ShowHelp(char** p)
{
	int i=0;
	while(*(p[i]))
	{
		cerr<<p[i]<<endl;
		i++;
	}
}

void CPtrMap::EmptyContent()
{
	if(m_pKey)
		delete []m_pKey;
	if(m_pOther)
		delete []m_pOther;
}

void Free(char** p)
{
	int i = 0;
	while(p[i])
	{
		delete p[i];
		p[i] = NULL;
		i++;
	}
	delete []p;
}

int MarkCount(char *str, char *mark)
{
  char *p1 = str;
  int count = 0;
  while(*p1)
  {
    if(!strncmp(p1, mark, strlen(mark)))
    {
      count++;
      p1 += strlen(mark);
    }
    else
      p1 ++;
  }
  return count;
}

bool Is_WholeNumber(char *str, bool bSign, bool bDot)
{
  ChopEnd(str);
  char *p1 = str;
  while(*p1)
  {
    if(*p1>='0' && *p1<='9')
      p1 ++;
    else if(*p1 == '.' && bDot)
      p1 ++;
    else if(*p1 == '-' && bSign)
    {
      if(p1 != str)
        return false;
      p1 ++;
    }
    else
      return false;
  }
  return true;
}

bool Is_HexNumber(char *str)
{
  char *p1 = str;
  while(*p1)
  {
    if(*p1>='0' && *p1<='9')
      p1 ++;
    else if(*p1>='A' && *p1<='F')
      p1 ++;
    else
      return false;
  }
  return true;
}

void strstr_rpl(char *pline, char *src, char *dst)
{
  char *p1 = pline, *ptemp = new char[strlen(p1)+100];
  char *p2 = ptemp;
  while(*p1)
  {
    if(!strncmp(p1, src, strlen(src)))
    {
      strcpy(p2, dst);
      p2 += strlen(dst);
      p1 += strlen(src);
    }
    else
      *p2++ = *p1++;
  }
  *p2 = 0;
  strcpy(pline, ptemp);
  delete []ptemp;
}