c_shm_merge.cpp

HP共享内存实现,只要将sql语句配置好,装载共享内存即可

	//读serial_list
	fread( p_serial_list, sizeof(int), 1, fp );
	fread( &(p_serial_list[1]), sizeof(int), p_serial_list[0]+1, fp );
	//写十个子块
	for( int i=0; i<MAX_ITEM_COUNT; i++ )
	{
		fread( p_merge_item[i]->p_merge_info, sizeof(SHM_MERGE_INFO), 1, fp );
		//printf("%drecord count:%d,%d\n", i,p_merge_item[i]->p_merge_info->record_count, p_merge_item[i]->p_merge_info->add_record_count);
		fread( p_merge_item[i]->p_merge_list, sizeof(SHM_MERGE_LIST), p_merge_item[i]->p_merge_info->record_count, fp );
		fread( p_merge_item[i]->p_add_merge_list, sizeof(SHM_MERGE_LIST), p_merge_item[i]->p_merge_info->add_record_count, fp );
	}

	//写附加块
	fread( p_merge_addition->p_merge_info, sizeof(SHM_MERGE_INFO), 1, fp );
	fread( p_merge_addition->p_merge_list_item, sizeof(SHM_MERGE_LIST_ITEM), p_merge_addition->p_merge_info->record_count, fp );

	return 0;
}

SHM_MERGE_LIST_ITEM* c_shm_merge::getNext()
{
	if( get_next_pos == -1 )
	{
		return NULL;
	}
	else
	{
		SHM_MERGE_LIST_ITEM* p_list;
		p_list = &(p_merge_addition->p_merge_list_item[get_next_pos]);
		get_next_pos = p_list->next_pos;
		return p_list;
	}
}

SHM_MERGE_LIST* c_shm_merge::getElementBySeq( const int main_seq, const int item_seq, const int find_in_sort )
{
	if( main_seq >= MAX_ITEM_COUNT )
	{
		printf("%d超过最大分块数%d\n", main_seq, MAX_ITEM_COUNT);
		get_next_pos = -1;
		return NULL;
	}

	if( find_in_sort == 1 )
	{
		if( item_seq >= p_merge_item[main_seq]->p_merge_info->record_count )
		{
			printf("%d超过最大记录数%d\n", item_seq, p_merge_item[main_seq]->p_merge_info->record_count);
			get_next_pos = -1;
			return NULL;
		}
		get_next_pos = p_merge_item[main_seq]->p_merge_list[item_seq].item_pos;
		return &(p_merge_item[main_seq]->p_merge_list[item_seq]);
	}
	else
	{
		if( item_seq >= p_merge_item[main_seq]->p_merge_info->add_record_count )
		{
			printf("%d超过最大记录数%d\n", item_seq, p_merge_item[main_seq]->p_merge_info->add_record_count);
			get_next_pos = -1;
			return NULL;
		}
		get_next_pos = p_merge_item[main_seq]->p_add_merge_list[item_seq].item_pos;
		return &(p_merge_item[main_seq]->p_add_merge_list[item_seq]);
	}
}

/////2006-01-18
long c_shm_merge::getCharge(const int serv_id, const int counting_type_id, const int acct_item_type_id )
{
	//首先确定是在哪一块中
	int main_seq = (serv_id%100)/10;
	
	//在小块中查找
	if( counting_type_id != -1 )
	{
		SHM_MERGE_LIST* p_find_main = p_merge_item[main_seq]->findServID( serv_id, counting_type_id );
		if( p_find_main != NULL )
		{
			//找到号码
			//return update( p_find_main->item_pos, p_item, p_fee );
			return p_merge_addition->getFee(p_find_main->item_pos, acct_item_type_id);
		}
		else
		{
			//打不到
			return -999999;
		}	
	}
	else
	{
		SHM_MERGE_LIST* p_find_main = p_merge_item[main_seq]->findServID( serv_id, -1 );

		long t = 0;


		for( int i = 0; i<  p_merge_item[main_seq]->foundMerge.size(); i++ )
		{
			//找到号码
			//return update( p_find_main->item_pos, p_item, p_fee );
 			t = t + p_merge_addition->getFee(  p_merge_item[main_seq]->foundMerge[i]->item_pos, acct_item_type_id);
		}

		if (t == 0 )
		{
			return -999999;
		}
		else
			return t;
	}
}

