resultxsd.cpp

自动化编译工具代码

//////////////////////////////////////////////////////////////////////////////
//
// resultxsd.cpp
//
// Copyright (C) 2002 Altova GmbH - The XML Spy Company
// All rights reserved.
//
// This file was generated by XML Spy.
// DO NOT ALTER THIS FILE.
//
// Refer to the XML Spy Documentation for further details.
// http://www.xmlspy.com
//
//////////////////////////////////////////////////////////////////////////////


#include "stdafx.h"
#include "resultxsd.h"


void CresultxsdDoc::DeclareNamespaces(CNode& rNode)
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CErrorsType
//
//////////////////////////////////////////////////////////////////////////////


CErrorsType::CErrorsType(CSchemaByte::basetype Value) : CSchemaByte(Value)
{
	Validate();
}


CErrorsType::CErrorsType(const CString& sValue) : CSchemaByte(sValue)
{
	Validate();
}


void CErrorsType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CidType
//
//////////////////////////////////////////////////////////////////////////////


CidType::CidType(CSchemaByte::basetype Value) : CSchemaByte(Value)
{
	Validate();
}


CidType::CidType(const CString& sValue) : CSchemaByte(sValue)
{
	Validate();
}


void CidType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CFailedTestType
//
//////////////////////////////////////////////////////////////////////////////


int CFailedTestType::GetidMinCount()
{
	return 1;
}


int CFailedTestType::GetidMaxCount()
{
	return 1;
}


int CFailedTestType::GetidCount()
{
	return ChildCount(Attribute, _T(""), _T("id"));
}


bool CFailedTestType::Hasid()
{
	return GetidCount() > 0;
}


void CFailedTestType::Addid(CidType id)
{
	AppendChild(Attribute, _T(""), _T("id"), id);
}


CidType CFailedTestType::GetidAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Attribute, _T(""), _T("id"), nIndex)->text);
}


CidType CFailedTestType::Getid()
{
	return GetidAt(0);
}


void CFailedTestType::RemoveidAt(int nIndex)
{
	RemoveChildAt(Attribute, _T(""), _T("id"), nIndex);
}


void CFailedTestType::Removeid()
{
	while (Hasid())
		RemoveidAt(0);
}

int CFailedTestType::GetNameMinCount()
{
	return 1;
}


int CFailedTestType::GetNameMaxCount()
{
	return 1;
}


int CFailedTestType::GetNameCount()
{
	return ChildCount(Element, _T(""), _T("Name"));
}


bool CFailedTestType::HasName()
{
	return GetNameCount() > 0;
}


void CFailedTestType::AddName(CNameType Name)
{
	AppendChild(Element, _T(""), _T("Name"), Name);
}


CNameType CFailedTestType::GetNameAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("Name"), nIndex)->text);
}


CNameType CFailedTestType::GetName()
{
	return GetNameAt(0);
}


void CFailedTestType::RemoveNameAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("Name"), nIndex);
}


void CFailedTestType::RemoveName()
{
	while (HasName())
		RemoveNameAt(0);
}

int CFailedTestType::GetFailureTypeMinCount()
{
	return 1;
}


int CFailedTestType::GetFailureTypeMaxCount()
{
	return 1;
}


int CFailedTestType::GetFailureTypeCount()
{
	return ChildCount(Element, _T(""), _T("FailureType"));
}


bool CFailedTestType::HasFailureType()
{
	return GetFailureTypeCount() > 0;
}


void CFailedTestType::AddFailureType(CFailureTypeType FailureType)
{
	AppendChild(Element, _T(""), _T("FailureType"), FailureType);
}


CFailureTypeType CFailedTestType::GetFailureTypeAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("FailureType"), nIndex)->text);
}


CFailureTypeType CFailedTestType::GetFailureType()
{
	return GetFailureTypeAt(0);
}


void CFailedTestType::RemoveFailureTypeAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("FailureType"), nIndex);
}


void CFailedTestType::RemoveFailureType()
{
	while (HasFailureType())
		RemoveFailureTypeAt(0);
}

int CFailedTestType::GetLocationMinCount()
{
	return 1;
}


int CFailedTestType::GetLocationMaxCount()
{
	return 1;
}


int CFailedTestType::GetLocationCount()
{
	return ChildCount(Element, _T(""), _T("Location"));
}


bool CFailedTestType::HasLocation()
{
	return GetLocationCount() > 0;
}


void CFailedTestType::AddLocation(CLocationType Location)
{
	AppendChildElement(_T(""), _T("Location"), &Location);
}


CLocationType CFailedTestType::GetLocationAt(int nIndex)
{
	return CLocationType(*this, GetChildAt(Element, _T(""), _T("Location"), nIndex));
}


CLocationType CFailedTestType::GetLocation()
{
	return GetLocationAt(0);
}


void CFailedTestType::RemoveLocationAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("Location"), nIndex);
}


void CFailedTestType::RemoveLocation()
{
	while (HasLocation())
		RemoveLocationAt(0);
}

int CFailedTestType::GetMessageMinCount()
{
	return 1;
}


int CFailedTestType::GetMessageMaxCount()
{
	return 1;
}


int CFailedTestType::GetMessageCount()
{
	return ChildCount(Element, _T(""), _T("Message"));
}


