node.cpp

自动化编译工具代码

}


void CDoc::SetRootElementName(CString sName, CString sNamespaceURI)
{
	m_sName = sName;
	m_sNamespaceURI = sNamespaceURI;
}


void CDoc::SetSchemaLocation(const CString& sSchemaLocation)
{
	m_sSchemaLocation = sSchemaLocation;
}


void CDoc::Save(const CString& sFilename, CNode& rNode)
{
	if (rNode.m_spNode->parentNode->nodeTypeString == _bstr_t(_T("documentfragment")))
	{
		FinalizeRootElement(rNode);
	}
	InternalSetSchemaLocation(rNode);

	rNode.m_spDocument->save(_variant_t(sFilename));
}


void CDoc::Validate(CNode& rNode)
{

	if (rNode.m_spNode->parentNode->nodeTypeString == _bstr_t(_T("documentfragment")))
	{
		FinalizeRootElement(rNode);
	}
	InternalSetSchemaLocation(rNode);

	MSXML2::IXMLDOMParseErrorPtr spError = rNode.m_spDocument->validate();
	if (spError->errorCode)
	{
		throw CNodeException(CNodeException::eError1, (LPCTSTR)spError->reason);
	}
}


void CDoc::FinalizeRootElement(CNode& rNode)
{
	if (m_sName.IsEmpty())
	{
		throw CNodeException(CNodeException::eError1, _T("Call SetRootElementName first"));
	}

	rNode.m_spDocument.CreateInstance(__uuidof(MSXML2::DOMDocument40));
	rNode.m_spDocument->async = VARIANT_FALSE;
	rNode.m_spDocument->setProperty(_T("NewParser"), true);

	rNode.m_spDocument->appendChild(rNode.m_spDocument->createProcessingInstruction(_T("xml"), _T("version='1.0' encoding='UTF-8'")));

	rNode.m_spNode = rNode.AppendChildElement(m_sNamespaceURI, m_sName, &rNode, rNode.m_spDocument);
	MSXML2::IXMLDOMElementPtr spRootElement = rNode.m_spNode;

	spRootElement->setAttribute(_T("xmlns:xsi"), _T("http://www.w3.org/2001/XMLSchema-instance"));

	if (m_sNamespaceURI.IsEmpty())
	{
		if (!m_sSchemaLocation.IsEmpty())
			spRootElement->setAttribute(_T("xsi:noNamespaceSchemaLocation"), (LPCTSTR)m_sSchemaLocation);
	}
	else
	{
		if (!m_sSchemaLocation.IsEmpty())
			spRootElement->setAttribute(_T("xsi:schemaLocation"), (LPCTSTR)(m_sNamespaceURI + _T(" ") + m_sSchemaLocation));
	}
	
	DeclareNamespaces(rNode);
}


void CDoc::InternalSetSchemaLocation(CNode& rNode)
{
	MSXML2::IXMLDOMElementPtr spRootElement = rNode.m_spNode;

	if (m_sNamespaceURI.IsEmpty())
	{
		if (!m_sSchemaLocation.IsEmpty() && spRootElement->getAttributeNode(_T("xsi:noNamespaceSchemaLocation")) == NULL)
			spRootElement->setAttribute(_T("xsi:noNamespaceSchemaLocation"), (LPCTSTR)m_sSchemaLocation);
	}
	else
	{
		if (!m_sSchemaLocation.IsEmpty() && spRootElement->getAttributeNode(_T("xsi:schemaLocation")) == NULL)
			spRootElement->setAttribute(_T("xsi:schemaLocation"), (LPCTSTR)(m_sNamespaceURI + _T(" ") + m_sSchemaLocation));
	}
}


///////////////////////////////////////////////////////////////////////////////
//
//  CSchemaBase64Binary
//
///////////////////////////////////////////////////////////////////////////////


const TCHAR CSchemaBase64Binary::m_EncodeArray[] =
	_T("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");