//liuliming
//20060605增加接口
bool c_shm_merge::getCharge(const long serv_id, const int billing_cycle_id, const short int acct_item_type_id, const short int item_source, long* out_value )
{
	//构造acct_item_
	int tmp_acct_item_type = 0;
	setInt( acct_item_type_id, item_source, &tmp_acct_item_type );
	//构造main
	char tmp_buf[20];
	memcpy( &tmp_buf[0], &serv_id, 8 );
	memcpy( &tmp_buf[8], &billing_cycle_id, 4 );
	
	return getCharge( &tmp_buf[0], tmp_acct_item_type, out_value );
}

bool c_shm_merge::getCharge(const void* p_main, const int acct_item_type_id, long* out_value )
{
	//首先确定是在哪一块中
	int main_seq = getMergeItemSeq(p_main);
	
	//在小块中查找
	SHM_MERGE_LIST* p_find_main = p_merge_item[main_seq]->find(p_main);
	if( p_find_main != NULL )
	{
		//找到号码
		return  p_merge_addition->getFee(p_find_main->item_pos, acct_item_type_id, out_value);
	}
	else
	{
		//打不到
		return false;
	}
}

bool c_shm_merge::updateCharge(const long serv_id, const int counting_type_id, const int acct_item_type_id, const long fee )
{
	//首先确定是在哪一块中
	int main_seq = (serv_id%100)/10;
	
	//在小块中查找
	SHM_MERGE_LIST* p_find_main = p_merge_item[main_seq]->findServID( serv_id, counting_type_id );
	if( p_find_main != NULL )
	{
		//找到号码
		//return update( p_find_main->item_pos, p_item, p_fee );
		return p_merge_addition->updateFee(p_find_main->item_pos, acct_item_type_id, fee);
	}
	else
	{
		//找不到
		return false;
	}	
}

bool c_shm_merge::updateCharge(const void * p_main, const int acct_item_type_id, const long fee )
{
	//首先确定是在哪一块中
	int main_seq = getMergeItemSeq(p_main);
	
	//在小块中查找
	SHM_MERGE_LIST* p_find_main = p_merge_item[main_seq]->find(p_main);
	if( p_find_main != NULL )
	{
		//找到号码
		//return update( p_find_main->item_pos, p_item, p_fee );
		return p_merge_addition->updateFee(p_find_main->item_pos, acct_item_type_id, fee);
	}
	else
	{
		//找不到
		if( p_merge_item[main_seq]->append( p_main, &acct_item_type_id, &fee ) == 0 )
			return true;
		else
			return false;
	}	
	return true;
}

bool c_shm_merge::updateCharge(const long serv_id, const int billing_cycle_id, const short int acct_item_type_id, const short int item_source, const long fee )
{
	//构造acct_item_
	int tmp_acct_item;
	setInt( acct_item_type_id, item_source, &tmp_acct_item );
	//构造main
	char tmp_buf[20];
	memcpy( &tmp_buf[0], &serv_id, 8 );
	memcpy( &tmp_buf[8], &billing_cycle_id, 4 );
	
	return updateCharge( &tmp_buf[0], tmp_acct_item, fee );
}

//更新所有的帐目项
//先删除后增加
bool c_shm_merge::updateChargeList(const long serv_id, const int billing_cycle_id, vector<ACCT_ITEM_FEE>* acct_item_fee )
{
	//构造main
	char tmp_buf[20];
	memcpy( &tmp_buf[0], &serv_id, 8 );
	memcpy( &tmp_buf[8], &billing_cycle_id, 4 );
	
	return updateChargeList( &tmp_buf[0], acct_item_fee );
}

