c_shm_mem_load_data.cpp

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

/***********************************************************************
 
* Module:  c_shm_mem_load_data.cpp
 
* Author:  Administrator
 
* Modified: 2005年9月15日 9:03:22
 
* Purpose: Declaration of the class c_shm_mem
_load_data 
* Comment: 共享内存装载资料类
 
***********************************************************************/

#include "c_shm_mem_load_data.h"

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem_load_data::c_shm_mem_load_data()
// Purpose:		构造函数
// Return:     
////////////////////////////////////////////////////////////////////////
c_shm_mem_load_data::c_shm_mem_load_data()
{
	p_share_info = new c_share_info();
	p_share_info->loadAllInfo();
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem_load_data::~c_shm_mem_load_data()
// Purpose:		析构函数
// Return:     
////////////////////////////////////////////////////////////////////////
c_shm_mem_load_data::~c_shm_mem_load_data()
{
}

/*void c_shm_mem_load_data::init( char* mem_name )
{
	SHARE_MEM_INFO* tmp = p_share_info->getMemInfo( mem_name);
	if( tmp == NULL )
	{
		printf("不存在%s的共享内存\n", mem_name );fflush(stdout);
		exit(1);
	}
	c_shm newshm(tmp->share_area_id);
	newshm.getshm();
	c_shm_mem_load_data* newmem = newshm.get_mem(mem_name);	

	p_share_mem_info = newmem->p_share_mem_info;
	p_stShareInfo = newmem->p_stShareInfo;
	p_field_info = newmem->p_field_info;
	head_point = newmem->head_point;
	append_mutex._mutex = newmem->append_mutex._mutex;
	record_count_mutex._mutex = newmem->record_count_mutex._mutex;
	v_update_mutex.clear();
	for( int i = 0 ; i < newmem->p_stShareInfo->block_count ; i ++ )
	{
		c_mutex t_mutex;
		t_mutex._mutex = &(newmem->p_stShareInfo->update_lock[i]);
		v_update_mutex.push_back( t_mutex );
	}
	append_key_mutex._mutex = newmem->append_key_mutex._mutex;

	//拷贝路径
	strcpy(file_path, newmem->file_path );
}*/

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem_load_data::loadData()
// Purpose:     加载数据，继承类可以重写，在初始化后一次调用
// Return:     int 成功：0 失败：errMemDelete，errAppenElement
////////////////////////////////////////////////////////////////////////
int c_shm_mem_load_data::loadData(const int sql_seq)
{
	return c_shm_mem::loadData(sql_seq);	
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem_load_data::unloadData()
// Purpose:		卸载数据
// Comment:		修改标志，同时，将记录数修改为0
// Return:     int，成功：0，失败：errMemUnload
////////////////////////////////////////////////////////////////////////
int c_shm_mem_load_data::unloadData()
{
	return c_shm_mem::unloadData();
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem_load_data::appendElement( void * p_element )
// Purpose:    Implementation of c_shm_mem_load_data::appendElement( void * p_element )
// Comment:    在原有数据的后面添加一条记录，同时把记录数加1。用锁。
// Return:     int，成功:0，失败errMemLimited
////////////////////////////////////////////////////////////////////////
int c_shm_mem_load_data::appendElement( void * p_element )
{
//cout<<"1";
	append_mutex.enterMutex();
//cout<<"2";
	int append_pos = p_stShareInfo->append_record_count;
//cout<<"3:";
//cout<<append_pos<<","<<(append_pos + 1 ) * (p_share_mem_info->element_size + 1)<<"||"<<(p_share_mem_info->mem_size - p_share_mem_info->addition_size)<<"||";
	if( (append_pos + 1 ) * (p_share_mem_info->element_size + 1) > (p_share_mem_info->mem_size - p_share_mem_info->addition_size) )
	{
		cout<<"内存不足!"<<endl;
		append_mutex.leaveMutex();
		return errMemLimited;
	}

//cout<<"a";
	char* flag = &(head_point[append_pos * (p_share_mem_info->element_size + 1)]);
	flag[0] = '1';
//cout<<"b";	
	memcpy( &flag[1], p_element, p_share_mem_info->element_size );
//cout<<"c";
	p_stShareInfo->append_record_count ++;
//cout<<"d";
	append_mutex.leaveMutex();
	if( singal_terminate.isTerminated() )
	{
		cout<<"程序终止!"<<endl;
		singal_terminate.kill();
	}
//cout<<"e"<<endl;
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem_load_data::deleteElement(int seq)
// Purpose:    Implementation of c_shm_mem_load_data::deleteElement()
// Comment:    删除时做一个删除标记。
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem_load_data::deleteElement( int seq )
{
	return c_shm_mem::deleteElement( seq );
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem_load_data::updateElement( int seq, void* element_value )
// Purpose:    Implementation of c_shm_mem_load_data::updateElement( int seq, void* element_value )
// Comment:    资料类，没有修改记录。
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem_load_data::updateElement( int seq, void* element_value )
{	
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem_load_data::appendElement()
// Purpose:    Implementation of c_shm_mem_load_data::appendElement()
// Comment:    添加记录。
//				使用该函数，须先使用SetData，将记录内容添加到buff中，添加时，从buff中获取要修改的记录内容。
// Return:     int，成功:0，失败errMemLimited
////////////////////////////////////////////////////////////////////////
int c_shm_mem_load_data::appendElement()
{
	return appendElement(buff);
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem_load_data::updateElement( int seq )
// Purpose:    Implementation of c_shm_mem_load_data::updateElement( int seq )
// Comment:    修改时， 不能修改关键字， 只能修改非关键字的部分。
//				使用该函数，须先使用SetData，将记录内容添加到buff中，更新时，从buff中获取要修改的记录内容。
// Return:     int，成功，0，失败：errNoDataSeq, errDataDelete, errChangeKeyValue
////////////////////////////////////////////////////////////////////////
int c_shm_mem_load_data::updateElement( int seq )
{
	return c_shm_mem::updateElement( seq );
}


///////2005-11-23
//添加数据
int c_shm_mem_load_data::SetData( int seq, void * buf_v )
{
	try
	{
	//cout<<"in:";
		if( seq >= p_share_mem_info->field_count )
		{
			cout<<"没有第"<<seq<<"个字段!"<<endl;
			return errNoFieldSeq;
		}
		int len_buf = strlen((char*)buf_v);
		if( p_field_info[seq].field_size == -1 )
		{
			int last_pos;
			if( len_buf == 0 )
			{
				last_pos = -1;
				memcpy( &buff[p_field_info[seq].field_pos], &last_pos, sizeof(int) );
				return 0;
			}
	//printf("%d\n",p_stShareInfo->addition_pos);fflush(stdout);
			addition_mutex.enterMutex();
	//printf("B\n");fflush(stdout);
			last_pos = p_stShareInfo->addition_pos;
	//cout<<"C";
			if( (last_pos+1+len_buf) > p_share_mem_info->addition_size )
			{
				cout<<"附加块内存不足!"<<endl;
				addition_mutex.leaveMutex();				
				return errMemLimited;
			}
	//cout<<"D";
			
			//char* record = &addition_point[ last_pos ];
	//cout<<"E";
			memcpy( &addition_point[ last_pos ], (char*)buf_v, len_buf+1 );
	//cout<<"F";
			//record[last_pos+len_buf] = '\0';
	//cout<<"G";
			p_stShareInfo->addition_pos += (len_buf+1);
	//cout<<"H";
			memcpy( &buff[p_field_info[seq].field_pos], &last_pos, 4 );
	//cout<<"I";
			addition_mutex.leaveMutex();
		}
		else
		{
			memcpy( &buff[p_field_info[seq].field_pos], (char*)buf_v, p_field_info[seq].field_size );
		}
	}
	catch(Exception& ex)
	{
		return -1;
	}
	//cout<<"end"<<endl;
	return 0;
}

int c_shm_mem_load_data::getFieldValue(int seq, char* out_value)
{
	if( seq >= p_share_mem_info->field_count )
	{
		cout<<"没有第"<<seq<<"个字段!"<<endl;
		return errNoFieldSeq;
	}

	if(p_field_info[seq].field_size==-1)
	{
		char tmp[4];
		memcpy( tmp, (char*)&p_element_point[ p_field_info[seq].field_pos ], 4 );
		//int* pos = (int*)tmp;
		if( *(int*)tmp != -1 )
		{
			strcpy( out_value, (char*)&(addition_point[ *(int*)tmp ]) );
		}
		else
		{
			strcpy( out_value, "\0" );
		}
	}
	else
	{
		memcpy( out_value, (char*)&p_element_point[ p_field_info[seq].field_pos ], p_field_info[seq].field_size );
	}	
	if( singal_terminate.isTerminated() )
	{
		cout<<"程序终止!"<<endl;
		singal_terminate.kill();
	}
	return 0;
}

int c_shm_mem_load_data::getAttrValue( int event_attr_id, char* out_value )
{
	// TODO : implement
	if( field_attr_id[ event_attr_id ] != -1 )
	{
		return getFieldValue( field_attr_id[ event_attr_id ], out_value );
	}
	else
	{
		cout<<"没有事件属性ID为"<<event_attr_id<<"的字段!"<<endl;
		return errNoAttrId;
	}
}

int c_shm_mem_load_data::getAttrFieldType( const int event_attr_id )
{
	if( field_attr_id[ event_attr_id ] != -1 )
	{
		return p_field_info[field_attr_id[ event_attr_id ]].field_type;
	}
	else
	{
		cout<<"没有事件属性ID为"<<event_attr_id<<"的字段!"<<endl;
		return errNoAttrId;
	}
}

int c_shm_mem_load_data::getFieldType( const int field_seq )
{
	if( field_seq >= p_share_mem_info->field_count )
	{
		cout<<"没有第"<<field_seq<<"个字段!"<<endl;
		return errNoFieldSeq;
	}
	return p_field_info[field_seq].field_type;
}