c_shm_merge.cpp

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

		}
	}
}
*/

//查找，找到，返回值，否则，返回NULL，二分法查找8个值
SHM_MERGE_LIST_ITEM* c_shm_merge_addition::find( const int begin_pos, const void * item_value ) 
{
	return NULL;
}


//添加值，首先在空余的空间添加，如没有空余的空间，则申请8个空间做为空余的空间，再添加
int c_shm_merge_addition::append( const int main_pos, const void* p_item, const void* p_fee )
{
	//if( main_pos % MAX_LIST_COUNT != 0 )
	//	cout<<"error"<<main_pos<<endl;
	int j, last_pos, get_comp_pos;
	
	int last_main_pos = main_pos;
	int begin_pos, end_pos, middle_pos, insert_pos;
	long tmp_value1 = 0;

//将位置压入
	m_pos.clear();
	m_pos.push_back(last_main_pos);
	while( p_merge_list_item[last_main_pos].next_pos != -1 )
	{
		m_pos.push_back(p_merge_list_item[last_main_pos].next_pos);
		last_main_pos = p_merge_list_item[last_main_pos].next_pos;
	}

//从第一个节点开始比较
	for( int i = 0; i < m_pos.size(); i++ )
	{
		int t =  p_merge_list_item[ m_pos[i] ].acctFee[ p_merge_list_item[ m_pos[i] ].ele_count -1 ].key - *(int*)p_item ;
		if(  t == 0 )
		{
			memcpy( &tmp_value1, &(p_merge_list_item[ m_pos[i] ].acctFee[ p_merge_list_item[ m_pos[i] ].ele_count -1 ].fee), sizeof(long) );
			tmp_value1 += *((long*)p_fee);
			memcpy(&(p_merge_list_item[ m_pos[i] ].acctFee[ p_merge_list_item[ m_pos[i] ].ele_count -1 ].fee), &tmp_value1, sizeof(long) );
			//p_merge_list_item[ m_pos[i] ].acctFee[ p_merge_list_item[ m_pos[i] ].ele_count -1 ].fee += *(long*)p_fee;
			return 0;
		}
		else if( t > 0 )
		{
			break;
		}
	}

//找到插入块 i
	if( i == m_pos.size()  )  //最后一块
	{
		if(  p_merge_list_item[ m_pos[i-1] ].ele_count < MAX_LIST_COUNT )
		//直接插入到最后
		{
			memcpy(&(p_merge_list_item[ m_pos[i-1] ].acctFee[ p_merge_list_item[ m_pos[i-1] ].ele_count ].fee), p_fee, sizeof(long) );
			memcpy(&(p_merge_list_item[ m_pos[i-1] ].acctFee[ p_merge_list_item[ m_pos[i-1] ].ele_count ].key), p_item, sizeof(int) );
			p_merge_list_item[ m_pos[i-1] ].ele_count++;
			return 0;
		}
		else  //申请一个块, 并将该元素放入
		{
			m_p_shm_merge->append_mutex.enterMutex();
			if( p_merge_info->record_count >= m_p_shm_merge->max_addition_count )
			{
				cout<<"超出附加块内存限制!"<<endl;
				m_p_shm_merge->append_mutex.leaveMutex();
				exit(1);
			}
			last_pos = p_merge_info->record_count;
			p_merge_info->record_count ++;
			m_p_shm_merge->append_mutex.leaveMutex();

			p_merge_list_item[ m_pos[i-1] ].next_pos = last_pos;

			memcpy(&(p_merge_list_item[last_pos].acctFee[0].key), p_item, sizeof(int) );
			memcpy(&(p_merge_list_item[last_pos].acctFee[0].fee), p_fee, sizeof(long) );
			p_merge_list_item[last_pos].ele_count = 1;
			p_merge_list_item[last_pos].next_pos= -1;

			return 0;
		}

	}
	else  //对应的块号为m_pos[i], 在该块中插入数据, 而且所有块是满 
	{
//在i中寻找插入位置
		begin_pos = 0;
		end_pos = p_merge_list_item[m_pos[i]].ele_count-2;


		while( begin_pos <= end_pos )
		{
			middle_pos = begin_pos + (end_pos-begin_pos)/2;
			int comp_value = p_merge_list_item[m_pos[i]].acctFee[middle_pos].key - *((int*)p_item);
			if( comp_value == 0 )
			{
				//直接加
				memcpy( &tmp_value1, &(p_merge_list_item[m_pos[i]].acctFee[middle_pos].fee), sizeof(long) );
				tmp_value1 += *((long*)p_fee);
				memcpy(&(p_merge_list_item[m_pos[i]].acctFee[middle_pos].fee), &tmp_value1, sizeof(long) );
				return 0;
			}
			else if( comp_value > 0 )
			{
				end_pos = middle_pos - 1;
			}
			else
			{
				begin_pos = middle_pos + 1;
			}
		}

//printf("begin_pos:%d, %d\n",begin_pos, p_merge_list_item[ m_pos[m_pos.size()-1] ].ele_count);

		if( p_merge_list_item[ m_pos[m_pos.size()-1] ].ele_count == MAX_LIST_COUNT ) //最后一个块满
		{
			m_p_shm_merge->append_mutex.enterMutex();
			last_pos = p_merge_info->record_count;
			p_merge_info->record_count ++;
			
			if( p_merge_info->record_count >= m_p_shm_merge->max_addition_count )
			{
				cout<<"超出附加块内存限制!"<<endl;
				m_p_shm_merge->append_mutex.leaveMutex();
				exit(1);
			}

			m_p_shm_merge->append_mutex.leaveMutex();
			p_merge_list_item[ m_pos[m_pos.size()-1] ].next_pos = last_pos;

			p_merge_list_item[ last_pos].ele_count = 0;
			p_merge_list_item[ last_pos].next_pos = -1;
			m_pos.push_back( last_pos );
		}

		if( m_pos.size() - 1 == i )
		{
			p_merge_list_item[ m_pos[i] ].ele_count++;
			memmove( &p_merge_list_item[ m_pos[i] ].acctFee[begin_pos+1], &p_merge_list_item[m_pos[i]].acctFee[begin_pos], ( p_merge_list_item[ m_pos[i] ].ele_count - begin_pos-1 )*sizeof(ACCT_ITEM_FEE) );

	//在begin_pos中插入新的元素
			memcpy(&(p_merge_list_item[m_pos[i]].acctFee[begin_pos].key), p_item, sizeof(int) );
			memcpy(&(p_merge_list_item[m_pos[i]].acctFee[begin_pos].fee), p_fee, sizeof(long) );
			return 0;
		}

//移动数据
//最后一个块内的数据全部偏移一位
		if( p_merge_list_item[ m_pos[m_pos.size() - 1]].ele_count != 0 )
		{
			memmove( &p_merge_list_item[ m_pos[m_pos.size() -1] ].acctFee[1], &p_merge_list_item[ m_pos[m_pos.size() - 1] ].acctFee[0], p_merge_list_item[ m_pos[m_pos.size() - 1]].ele_count*sizeof(ACCT_ITEM_FEE) );
		}
		p_merge_list_item[ m_pos[m_pos.size() - 1]].ele_count++;


		for( j = m_pos.size() -2 ; j > i ; j-- )
		{
			//块间偏移
			memcpy( &p_merge_list_item[ m_pos[j+1] ].acctFee[0],  &p_merge_list_item[ m_pos[j] ].acctFee[MAX_LIST_COUNT-1], sizeof(ACCT_ITEM_FEE) );
			//块内移动
			memmove( &p_merge_list_item[ m_pos[j] ].acctFee[1], &p_merge_list_item[m_pos[j]].acctFee[0], (MAX_LIST_COUNT-1)*sizeof(ACCT_ITEM_FEE) );
		}

//插入位置为begin_pos
		memcpy( &p_merge_list_item[ m_pos[i+1] ].acctFee[0],  &p_merge_list_item[ m_pos[i] ].acctFee[MAX_LIST_COUNT-1], sizeof(ACCT_ITEM_FEE) );
		//块内移动
		memmove( &p_merge_list_item[ m_pos[i] ].acctFee[begin_pos+1], &p_merge_list_item[m_pos[i]].acctFee[begin_pos], ( MAX_LIST_COUNT-begin_pos-1 )*sizeof(ACCT_ITEM_FEE) );

//在begin_pos中插入新的元素
		memcpy(&(p_merge_list_item[m_pos[i]].acctFee[begin_pos].key), p_item, sizeof(int) );
		memcpy(&(p_merge_list_item[m_pos[i]].acctFee[begin_pos].fee), p_fee, sizeof(long) );
	}

	return 0;
}