bool c_shm_merge::updateChargeList( const void* p_main, vector<ACCT_ITEM_FEE>* acct_item_fee )
{
	//首先确定是在哪一块中
	int main_seq = getMergeItemSeq(p_main);
	//在小块中查找
	SHM_MERGE_LIST* p_find_main = p_merge_item[main_seq]->find(p_main);
	
	if( p_find_main != NULL )
	{
		//找到号码
		p_find_main->item_pos = -1;
		if( (*acct_item_fee).size() > 0 )
		{
			//插入全新的数据
			return insertNewList( p_find_main, acct_item_fee );
		}
		else
		{
			//不用插入	
			return true;
		}
	}
	else
	{
		//找不到插入全新的数据
		append_mutex.enterMutex();
		int pos = p_merge_item[main_seq]->p_merge_info->add_record_count;
		p_merge_item[main_seq]->p_merge_info->add_record_count ++; 
		append_mutex.leaveMutex();
		
		memcpy( p_merge_item[main_seq]->p_add_merge_list[pos].main, (char*)p_main, main_key_size );
		p_merge_item[main_seq]->p_add_merge_list[pos].item_pos = -1;
		p_find_main = & (p_merge_item[main_seq]->p_add_merge_list[pos]);
		return insertNewList( p_find_main, acct_item_fee );
	}	
}

bool c_shm_merge::insertNewList( SHM_MERGE_LIST* p_find_main, vector<ACCT_ITEM_FEE>* acct_item_fee )
{
	int i, main_pos=0, add_count=0;
	long tmp_value = 0;
	sort( (*acct_item_fee).begin(), (*acct_item_fee).end(), lessByItemKey );
	for( i = 0 ; i < (*acct_item_fee).size() ; i ++ )
	{
		if( add_count == 0 )
		{
			append_mutex.enterMutex();					
			main_pos = p_merge_addition->p_merge_info->record_count;
			p_merge_addition->p_merge_info->record_count ++;
			append_mutex.leaveMutex();
			p_find_main->item_pos = main_pos;
	
			memcpy(&(p_merge_addition->p_merge_list_item[main_pos].acctFee[0].key), &((*acct_item_fee)[i].key), sizeof(int) );
			memcpy(&(p_merge_addition->p_merge_list_item[main_pos].acctFee[0].fee), &((*acct_item_fee)[i].fee), sizeof(long) );		
			p_merge_addition->p_merge_list_item[main_pos].ele_count = 1;
			p_merge_addition->p_merge_list_item[main_pos].next_pos = -1;
			add_count ++;
		}
		else
		{
			if( (*acct_item_fee)[i].key == (*acct_item_fee)[i-1].key )
			{
				memcpy( &tmp_value, &(p_merge_addition->p_merge_list_item[main_pos].acctFee[p_merge_addition->p_merge_list_item[main_pos].ele_count].fee), sizeof(long) );
				tmp_value += (*acct_item_fee)[i-1].fee;
				memcpy( &(p_merge_addition->p_merge_list_item[main_pos].acctFee[p_merge_addition->p_merge_list_item[main_pos].ele_count].fee), &tmp_value, sizeof(long) );
				//p_merge_addition->p_merge_list_item[main_pos].acctFee[p_merge_addition->p_merge_list_item[main_pos].ele_count-1].fee += acct_item_fee[i].fee;
				continue;
			}
			else
			{
				if( add_count % MAX_LIST_COUNT == 0 )
				{
					//满了
					append_mutex.enterMutex();	
					p_merge_addition->p_merge_list_item[main_pos].next_pos = p_merge_addition->p_merge_info->record_count;
					main_pos = p_merge_addition->p_merge_info->record_count;
					p_merge_addition->p_merge_info->record_count ++;
					append_mutex.leaveMutex();

					memcpy(&(p_merge_addition->p_merge_list_item[main_pos].acctFee[0].key), &((*acct_item_fee)[i].key), sizeof(int) );
					memcpy(&(p_merge_addition->p_merge_list_item[main_pos].acctFee[0].fee), &((*acct_item_fee)[i].fee), sizeof(long) );		
					p_merge_addition->p_merge_list_item[main_pos].ele_count = 1;
					p_merge_addition->p_merge_list_item[main_pos].next_pos = -1;
				}
				else
				{
					//没满
					memcpy(&(p_merge_addition->p_merge_list_item[main_pos].acctFee[p_merge_addition->p_merge_list_item[main_pos].ele_count].key), &((*acct_item_fee)[i].key), sizeof(int) );
					memcpy(&(p_merge_addition->p_merge_list_item[main_pos].acctFee[p_merge_addition->p_merge_list_item[main_pos].ele_count].fee), &((*acct_item_fee)[i].fee), sizeof(long) );		
					//p_merge_addition->p_merge_list_item[main_pos].acctFee[p_merge_addition->p_merge_list_item[main_pos].ele_count-1].key = acct_item_fee[i].key;
					//p_merge_addition->p_merge_list_item[main_pos].acctFee[p_merge_addition->p_merge_list_item[main_pos].ele_count-1].fee = acct_item_fee[i].fee;		
					p_merge_addition->p_merge_list_item[main_pos].ele_count ++;
				}
				add_count ++;
			}
		}				
	}
	return true;
}