bool CFailedTestType::HasMessage()
{
	return GetMessageCount() > 0;
}


void CFailedTestType::AddMessage(CSchemaString Message)
{
	AppendChild(Element, _T(""), _T("Message"), Message);
}


CSchemaString CFailedTestType::GetMessageAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("Message"), nIndex)->text);
}


CSchemaString CFailedTestType::GetMessage()
{
	return GetMessageAt(0);
}


void CFailedTestType::RemoveMessageAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("Message"), nIndex);
}


void CFailedTestType::RemoveMessage()
{
	while (HasMessage())
		RemoveMessageAt(0);
}

//////////////////////////////////////////////////////////////////////////////
//
// class CFailedTestsType
//
//////////////////////////////////////////////////////////////////////////////


int CFailedTestsType::GetFailedTestMinCount()
{
	return 1;
}


int CFailedTestsType::GetFailedTestMaxCount()
{
	return INT_MAX;
}


int CFailedTestsType::GetFailedTestCount()
{
	return ChildCount(Element, _T(""), _T("FailedTest"));
}


bool CFailedTestsType::HasFailedTest()
{
	return GetFailedTestCount() > 0;
}


void CFailedTestsType::AddFailedTest(CFailedTestType FailedTest)
{
	AppendChildElement(_T(""), _T("FailedTest"), &FailedTest);
}


CFailedTestType CFailedTestsType::GetFailedTestAt(int nIndex)
{
	return CFailedTestType(*this, GetChildAt(Element, _T(""), _T("FailedTest"), nIndex));
}


CFailedTestType CFailedTestsType::GetFailedTest()
{
	return GetFailedTestAt(0);
}


void CFailedTestsType::RemoveFailedTestAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("FailedTest"), nIndex);
}


void CFailedTestsType::RemoveFailedTest()
{
	while (HasFailedTest())
		RemoveFailedTestAt(0);
}

//////////////////////////////////////////////////////////////////////////////
//
// class CFailureTypeType
//
//////////////////////////////////////////////////////////////////////////////


CFailureTypeType::CFailureTypeType(CSchemaString::basetype Value) : CSchemaString(Value)
{
	Validate();
}


CFailureTypeType::CFailureTypeType(const CString& sValue) : CSchemaString(sValue)
{
	Validate();
}


void CFailureTypeType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CFailuresType
//
//////////////////////////////////////////////////////////////////////////////


CFailuresType::CFailuresType(CSchemaByte::basetype Value) : CSchemaByte(Value)
{
	Validate();
}


CFailuresType::CFailuresType(const CString& sValue) : CSchemaByte(sValue)
{
	Validate();
}


void CFailuresType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CFailuresTotalType
//
//////////////////////////////////////////////////////////////////////////////


CFailuresTotalType::CFailuresTotalType(CSchemaByte::basetype Value) : CSchemaByte(Value)
{
	Validate();
}


CFailuresTotalType::CFailuresTotalType(const CString& sValue) : CSchemaByte(sValue)
{
	Validate();
}


void CFailuresTotalType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CFileType
//
//////////////////////////////////////////////////////////////////////////////


CFileType::CFileType(CSchemaString::basetype Value) : CSchemaString(Value)
{
	Validate();
}


CFileType::CFileType(const CString& sValue) : CSchemaString(sValue)
{
	Validate();
}


void CFileType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CLineType
//
//////////////////////////////////////////////////////////////////////////////


CLineType::CLineType(CSchemaByte::basetype Value) : CSchemaByte(Value)
{
	Validate();
}


CLineType::CLineType(const CString& sValue) : CSchemaByte(sValue)
{
	Validate();
}


void CLineType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CLocationType
//
//////////////////////////////////////////////////////////////////////////////


int CLocationType::GetFileMinCount()
{
	return 1;
}


int CLocationType::GetFileMaxCount()
{
	return 1;
}


int CLocationType::GetFileCount()
{
	return ChildCount(Element, _T(""), _T("File"));
}


bool CLocationType::HasFile()
{
	return GetFileCount() > 0;
}


void CLocationType::AddFile(CFileType File)
{
	AppendChild(Element, _T(""), _T("File"), File);
}


CFileType CLocationType::GetFileAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("File"), nIndex)->text);
}


CFileType CLocationType::GetFile()
{
	return GetFileAt(0);
}


void CLocationType::RemoveFileAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("File"), nIndex);
}


void CLocationType::RemoveFile()
{
	while (HasFile())
		RemoveFileAt(0);
}

int CLocationType::GetLineMinCount()
{
	return 1;
}


int CLocationType::GetLineMaxCount()
{
	return 1;
}


int CLocationType::GetLineCount()
{
	return ChildCount(Element, _T(""), _T("Line"));
}


bool CLocationType::HasLine()
{
	return GetLineCount() > 0;
}


void CLocationType::AddLine(CLineType Line)
{
	AppendChild(Element, _T(""), _T("Line"), Line);
}


CLineType CLocationType::GetLineAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("Line"), nIndex)->text);
}


CLineType CLocationType::GetLine()
{
	return GetLineAt(0);
}


void CLocationType::RemoveLineAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("Line"), nIndex);
}


void CLocationType::RemoveLine()
{
	while (HasLine())
		RemoveLineAt(0);