sdbms_datastruct.cpp

使用yacc的一个例子

#include "stdafx.h"
#include "Sdbms_DataStruct.h"
#include "Sdbms.h"
#include "SqlMsg.h"

extern CSqlMessage g_msg;
extern CSdbms g_sdbms;
extern char g_strMsg[1000];
extern char *g_strSystemRight[];
extern char *g_strObjectRight[];

/*类 -- 安全级**********************************************************************/

CSdbms_SecurityLevel::CSdbms_SecurityLevel()
{
	m_nClassifaction = -1;	//表明安全级为空
	m_nRangeCount = 0;
}

CSdbms_SecurityLevel::CSdbms_SecurityLevel(int nClass)
{
	m_nClassifaction = nClass < 0 ? 0 : nClass;
	m_nClassifaction = nClass > 3 ? 3 : m_nClassifaction;
	m_nRangeCount = 0;
}

CSdbms_SecurityLevel::CSdbms_SecurityLevel(const CSdbms_SecurityLevel& seclevel)
{
	m_nClassifaction = seclevel.m_nClassifaction;
	m_nRangeCount = seclevel.m_nRangeCount;
	for	(int i=0; i<m_nRangeCount; i++)
	{
		m_nRange[i]	= seclevel.m_nRange[i];
		m_strRange[i] = seclevel.m_strRange[i]; 
	}
}

CSdbms_SecurityLevel::CSdbms_SecurityLevel(BYTE *pData, UINT nSize)
{
	char strNull[MAX_RECORD_SIZE];
	memset(strNull, NULL_CHAR, MAX_RECORD_SIZE);
	
	if	((nSize == 0) || (memcmp(pData, strNull, nSize) == 0))
	{
		m_nClassifaction = -1;	//置空
		m_nRangeCount = 0;
		return;
	}

	ASSERT(pData && nSize>sizeof(int));
	ASSERT((nSize % sizeof(int) == 0));	//是sizeof(int)的整数倍

	BYTE *pTemp = (BYTE *)pData;

	memcpy(&m_nClassifaction, pTemp, sizeof(int));
	ASSERT(m_nClassifaction >=0 && m_nClassifaction <= 3);
	pTemp += sizeof(int);
	nSize -= sizeof(int);

	m_nRangeCount = 0;
	while (nSize > 0)
	{
		memcpy(&m_nRange[m_nRangeCount], pTemp, sizeof(int));
		if	(m_nRange[m_nRangeCount] == -1)	//空字符
			break;

		m_nRangeCount++;
		pTemp += sizeof(int);
		nSize -= sizeof(int);
	}
}

CSdbms_SecurityLevel::~CSdbms_SecurityLevel()
{
}


/**********************************************************************
功能：赋值运算符
***********************************************************************/
const CSdbms_SecurityLevel& CSdbms_SecurityLevel::operator=(const CSdbms_SecurityLevel& seclevel)
{
	m_nClassifaction = seclevel.m_nClassifaction;
	m_nRangeCount = seclevel.m_nRangeCount;
	for	(int i=0; i<m_nRangeCount; i++)
	{
		m_nRange[i]	= seclevel.m_nRange[i];
		m_strRange[i] = seclevel.m_strRange[i]; 
	}

	return *this;
}


/**********************************************************************
功能：'=='运算符
***********************************************************************/
bool CSdbms_SecurityLevel::operator==(const CSdbms_SecurityLevel& seclevel)
{
	if	(m_nClassifaction != seclevel.m_nClassifaction)
		return	FALSE;

	if	(m_nRangeCount != seclevel.m_nRangeCount)
		return	FALSE;

	for	(int i=0; i<m_nRangeCount; i++)
		if	(m_nRange[i] != seclevel.m_nRange[i])
			return	FALSE;

	return	TRUE;
}


/**********************************************************************
功能：'!='运算符
***********************************************************************/
bool CSdbms_SecurityLevel::operator!=(const CSdbms_SecurityLevel& seclevel)
{
	return	!operator==(seclevel);
}


/**********************************************************************
功能：'>'运算符
***********************************************************************/
bool CSdbms_SecurityLevel::operator>(const CSdbms_SecurityLevel& seclevel)
{
	if	((m_nClassifaction < seclevel.m_nClassifaction) ||
		 (m_nRangeCount < seclevel.m_nRangeCount) ||
		 ((m_nClassifaction == seclevel.m_nClassifaction) && (m_nRangeCount == seclevel.m_nRangeCount)))
		return	FALSE;

	for	(int i=0; i<seclevel.m_nRangeCount; i++)
	{
		for	(int j=0; j<m_nRangeCount; j++)
			if	(seclevel.m_nRange[i] <= m_nRange[j])
				break;

		if	((j < m_nRangeCount) && (seclevel.m_nRange[i] == m_nRange[j]))
			continue;
		else
			return	FALSE;
	}

	return	TRUE;
}