int c_shm_merge::appendElement(const long serv_id, const int billing_cycle_id, const short int acct_item_type_id, const short int item_source_id, long fee)
{
	//构造acct_item_
	int tmp_acct_item;
	setInt( acct_item_type_id, item_source_id, &tmp_acct_item );
	//构造main
	char tmp_buf[20];
	memcpy( &tmp_buf[0], &serv_id, 8 );
	memcpy( &tmp_buf[8], &billing_cycle_id, 4 );
	return appendElement( &tmp_buf[0], &tmp_acct_item, &fee );
}

bool c_shm_merge::getFirstElement( long* serv_id, int* billing_cycle_id )
{
	SHM_MERGE_LIST* _first = getFirstElement() ;
	if( _first != NULL )
	{
		memcpy(serv_id, &_first->main[0], 8);
		memcpy(billing_cycle_id, &_first->main[8], 4);
		get_next_pos = _first->item_pos;
		p_list = getNext();
		list_get_item_count = -1;
		return true;
	}
	else
	{
		return false;
	}
}

bool c_shm_merge::getNextElement( long* serv_id, int* billing_cycle_id )
{
	SHM_MERGE_LIST* _tmp = getNextElement();
	if( _tmp != NULL )
	{
		memcpy(serv_id, &_tmp->main[0], 8);
		memcpy(billing_cycle_id, &_tmp->main[8], 4);
		get_next_pos = _tmp->item_pos;
		p_list = getNext();
		list_get_item_count = -1;
		return true;
	}
	else
	{
		return false;
	}
}

bool c_shm_merge::getNextItem( short int* acct_item_id, short int* item_source_id, long* acct_fee )
{
	if( p_list == NULL )
	{
		return false;
	}
	list_get_item_count ++;
	if( list_get_item_count >= p_list->ele_count )
	{
		p_list = getNext();
		if( p_list == NULL )
		{
			return false;
		}
		else
		{
			list_get_item_count = 0;
		}
	}
	char tmp_key[20];
	memcpy( &tmp_key[0], &(p_list->acctFee[list_get_item_count].key), 20);
	memcpy( acct_item_id, &tmp_key[0], 2 );
	memcpy( item_source_id, &tmp_key[2], 2 );
	memcpy( acct_fee, &(p_list->acctFee[list_get_item_count].fee), 8 );

	//int tmp_d;
	//char tmp_char[17];
	//memcpy( &tmp_char[0], &(p_list->acctFee[list_get_item_count].key), 16 );
	//for( tmp_d = 0 ; tmp_d < 16; tmp_d ++ )
	//	printf( "%d\t", tmp_char[tmp_d] );
	//printf("\n");fflush(stdout);
	return true;
}

bool c_shm_merge::setInt( const short int acct_item_id, const short int item_source_id, int* acct_item )
{
	char buf[4];
	memcpy( &buf[0], &acct_item_id, sizeof(short int ) );
	memcpy( &buf[2], &item_source_id, sizeof(short int) );
	memcpy( acct_item, buf, sizeof(int));
	return true;
}

bool c_shm_merge::getShortInt( const int acct_item, short int* acct_item_id, short int * item_source_id )
{
	char buf[4];
	memcpy( buf, &acct_item, sizeof(int));
	memcpy( acct_item_id, &buf[0], sizeof(short int ) );
	memcpy( item_source_id, &buf[2], sizeof(short int) );	
	return true;
}
	
SHM_MERGE_LIST* c_shm_merge::getFirstElement()
{
	//先从有序区找
	i_item_seq=0;
	i_sort_seq=1;
	i_element_seq=0;