/*
//添加值，首先在空余的空间添加，如没有空余的空间，则申请8个空间做为空余的空间，再添加
int c_shm_merge_addition::append( const int main_pos, const void* p_item, const void* p_fee )
{
	if( main_pos % MAX_LIST_COUNT != 0 )
		cout<<"error"<<main_pos<<endl;
	//cout<<"test :"<<main_pos+MAX_LIST_COUNT-1<<"|"<<p_merge_list_item[main_pos+MAX_LIST_COUNT-1].next_pos<<"|"<<endl;
	SHM_MERGE_LIST_ITEM* p_find;
	SHM_MERGE_LIST_ITEM shm_find;
	shm_find.key = *(int*)p_item ;
	int i, j, last_pos, get_comp_pos;
	
	int last_main_pos = main_pos;
	while(1)
	{
		p_find = (SHM_MERGE_LIST_ITEM*)bsearch(&shm_find, &p_merge_list_item[last_main_pos], p_merge_list_item[last_main_pos].ele_count, sizeof(SHM_MERGE_LIST_ITEM), listItemComp);
		if( p_find != NULL )
		{
			//找到了。
			//cout<<"find:"<<*(int*)p_item<<endl;
			p_find->fee +=  *((int*)p_fee);
			return 0;
		}
		else
		{
			//没找到
			//cout<<"not find:"<<*(int*)p_item<<endl;
			if( p_merge_list_item[last_main_pos].ele_count == MAX_LIST_COUNT )
			{
				get_comp_pos = getPos( last_main_pos+MAX_LIST_COUNT-1 );
				if( get_comp_pos ==  -1 )
				{
					//新开空间并插入
					m_p_shm_merge->append_mutex.enterMutex();
					last_pos = p_merge_info->record_count;
					p_merge_info->record_count += MAX_LIST_COUNT;
					m_p_shm_merge->append_mutex.leaveMutex();

					p_merge_list_item[last_main_pos+MAX_LIST_COUNT-1].next_pos = last_pos;

					//memcpy(p_merge_list_item[last_pos].key, (char*)p_item,MAX_ITEM_LENGTH);
					p_merge_list_item[last_pos].key = *(int*)p_item;
					p_merge_list_item[last_pos].fee = *((int*)p_fee);
					p_merge_list_item[last_pos].ele_count = 1;
					for( i = 0; i < MAX_LIST_COUNT; i ++ )
					{
						p_merge_list_item[last_pos+i].next_pos= -1;
					}

					return 0;	
				}
				else
				{
					//找下一个小节
					last_main_pos = get_comp_pos;
				}
			}
			else
			{
				//新增一个节点
				last_pos = last_main_pos + p_merge_list_item[last_main_pos].ele_count - 1 ;
				p_merge_list_item[last_pos].next_pos = last_pos+1;

				for( i = 0 ; i < p_merge_list_item[last_main_pos].ele_count ; i ++ )
				{					
					if( listItemComp( &shm_find, &(p_merge_list_item[last_main_pos+i]) ) < 0 )
					{
						//插入
						for( j = p_merge_list_item[last_main_pos].ele_count ; j > i ; j -- )
						{
							//memcpy( p_merge_list_item[last_main_pos+j].key, p_merge_list_item[last_main_pos+j-1].key, MAX_ITEM_LENGTH );
							p_merge_list_item[last_main_pos+j].key = p_merge_list_item[last_main_pos+j-1].key;
							p_merge_list_item[last_main_pos+j].fee = p_merge_list_item[last_main_pos+j-1].fee;
						}
						break;
					}
				}
				//memcpy( p_merge_list_item[last_main_pos+i].key, p_item, MAX_ITEM_LENGTH);
				p_merge_list_item[last_main_pos+i].key = *((int*)p_item) ;
				p_merge_list_item[last_main_pos+i].fee = *((int*)p_fee);
				p_merge_list_item[last_main_pos].ele_count ++;
				return 0;
			}
		}
	}
	return 0;
}
*/

