ledbuffer.cpp

是一个键盘测试程序

#include "ledbuffer.hpp"
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <iconv.h>

typedef struct tagLedItem{
	unsigned short* text;
	BOOL bUsed;
	time_t created_time;
}LedItem;

typedef unsigned short u2;

int u2_length(const unsigned short* str) {
	const unsigned short* cur = str; 
	if(!str)
	   return 0;
	while(*cur) {
		cur++;
	}
	return cur-str;
}

LedBuffer::~LedBuffer()
{
		clear();
		free(m_data);
		m_data = NULL;
}

void LedBuffer::setSize(int capacity){
	clear();
	if(capacity > m_count) {
		m_count = capacity;	
		m_data = malloc(m_count*sizeof(LedItem));
	}
	return;
}

int LedBuffer::getSize()
{
	return m_count;
}

BOOL LedBuffer::isEmpty()
{
	return m_used == 0;
}

BOOL LedBuffer::isFull()
{
	return (m_used == m_count);
}

int LedBuffer::getMaxIndex()
{
	if(m_data) {
		int i = 0;
		LedItem* item = (LedItem*)m_data;
		for(i = 0; i< m_count; i++) {
			if(item[m_count - i].bUsed)
				break;
		}
		return m_count - i;
	}else		
		return -1;
}
size_t LedBuffer::GB2312ToUCS2(char* out_buf, size_t buf_len,
				             const char* in_str)
{
	return ToUCS2(out_buf,buf_len, in_str, "GB2312");
}
size_t LedBuffer::ToUCS2(char* out_buf, size_t buf_len,
			     const char* in_str,
			     const char* in_code)
{
	static iconv_t	its_conv;
	if ( (its_conv = iconv_open("UCS-2", in_code)) == (iconv_t)-1 )
		return (size_t)-1;
	if (!in_str)
		return (size_t)-1;

	char *	instr = (char*)in_str;
	size_t	inlen = strlen(in_str) + 1;
	char *	outstr = out_buf;
	size_t	outlen = buf_len - 1;
	size_t	ret_conv = 0;
	ret_conv = iconv(its_conv, &instr, &inlen, &outstr, &outlen);
	iconv_close(its_conv);

	if ( (ret_conv == (size_t)-1) || (inlen == 1) )
		outstr[0] = '\0';	

	if (inlen == 1)	
		return (buf_len - 1 - outlen);
	if (ret_conv == (size_t)-1)
		return 0;

	return (buf_len - 2 - outlen);
}

/*
@return the newly appended string's id
*/
int LedBuffer::AppendUCS2(const unsigned short* str)
{
	//check is full
	if(isFull()){
		return -1;
	}
	if(m_data) {
		int i = 0;
		int len = u2_length(str);
		LedItem* item = (LedItem*)m_data;
		for(i = 0; i< m_count; i++) {
			if(!item[i].bUsed)
				break;
		}
		item[i].bUsed = TRUE;
		item[i].created_time = time(NULL);
		item[i].text = (unsigned short*)malloc(len*sizeof(u2));
		memcpy(item[i].text,str,len*sizeof(u2));
		return i;
	}else	
		return 0;
}

//int add(const char* str);
BOOL LedBuffer::rm_byIndex(int idx)
{
	if(idx < 0) return FALSE;
	if(idx > m_count) {
		return FALSE;
	} else{
		LedItem* item = (LedItem*)m_data;
		item[idx].bUsed = FALSE;
		if(item[idx].text)
			free(item[idx].text);
		item[idx].text = NULL;
	}
	return TRUE;
}

/*
@return 0 , no item removed;
@return >0 , the count of items removed;
*/ 
int  LedBuffer::rm_byDate(time_t timebegin,time_t timeend)
{
	int nCount = 0;
	if(m_data) {
		LedItem* item = (LedItem*)m_data;
		for(int i = 0; i< m_count; i++) {
			if(item[i].bUsed) {
				if((item[i].created_time>timebegin)
				&&(item[i].created_time<timeend))
				{
					rm_byIndex(i);
					nCount ++;
				}
			}
		}
	}	
	return nCount;
}

BOOL LedBuffer::replaceUCS2(int idx,const unsigned short* str)
{
	if(idx < 0) return FALSE;
	if(idx > m_count) {
		return FALSE;
	} else{
		int len = u2_length(str);
		LedItem* item = (LedItem*)m_data;
		item[idx].bUsed = TRUE;
		if(item[idx].text)
			free(item[idx].text);
		item[idx].created_time = time(NULL);
		item[idx].text = (unsigned short*)malloc(len*sizeof(u2));
		memcpy(item[idx].text,str,len*sizeof(u2));
	}
	return TRUE;
}

//BOOL replace(int idx, const char* str);
/*
 @ 0 return ok
 @ >0 output buffer too small, the minBuffersize;
  */
int LedBuffer::textUCS2(unsigned short* buf,int size)
{
	unsigned short* cur = buf;
	int outbufsize = 0;
	unsigned short sep[] = {0x000a,0x0000};
	int sep_size = u2_length(sep);
	if(m_data) {
	     LedItem* item = (LedItem*)m_data;
	     for(int i = 0; i< m_count; i++) {
	        int len2 = u2_length(item[i].text);
	        if(item[i].bUsed) {
				if(cur-buf+len2 < size){
					memcpy(cur,item[i].text,len2*sizeof(u2));
					memcpy(cur+len2,sep,sep_size*sizeof(u2));
				}
				cur+=len2;
				cur+=sep_size;
			}
		}
    }
	if(cur-buf <size)
		return 0;
	else
		return cur-buf;
}

BOOL LedBuffer::setDate(int idx, time_t date)
{
	if(idx < 0) return FALSE;
	if(idx > m_count) {
		return FALSE;
	} else{
		LedItem* item = (LedItem*)m_data;
		item[idx].bUsed = TRUE;
		item[idx].created_time = date;
	}
	return TRUE;
}

void LedBuffer::clear()
{
	if(m_data) {
		LedItem* item = (LedItem*)m_data;
		for(int i = 0; i< m_count; i++) {
			if(item[i].text)
				free(item[i].text);
			item[i].text = NULL;
			item[i].bUsed = 0;
		}
	}	
}

int LedBuffer::find_bycontentUCS2(const unsigned short* str)
{
	if(m_data) {
	   LedItem* item = (LedItem*)m_data;
	   for(int i = 0; i< m_count; i++) {
	      int len1 = u2_length(str);
		  int len2 = u2_length(item[i].text);
		  if(item[i].bUsed&&len1==len2) {
			 int nRet = memcmp(str,item[i].text,len1*sizeof(u2));
			 if(nRet == 0)
				 return nRet;
		  }
		}
	}
	
	return -1;
}

/*
@return -1, no data
*/
int LedBuffer::getcontentUCS2_byIndex(int idx,unsigned short* buf,int size)
{
	if(idx < 0) return -1;
	if(idx > m_count) {
		return -1;
	}
	if(m_data) {
		LedItem* item = (LedItem*)m_data;
		if(item[idx].bUsed){
			int nLen = u2_length(item[idx].text);
			if(nLen > size ) return nLen;
			memcpy(buf,item[idx].text,nLen*sizeof(u2));
			return 0;
		}else
			return -2;		
	}else	
		return -1;
}