c_shm_mem.cpp

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

	int record_count = getRecordCount();
	if( ( seq >= record_count ) || ( seq < 0 ) )
	{
		theLog<<"没有这个序号的数据!"<<endi;
		return NULL;
	}

	//theLog<<p_share_mem_info->element_size <<endi;
	int element_pos = seq * (p_share_mem_info->element_size + 1) + 1;
	//计算所在的锁
	int lock_pos = element_pos / p_share_mem_info->block_size;

	v_update_mutex[lock_pos].enterMutex();

	char* flag = (char *)&(head_point[element_pos-1]);	
	if( flag[0] != '1' )
	{
		theLog<<"该序号数据已经被删除!"<<endi;
		v_update_mutex[lock_pos].leaveMutex();
		return NULL;
	}

	//p_element_point = &head_point[ seq * (p_share_mem_info->element_size + 1) + 1 ];
	
	memcpy( element_buff, &head_point[ seq * (p_share_mem_info->element_size + 1) + 1 ], p_share_mem_info->element_size );
	v_update_mutex[lock_pos].leaveMutex();
	p_element_point = element_buff;
	
	return p_element_point;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::getFieldPointer( void* p_ele, int field_seq )
// Comment:		取字段指针
// Return:		int。成功:返回指针，错误，返回NULL
////////////////////////////////////////////////////////////////////////
char* c_shm_mem::getFieldPointer( void* p_ele, int field_seq )
{
	if( ( field_seq >= p_share_mem_info->field_count ) || field_seq < 0 )
	{
		theLog<<"没有第"<<field_seq<<"个字段!"<<endi;
		return NULL;
	}

	return &((char*)p_ele)[ p_field_info[field_seq].field_pos ];
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::getFieldValue(int seq, char* out_value)
// Comment:		取字符串值
// Return:		int。成功:0，失败errNoFieldSeq，值在out_value
////////////////////////////////////////////////////////////////////////
int c_shm_mem::getFieldValue(int seq, char* out_value)
{
   // TODO : implement
	if( seq >= p_share_mem_info->field_count )
	{
		theLog<<"没有第"<<seq<<"个字段!"<<endi;
		return errNoFieldSeq;
	}

	memcpy( out_value, (char*)&p_element_point[ p_field_info[seq].field_pos ], p_field_info[seq].field_size );
	//out_value[ v_mem_field_info[seq].field_size ] = '\0';
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::getFieldValue(int seq, int* out_value)
// Comment:		取int值
// Return:		int。成功:0，失败errNoFieldSeq，值在out_value
////////////////////////////////////////////////////////////////////////
int c_shm_mem::getFieldIntValue(int seq, int* out_value)
{
	char tmp_out[600];
	int return_value = getFieldValue( seq, &tmp_out[0] );
	if( return_value == 0 )
	{
		memcpy( out_value, &tmp_out[0], sizeof(int) );
		return 0;
	}
	else
	{
		return return_value;
	}
	/*
	if( seq >= p_share_mem_info->field_count )
	{
		theLog<<"没有第"<<seq<<"个字段!"<<endi;
		return errNoFieldSeq;
	}
	
	char temp[40];
	int* return_value;
	memcpy( temp, &(p_element_point[ p_field_info[seq].field_pos ]), sizeof(int) );
	return_value = (int *)temp;
	*out_value = *return_value;
	*/
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::getFieldDoubleValue(int seq, double* out_value)
// Comment:		取double值
// Return:		int。成功:0，失败errNoFieldSeq，值在out_value
////////////////////////////////////////////////////////////////////////
int c_shm_mem::getFieldDoubleValue(int seq, double* out_value)
{
	char tmp_out[600];
	int return_value = getFieldValue( seq, &tmp_out[0] );
	if( return_value == 0 )
	{
		memcpy( out_value, &tmp_out[0], sizeof(double) );
		return 0;
	}
	else
	{
		return return_value;
	}
	/*
	if( seq >= p_share_mem_info->field_count )
	{
		theLog<<"没有第"<<seq<<"个字段!"<<endi;
		return errNoFieldSeq;
	}
	
	char temp[40];
	double* return_value;
	memcpy( temp, &(p_element_point[ p_field_info[seq].field_pos ]), sizeof(double) );
	return_value = (double *)temp;
	*out_value = *return_value;
	*/
	return 0;
}

/////////////////2005-12-23
int c_shm_mem::getFieldLongValue(int seq, long* out_value)
{
	char tmp_out[600];
	int return_value = getFieldValue( seq, &tmp_out[0] );
	if( return_value == 0 )
	{
		memcpy( out_value, &tmp_out[0], sizeof(long) );
		return 0;
	}
	else
	{
		return return_value;
	}
	//int field_count;
	//memcpy( &field_count, &(p_share_mem_info->field_count), sizeof(int) );
	/*if( seq >= p_share_mem_info->field_count )
	{
		theLog<<"没有第"<<seq<<"个字段!"<<endi;
		return errNoFieldSeq;
	}
	
	char temp[40];
	long* return_value;
	memcpy( temp, &(p_element_point[ p_field_info[seq].field_pos ]), sizeof(long) );
	return_value = (long *)temp;
	*out_value = *return_value;
	*/
	return 0;	
}


////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::getFieldValue(int seq, char* out_value)
// Comment:		取char值
// Return:		int。成功:0，失败errNoFieldSeq，值在out_value
////////////////////////////////////////////////////////////////////////
int c_shm_mem::getFieldCharValue(int seq, char* out_value)
{
	if( seq >= p_share_mem_info->field_count )
	{
		theLog<<"没有第"<<seq<<"个字段!"<<endi;
		return errNoFieldSeq;
	}
	
	out_value[0] = p_element_point[ p_field_info[seq].field_pos ];
	
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::getAttrValue( int event_attr_id, char* out_value )
// Purpose:		根据event_attr_id取字符串值
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem::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
	{
		theLog<<"没有事件属性ID为"<<event_attr_id<<"的字段!"<<endi;
		return errNoAttrId;
	}
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::getAttrCharValue( int event_attr_id, char* out_value )
// Comment:		根据event_attr_id取char值
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem::getAttrCharValue( int event_attr_id, char* out_value )
{
	// TODO : implement
	if( field_attr_id[ event_attr_id ] != -1 )
	{
		return getFieldCharValue( field_attr_id[ event_attr_id ], out_value );
	}
	else
	{
		theLog<<"没有事件属性ID为"<<event_attr_id<<"的字段!"<<endi;
		return errNoAttrId;
	}
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::getAttrIntValue( int event_attr_id, int* out_value )
// Comment:		根据event_attr_id取Int值
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem::getAttrIntValue( int event_attr_id, int* out_value )
{
	// TODO : implement
	if( field_attr_id[ event_attr_id ] != -1 )
	{
		return getFieldIntValue( field_attr_id[ event_attr_id ], out_value );
	}
	else
	{
		theLog<<"没有事件属性ID为"<<event_attr_id<<"的字段!"<<endi;
		return errNoAttrId;
	}
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::getAttrDoubleValue( int event_attr_id, double* out_value )
// Purpose:		根据event_attr_id取double值
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem::getAttrDoubleValue( int event_attr_id, double* out_value )
{
	// TODO : implement
	if( field_attr_id[ event_attr_id ] != -1 )
	{
		return getFieldDoubleValue( field_attr_id[ event_attr_id ], out_value );
	}
	else
	{
		theLog<<"没有事件属性ID为"<<event_attr_id<<"的字段!"<<endi;
		return errNoAttrId;
	}
}


/////2005-12-23
int c_shm_mem::getAttrLongValue( int event_attr_id, long* out_value )
{
	// TODO : implement
	if( field_attr_id[ event_attr_id ] != -1 )
	{
		return getFieldLongValue( field_attr_id[ event_attr_id ], out_value );
	}
	else
	{
		theLog<<"没有事件属性ID为"<<event_attr_id<<"的字段!"<<endi;
		return errNoAttrId;
	}
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::addKey( int field_seq )
// Comment:    添加索引，索引数加1
// Purpose:    Implementation of c_shm_mem::addKey( int )
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem::addKey( int field_seq )
{
	if( field_seq >= p_share_mem_info->field_count )
	{
		theLog<<"没有第"<<field_seq<<"个字段!"<<endi;
		return errNoFieldSeq;
	}
	
	append_key_mutex.enterMutex();
	p_field_info[field_seq].key_count ++;
	append_key_mutex.leaveMutex();

	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::deleteKey( int field_seq )
// Comment:    删除索引，索引数减1
// Purpose:    Implementation of c_shm_mem::deleteKey( int )
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem::deleteKey( int field_seq )
{
	if( field_seq >= p_share_mem_info->field_count )
	{
		theLog<<"没有第"<<field_seq<<"个字段!"<<endi;
		return errNoFieldSeq;
	}
	
	append_key_mutex.enterMutex();
	p_field_info[field_seq].key_count --;
	append_key_mutex.leaveMutex();

	return 0;
}


////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::appendElement(void* p_element)
// Comment:    在原有数据的后面添加一条记录，同时把记录数加1。用锁。
// Purpose:    Implementation of c_shm_mem::appendElement()
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem::appendElement(void* p_element)
{
	// TODO : implement
	append_mutex.enterMutex();
	int append_pos = p_stShareInfo->append_record_count;
	if( (append_pos + 1 ) * (p_share_mem_info->element_size + 1) > p_share_mem_info->mem_size )
	{
		theLog<<"内存不足!"<<endi;
		append_mutex.leaveMutex();
		return errMemLimited;
	}
	p_stShareInfo->append_record_count ++;	
	append_mutex.leaveMutex();

	char* flag = &(head_point[append_pos * (p_share_mem_info->element_size + 1)]);
	
	flag[0] = '1';

	void* record = &head_point[ append_pos * (p_share_mem_info->element_size + 1) + 1 ];

	memcpy( record, p_element, p_share_mem_info->element_size );

	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::deleteElement(int seq)
// Purpose:    Implementation of c_shm_mem::deleteElement()
// Comment:    删除时做一个删除标记。
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem::deleteElement(int seq)
{
	// TODO : implement
	int record_count = getRecordCount();
	if( ( seq > record_count ) || ( seq < 0 ) )
	{
		theLog<<"没有这个序号的数据!"<<endi;
		return errNoDataSeq;
	}

	//计算所在的锁
	int element_pos = seq * (p_share_mem_info->element_size + 1) + 1;
	int lock_pos = element_pos / p_share_mem_info->block_size;
	//锁住
	v_update_mutex[lock_pos].enterMutex();

	char* flag = (char *)&(head_point[ element_pos - 1 ]);
	if( flag[0] != '1' )
	{
		theLog<<"这个序号的数据已经被删除了!"<<endi;
		v_update_mutex[lock_pos].leaveMutex();
		return errDataDelete;
	}

	flag[0] = '0';

	//解锁
	v_update_mutex[lock_pos].leaveMutex();

	/*char* flag = &(head_point[ (int)(seq * (p_share_mem_info->element_size + 1)) ]);
	if( flag[0] != '1' )
	{
		theLog<<"这个序号的数据已经被删除了!"<<endi;
		return errDataDelete;
	}*/
	
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm_mem::updateElement( int seq, void* element_value )
// Purpose:    Implementation of c_shm_mem::updateElement( int seq, void* element_value )
// Comment:    修改时， 不能修改关键字， 只能修改非关键字的部分。
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm_mem::updateElement( int seq, void* element_value )
{
   // TODO : implement
	int record_count = getRecordCount();
	//if( ( seq > p_stShareInfo->real_record_count ) || ( seq < 0 ) )
	if( ( seq > record_count ) || ( seq < 0 ) )
	{
		theLog<<"没有这个序号的数据!"<<endi;
		return errNoDataSeq;
	}

	//计算所在的锁
	int element_pos = seq * (p_share_mem_info->element_size + 1) + 1;
	int lock_pos = element_pos / p_share_mem_info->block_size;	
	//锁住
	v_update_mutex[lock_pos].enterMutex();

	
	char* flag = (char *)&(head_point[ element_pos - 1 ]);
	if( flag[0] != '1' )
	{
		theLog<<"这个序号的数据已经被删除了!"<<endi;
		v_update_mutex[lock_pos].leaveMutex();
		return errDataDelete;
	}
	
	char check1[MAX_RECORD_SIZE], check2[MAX_RECORD_SIZE];
	char* c_element = (char*) element_value;


	//检查