SHM_MERGE_LIST* c_shm_merge_item::binfind( const int begin_pos, const int end_pos, const SHM_MERGE_LIST* item ) 
{
	return NULL;
}

//查找，找到，返回值，否则，返回NULL
SHM_MERGE_LIST* c_shm_merge_item::find( const void * p_main )
{
	SHM_MERGE_LIST shm_find;
	memcpy( shm_find.main, (char*)p_main, m_p_shm_merge->main_key_size );
	//strcpy( shm_find.main, (char*) p_main);
	//memcpy( shm_find.main, (char*)p_main, MAX_MAIN_LENGTH);
	//for(int j=0; j<g_main_key.size(); j++ )
	//{
	//	memcpy(&(shm_find.main[g_main_key[j].pos]), &(((char*)p_main)[g_main_key[j].pos]), g_main_key[j].size );
	//}

	if ( p_current != NULL ) 
	{
		if( itemComp( p_current, &shm_find ) == 0 )
			return p_current;
		//if( strcmp( p_current->main, (char*)p_main  ) == 0 )
		//	return p_current;
	}

	SHM_MERGE_LIST* p = NULL;

	if( p_merge_info->record_count > 0 )
	{
		p = (SHM_MERGE_LIST*)bsearch(&shm_find, p_merge_list, p_merge_info->record_count, sizeof(SHM_MERGE_LIST), itemComp);
	}
	
	if( p == NULL )
	{
		p_merge_info->unsort_find_count ++;
		for( int i = 0 ; i < p_merge_info->add_record_count ; i ++ )
		{
			//if( strcmp( p_add_merge_list[i].main, (char*) p_main) == 0 )
			if( itemComp( &p_add_merge_list[i], &shm_find )  == 0 )
			{
				p = &p_add_merge_list[i];				
				break;
			}
		}
	}	

	p_current = p;
	return p;
}