const TCHAR CSchemaBase64Binary::m_DecodeArray[] =
{
	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	62,	-1,	-1,	-1,	63,
	52,	53,	54,	55,	56,	57,	58,	59,	60,	61,	-1,	-1,	-1,	-1,	-1,	-1,
	-1,	 0,	 1,	 2,	 3,	 4,	 5,	 6,	 7,	 8,	 9,	10,	11,	12,	13,	14,
	15,	16,	17,	18,	19,	20,	21,	22,	23,	24,	25,	-1,	-1,	-1,	-1,	-1,
	-1,	26,	27,	28,	29,	30,	31,	32,	33,	34,	35,	36,	37,	38,	39,	40,
	41,	42,	43,	44,	45,	46,	47,	48,	49,	50,	51,	-1,	-1,	-1,	-1,	-1,
	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1
};


CSchemaBase64Binary::CSchemaBase64Binary(LPCTSTR szValue)
{
	Decode(szValue, m_pData, m_nSize);
}


CSchemaBase64Binary::CSchemaBase64Binary(const CSchemaBase64Binary& rOther)
{
	m_nSize = rOther.m_nSize;
	m_pData = new BYTE[m_nSize];
	memcpy(m_pData, rOther.m_pData, m_nSize);
}


CSchemaBase64Binary::CSchemaBase64Binary(const CString& sValue)
{
	Decode(sValue, m_pData, m_nSize);
}


CSchemaBase64Binary::~CSchemaBase64Binary()
{
	if (m_pData)
	{
		delete[] m_pData;
	}
}


CSchemaBase64Binary& CSchemaBase64Binary::operator =(const CSchemaBase64Binary& rOther)
{
	m_nSize = rOther.m_nSize;
	m_pData = new BYTE[m_nSize];
	memcpy(m_pData, rOther.m_pData, m_nSize);
	return *this;
}


int CSchemaBase64Binary::GetSize() const
{
	return m_nSize;
}


unsigned char* CSchemaBase64Binary::GetData() const
{
	return m_pData;
}


void CSchemaBase64Binary::SetData(LPBYTE pData, int nSize, bool bCopy/* = true*/)
{
	if (m_pData)
	{
		delete[] m_pData;
	}

	m_nSize = nSize;
	if (bCopy)
	{
		m_pData = new BYTE[m_nSize];
		memcpy(m_pData, pData, m_nSize);
	}
	else
	{
		m_pData = pData;
	}
}


CSchemaBase64Binary::operator CString()
{
	LPTSTR szDst;
	int nDstSize;
	CString sResult;
	Encode(m_pData, m_nSize, szDst, nDstSize);
	sResult = szDst;
	delete szDst;
	return sResult;
}