/**********************************************************************
功能：'>='运算符
***********************************************************************/
bool CSdbms_SecurityLevel::operator>=(const CSdbms_SecurityLevel& seclevel)
{
	if	((m_nClassifaction < seclevel.m_nClassifaction) ||
		 (m_nRangeCount < seclevel.m_nRangeCount))
		return	FALSE;

	for	(int i=0; i<seclevel.m_nRangeCount; i++)
	{
		for	(int j=0; j<m_nRangeCount; j++)
			if	(seclevel.m_nRange[i] <= m_nRange[j])
				break;

		if	((j < m_nRangeCount) && (seclevel.m_nRange[i] == m_nRange[j]))
			return	FALSE;
	}

	return	TRUE;
}


/**********************************************************************
功能：'<'运算符
***********************************************************************/
bool CSdbms_SecurityLevel::operator<(const CSdbms_SecurityLevel& seclevel)
{
	if	((m_nClassifaction > seclevel.m_nClassifaction) ||
		 (m_nRangeCount > seclevel.m_nRangeCount) ||
		 ((m_nClassifaction == seclevel.m_nClassifaction) && (m_nRangeCount == seclevel.m_nRangeCount)))
		return	FALSE;

	for	(int i=0; i<m_nRangeCount; i++)
	{
		for	(int j=0; j<seclevel.m_nRangeCount; j++)
			if	(m_nRange[i] <= seclevel.m_nRange[j])
				break;

		if	((j < seclevel.m_nRangeCount) && (m_nRange[i] == seclevel.m_nRange[j]))
			continue;
		else
			return	FALSE;
	}

	return	TRUE;
}


/**********************************************************************
功能：'<='运算符
***********************************************************************/
bool CSdbms_SecurityLevel::operator<=(const CSdbms_SecurityLevel& seclevel)
{
	if	((m_nClassifaction > seclevel.m_nClassifaction) ||
		 (m_nRangeCount > seclevel.m_nRangeCount))
		return	FALSE;

	for	(int i=0; i<m_nRangeCount; i++)
	{
		for	(int j=0; j<seclevel.m_nRangeCount; j++)
			if	(m_nRange[i] <= seclevel.m_nRange[j])
				break;

		if	((j < seclevel.m_nRangeCount) && (m_nRange[i] == seclevel.m_nRange[j]))
			continue;
		else
			return	FALSE;
	}

	return	TRUE;
}

/**********************************************************************
功能：判断安全级是否为空
***********************************************************************/
BOOL CSdbms_SecurityLevel::IsEmpty()
{
	return	(m_nClassifaction == -1);
}

/**********************************************************************
功能：置安全级为空
***********************************************************************/
void CSdbms_SecurityLevel::Empty()
{
	m_nClassifaction = -1;
	m_nRangeCount = 0;
}

/**********************************************************************
功能：得到安全级长度，即所占字节数
***********************************************************************/
UINT CSdbms_SecurityLevel::GetSize()
{
	if	(m_nClassifaction == -1)	//空
		return	0;

	return sizeof(int) + m_nRangeCount*sizeof(int);
}

/**********************************************************************
功能：得到字节形式的安全级数据，包含密级及非分层范围的内码表示
返回值：临时数据
***********************************************************************/
BYTE* CSdbms_SecurityLevel::GetValue()
{
	BYTE *pData = new BYTE[GetSize()];
	BYTE *ptr = pData;
	
	memcpy(ptr, &m_nClassifaction, sizeof(int));
	ptr += sizeof(int);
	for	(int i=0; i<m_nRangeCount; i++)
	{
		memcpy(ptr, &m_nRange[i], sizeof(int));
		ptr += sizeof(int);
	}

	return	pData;
}

/**********************************************************************
功能：得到字符串形式的安全级数据，包含密级及非分层范围的内码表示
参数：pslBase -- 带有非分层范围的字符串表示的安全级，须以此为基准
***********************************************************************/
CString CSdbms_SecurityLevel::GetFormatString(CSdbms_SecurityLevel *pslBase/*=NULL*/)
{
	if	(pslBase == NULL)
		pslBase = this;

	CString str, strTemp;
	strTemp.Format("(%d, {", m_nClassifaction);
	str += strTemp;
	for (int i=0; i<m_nRangeCount; i++)
	{
		int nIndex = m_nRange[i];
//		strTemp.Format("%d),", nIndex);
		str += pslBase->m_strRange[nIndex];
		str += ",";
//		str += "(";
//		str += strTemp;
		}
	if	(str[str.GetLength()-1] == ',')	//去除最后一个逗号
		str.Delete(str.GetLength()-1);
	str += "})";

	return	str;
}