//添加值，首先在附加区添加，如果附加区的数量大于10000，则把附加区的数据添加到主区中，并排序
int c_shm_merge_item::append( const void* p_main, const void* p_item, const void* p_fee )
{	
	//在无序区添加
	//append_main_mutex是锁记录数
	//append_main_mutex.enterMutex();
	//append_mutex是锁附加区的记录数
	m_p_shm_merge->append_mutex.enterMutex();

	int main_pos = m_p_shm_merge_addition->p_merge_info->record_count;
	m_p_shm_merge_addition->p_merge_info->record_count ++;
	int pos = p_merge_info->add_record_count;
	p_merge_info->add_record_count ++; 

	m_p_shm_merge->append_mutex.leaveMutex();
	//append_main_mutex.leaveMutex();

	//strcpy(p_add_merge_list[pos].main, (char*) p_main );
	
	memcpy( p_add_merge_list[pos].main, (char*)p_main, m_p_shm_merge->main_key_size );
	p_add_merge_list[pos].item_pos = main_pos;
	p_current = & (p_add_merge_list[pos]);

	memcpy(&(m_p_shm_merge_addition->p_merge_list_item[main_pos].acctFee[0].key),p_item, sizeof(int) );
	memcpy(&(m_p_shm_merge_addition->p_merge_list_item[main_pos].acctFee[0].fee), p_fee, sizeof(long) );
	m_p_shm_merge_addition->p_merge_list_item[main_pos].ele_count = 1;
	m_p_shm_merge_addition->p_merge_list_item[main_pos].next_pos = -1;

	//排序无序区
	//if( p_merge_info->add_record_count - p_merge_info->sort_count > 10 )
	//{
	//	qsort(p_add_merge_list, p_merge_info->add_record_count, sizeof(SHM_MERGE_LIST), itemComp );
	//	p_merge_info->sort_count = p_merge_info->add_record_count;
	//}


	if ( p_merge_info->add_record_count >= MAX_ITEM_ADD_COUNT )
	{
		qSort();
	}
	return 0;
}

//更新值
int c_shm_merge_item::update( const int main_pos, const void* p_item, const void* p_fee ) 
{
	return m_p_shm_merge_addition->append(main_pos, p_item, p_fee);
}

//排序
int c_shm_merge_item::qSort() 
{
	if( p_merge_info->add_record_count < 10 )
	{
		p_merge_info->unsort_find_count = 0;
		return 0;
	}

	//把无序区的数据拷贝到有序区
	memcpy( &p_merge_list[p_merge_info->record_count], &p_add_merge_list[0], (p_merge_info->add_record_count)*sizeof(SHM_MERGE_LIST) );
	
	p_merge_info->record_count += p_merge_info->add_record_count; 
	p_merge_info->add_record_count = 0;
	p_merge_info->unsort_find_count = 0;
	
	//排序
	qsort(p_merge_list, p_merge_info->record_count, sizeof(SHM_MERGE_LIST), itemComp );
	return 0;
}

//添加数据，外部调用
int c_shm_merge_item::addRecord( const void* p_main, const void* p_item, const void* p_fee )
{
	//cout<<"addrecord:"<<(char*)p_main<<"|"<<(char*)p_item<<"|"<<(char*)p_fee<<endl;

	if( p_merge_info->unsort_find_count >= MAX_UNSORT_FINDED_COUNT )
	{
		qSort();		
	}

	//在小块中查找
	SHM_MERGE_LIST* p_find_main = find( p_main );
	if( p_find_main != NULL )
	{
		//找到号码
		//return update( p_find_main->item_pos, p_item, p_fee );
		return m_p_shm_merge_addition->append(p_find_main->item_pos, p_item, p_fee);
	}
	else
	{
		//未找到号码，在本块中新增一个数据
		return append( p_main, p_item, p_fee );
	}
	
}

/////2006-01-18
//在共享内存块中根据serv_id与counting_type_id查找到数据
////20060415 增加传入counting_type_id为-1时，找出指定的serv_id的所有数据。
SHM_MERGE_LIST* c_shm_merge_item::findServID( const int serv_id, const int counting_type_id )
{
	SHM_MERGE_LIST shm_find;
	memset( serv_buff, 0, 30 );
	sprintf(&serv_buff[0] ,"%10d", serv_id );
	sprintf(&serv_buff[10