void CSchemaBase64Binary::Encode(LPBYTE pSrc, int nSrcSize, LPTSTR& rszDst, int& rnDstSize, int nMaxLineLength/* = 76*/)
{
	int		nTmpSize, nAllocSize, nLineLength, i;
	LPTSTR	szDstWriter;
	DWORD	bBuf;

	if (nSrcSize == 0)
	{
		rszDst = NULL;
		rnDstSize = 0;
		return;
	}

	nTmpSize	= nSrcSize * 4 / 3;
	nAllocSize	= nTmpSize + 8;
	if (nMaxLineLength > 0)
		nAllocSize += nTmpSize * 2 / nMaxLineLength;
	
	rszDst		= new TCHAR[nAllocSize];
	szDstWriter	= rszDst;
	nTmpSize	= nSrcSize / 3 * 3;
	rnDstSize	= 0;
	nLineLength	= 0;

	if (nMaxLineLength > 0)
	{
		for (i = 0; i < nTmpSize; i += 3)
		{
			bBuf = *(pSrc + i) << 16 | *(pSrc + i + 1) << 8 | *(pSrc + i + 2);
			*szDstWriter++ = m_EncodeArray[(bBuf >> 18) & 0x3F];
			*szDstWriter++ = m_EncodeArray[(bBuf >> 12) & 0x3F];
			*szDstWriter++ = m_EncodeArray[(bBuf >>  6) & 0x3F];
			*szDstWriter++ = m_EncodeArray[ bBuf        & 0x3F];
			rnDstSize += 4;

			nLineLength += 4;
			if (nMaxLineLength > 0 && nLineLength >= nMaxLineLength)
			{
				*szDstWriter++ = _T('\r');
				*szDstWriter++ = _T('\n');
				rnDstSize += 2;
				nLineLength = 0;
			}
		}
	}
	else
	{
		for (i = 0; i < nTmpSize; i += 3)
		{
			bBuf = *(pSrc + i) << 16 | *(pSrc + i + 1) << 8 | *(pSrc + i + 2);
			*szDstWriter++ = m_EncodeArray[(bBuf >> 18) & 0x3F];
			*szDstWriter++ = m_EncodeArray[(bBuf >> 12) & 0x3F];
			*szDstWriter++ = m_EncodeArray[(bBuf >>  6) & 0x3F];
			*szDstWriter++ = m_EncodeArray[ bBuf        & 0x3F];
			rnDstSize += 4;
		}
	}

	int nRest = nSrcSize - nTmpSize;
	if (nRest == 2)
	{
		bBuf = *(pSrc + i) << 8 | *(pSrc + i + 1);
		*szDstWriter++ = m_EncodeArray[(bBuf >> 10) & 0x3F];
		*szDstWriter++ = m_EncodeArray[(bBuf >>  4) & 0x3F];
		*szDstWriter++ = m_EncodeArray[(bBuf <<  2) & 0x3F];
		*szDstWriter++ = _T('=');
		rnDstSize += 4;
	}
	else if (nRest == 1)
	{
		bBuf = *(pSrc + i);
		*szDstWriter++ = m_EncodeArray[(bBuf >>  2) & 0x3F];
		*szDstWriter++ = m_EncodeArray[(bBuf <<  4) & 0x3F];
		*szDstWriter++ = _T('=');
		*szDstWriter++ = _T('=');
		rnDstSize += 4;
	}

	*szDstWriter = 0;
}


void CSchemaBase64Binary::Decode(LPCTSTR szSrc, LPBYTE& rpDst, int& rnDstSize)
{
	int			nSrcSize;
	LPCTSTR		szSrcReader;
	LPBYTE		pDstWriter;
	DWORD		nBuf;
	LPBYTE		pnBuf = (LPBYTE)&nBuf;
	int			nCount;

	szSrcReader	= szSrc;
	while (*szSrcReader && m_DecodeArray[*szSrcReader] == -1)
	{
		szSrcReader++;
	}
	nSrcSize = _tcslen(szSrcReader);
	if (nSrcSize == 0)
	{
		rpDst = NULL;
		rnDstSize = 0;
		return;
	}

	rpDst		= new BYTE[nSrcSize];
	pDstWriter	= rpDst;
	rnDstSize	= 0;
	nBuf		= 0;
	nCount		= 0;

	while (*szSrcReader)
	{
		while (m_DecodeArray[*szSrcReader] == -1)
		{
			if (!*++szSrcReader)
				goto finish;
		}

		nBuf |= m_DecodeArray[*szSrcReader++];

		if (++nCount == 4)
		{
			*pDstWriter++ = (BYTE)(nBuf >> 16);
			*pDstWriter++ = (BYTE)(nBuf >>  8);
			*pDstWriter++ = (BYTE) nBuf;
			rnDstSize += 3;
			nBuf = 0;
			nCount = 0;
		}
		else
		{
			nBuf <<= 6;
		}
	}

finish:
	if (nCount == 2)
	{
		*pDstWriter++ = (BYTE)(nBuf >> 10);
		rnDstSize++;
	}
	else if (nCount == 3)
	{
		*pDstWriter++ = (BYTE)(nBuf >> 16) & 0xFF;
		*pDstWriter++ = (BYTE)(nBuf >>  8) & 0xFF;
		rnDstSize += 2;
	}
}