/**********************************************************************
功能：判断某字符串是否属于非分层范围
返回值：TRUE－成功，FALSE－失败
		*nIndex－在非分层范围数组中的序号
***********************************************************************/
BOOL CSdbms_SecurityLevel::IsRangeItem(CString strItem, UINT *nIndex)
{
	for	(int i=0; i<m_nRangeCount; i++)
		if	(strItem.CompareNoCase(m_strRange[i]) == 0)
		{
			*nIndex = i;
			return	TRUE;
		}

	return	FALSE;
}

/**********************************************************************
功能：对安全级内码从小到大进行排序且去除重复的项(不考虑字符串)
***********************************************************************/
void CSdbms_SecurityLevel::Adjust()
{
	//排序
	for	(int i=0; i<m_nRangeCount-1; i++)
	{
		int nMin = i;
		for	(int j=i+1; j<m_nRangeCount; j++)
		{
			if	(m_nRange[nMin] > m_nRange[j])
				nMin = j;
		}
		if	(nMin != i)
		{
			int nTemp = m_nRange[i];
			m_nRange[i] = m_nRange[nMin];
			m_nRange[nMin] = nTemp;
		}
	}

	//去除重复项
	i = 1;
	while (i < m_nRangeCount)
	{
		if	(m_nRange[i-1] == m_nRange[i])
		{
			//前移一位
			for (int j=i+1; j<m_nRangeCount-1; j++)
				m_nRange[j-1] = m_nRange[j];
			m_nRangeCount--;
		}
		else
			i++;
	}
}

/**********************************************************************
功能：解析用户输入的用逗号隔开的非分层范围字符串
***********************************************************************/
void CSdbms_SecurityLevel::ParseRangeString(CString strRange)
{
	ASSERT(!(strRange.IsEmpty()));

	int	n = 0, nCount = 0;
	while ((nCount = strRange.Find(',')) != -1)
	{
		m_nRange[n] = n;	//编号
		m_strRange[n] = strRange.Left(nCount);
		n++;
		strRange = strRange.Right(strRange.GetLength() - nCount - 1);
	}

	ASSERT(!strRange.IsEmpty());
	m_nRange[n] = n;
	m_strRange[n] = strRange;
	m_nRangeCount = n+1;
}

/*类－数据库******************************************************************************/

/**********************************************************************
功能：初始化
***********************************************************************/
CSdbms_Database::CSdbms_Database()
{
	m_bInit	= FALSE;
	m_nMaxRoleID = ROLE_SYSTEM+1;
	m_nMaxTableID= 0;
	m_pCreatorRole = NULL;
	m_pRole = NULL;
//	m_pRole	= new CSdbms_Role();
//	m_pRole->m_nRoleID = m_nMaxRoleID++;
//	m_nMaxRoleID++;
}

/**********************************************************************
功能：初始化
***********************************************************************/
CSdbms_Database::CSdbms_Database(CString strDBName, UINT nDBID, CString strFilePath, CSdbms_User *pCreatorUser)
:m_strDBName(strDBName), m_nDBID(nDBID), m_strFilePath(strFilePath), m_nCreatorID(pCreatorUser->m_nUserID)
{
	m_bInit	= FALSE;
	m_nMaxRoleID = ROLE_SYSTEM+1;
	m_nMaxTableID= 0;

	m_pCreatorRole = new CSdbms_Role();
	m_pCreatorRole->m_nRoleID = m_nMaxRoleID++;
	m_pCreatorRole->m_strRoleName = SYSTEM_ROLE_OWNER;
	m_pRole = m_pCreatorRole;

	//对数据库创建者角色要添加一个对象权限结点，目的是为了记录权限被授予的角色
//	CSdbms_RoleObjectRight *pRight = new CSdbms_RoleObjectRight;
	m_pCreatorRole->m_ORList.AddHead(new CSdbms_RoleObjectRight);

//	m_pRole	= new CSdbms_Role();
//	m_pRole->m_strRoleName = SYSTEM_ROLE_OWNER;
//	m_pRole->m_nRoleID = m_nMaxRoleID++;

	//把DB创建者和DB创建者角色的关系加到角色用户关系链表中，并且是第一个
	CSdbms_RoleUser *pRoleUser = new CSdbms_RoleUser;
	pRoleUser->m_pRole = m_pCreatorRole;
	pRoleUser->m_pUser = pCreatorUser;
	m_pCreatorRole->m_pos = m_RoleUserList.AddHead(pRoleUser);
	pCreatorUser->m_pos = m_UserRoleList.AddHead(pRoleUser);