config.cpp

自动化编译工具代码

//////////////////////////////////////////////////////////////////////////////
//
// config.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 "config.h"


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


//////////////////////////////////////////////////////////////////////////////
//
// class CBuildTypeType
//
//////////////////////////////////////////////////////////////////////////////


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


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


void CBuildTypeType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CConfigsType
//
//////////////////////////////////////////////////////////////////////////////


int CConfigsType::GetVSSInfoMinCount()
{
	return 1;
}


int CConfigsType::GetVSSInfoMaxCount()
{
	return 1;
}


int CConfigsType::GetVSSInfoCount()
{
	return ChildCount(Element, _T(""), _T("VSSInfo"));
}


bool CConfigsType::HasVSSInfo()
{
	return GetVSSInfoCount() > 0;
}


void CConfigsType::AddVSSInfo(CVSSInfoType VSSInfo)
{
	AppendChildElement(_T(""), _T("VSSInfo"), &VSSInfo);
}


CVSSInfoType CConfigsType::GetVSSInfoAt(int nIndex)
{
	return CVSSInfoType(*this, GetChildAt(Element, _T(""), _T("VSSInfo"), nIndex));
}


CVSSInfoType CConfigsType::GetVSSInfo()
{
	return GetVSSInfoAt(0);
}


void CConfigsType::RemoveVSSInfoAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("VSSInfo"), nIndex);
}


void CConfigsType::RemoveVSSInfo()
{
	while (HasVSSInfo())
		RemoveVSSInfoAt(0);
}

int CConfigsType::GetTestProjectsMinCount()
{
	return 1;
}


int CConfigsType::GetTestProjectsMaxCount()
{
	return 1;
}


int CConfigsType::GetTestProjectsCount()
{
	return ChildCount(Element, _T(""), _T("TestProjects"));
}


bool CConfigsType::HasTestProjects()
{
	return GetTestProjectsCount() > 0;
}


void CConfigsType::AddTestProjects(CTestProjectsType TestProjects)
{
	AppendChildElement(_T(""), _T("TestProjects"), &TestProjects);
}


CTestProjectsType CConfigsType::GetTestProjectsAt(int nIndex)
{
	return CTestProjectsType(*this, GetChildAt(Element, _T(""), _T("TestProjects"), nIndex));
}


CTestProjectsType CConfigsType::GetTestProjects()
{
	return GetTestProjectsAt(0);
}


void CConfigsType::RemoveTestProjectsAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("TestProjects"), nIndex);
}


void CConfigsType::RemoveTestProjects()
{
	while (HasTestProjects())
		RemoveTestProjectsAt(0);
}

//////////////////////////////////////////////////////////////////////////////
//
// class CDataBasePathType
//
//////////////////////////////////////////////////////////////////////////////


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


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


void CDataBasePathType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CProjectFileType
//
//////////////////////////////////////////////////////////////////////////////


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


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


void CProjectFileType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CProjectNameType
//
//////////////////////////////////////////////////////////////////////////////


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


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


void CProjectNameType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CProjectVersionType
//
//////////////////////////////////////////////////////////////////////////////


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


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


void CProjectVersionType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CTestProjectType
//
//////////////////////////////////////////////////////////////////////////////


int CTestProjectType::GetProjectNameMinCount()
{
	return 1;
}


int CTestProjectType::GetProjectNameMaxCount()
{
	return 1;
}


int CTestProjectType::GetProjectNameCount()
{
	return ChildCount(Element, _T(""), _T("ProjectName"));
}


bool CTestProjectType::HasProjectName()
{
	return GetProjectNameCount() > 0;
}


void CTestProjectType::AddProjectName(CProjectNameType ProjectName)
{
	AppendChild(Element, _T(""), _T("ProjectName"), ProjectName);
}


CProjectNameType CTestProjectType::GetProjectNameAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("ProjectName"), nIndex)->text);
}


CProjectNameType CTestProjectType::GetProjectName()
{
	return GetProjectNameAt(0);
}


void CTestProjectType::RemoveProjectNameAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("ProjectName"), nIndex);
}


void CTestProjectType::RemoveProjectName()
{
	while (HasProjectName())
		RemoveProjectNameAt(0);
}

int CTestProjectType::GetVSSPathMinCount()
{
	return 1;
}


int CTestProjectType::GetVSSPathMaxCount()
{
	return 1;
}


int CTestProjectType::GetVSSPathCount()
{
	return ChildCount(Element, _T(""), _T("VSSPath"));
}


bool CTestProjectType::HasVSSPath()
{
	return GetVSSPathCount() > 0;
}


void CTestProjectType::AddVSSPath(CVSSPathType VSSPath)
{
	AppendChild(Element, _T(""), _T("VSSPath"), VSSPath);
}


CVSSPathType CTestProjectType::GetVSSPathAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("VSSPath"), nIndex)->text);
}


CVSSPathType CTestProjectType::GetVSSPath()
{
	return GetVSSPathAt(0);
}


void CTestProjectType::RemoveVSSPathAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("VSSPath"), nIndex);
}


void CTestProjectType::RemoveVSSPath()
{
	while (HasVSSPath())
		RemoveVSSPathAt(0);
}

int CTestProjectType::GetProjectFileMinCount()
{
	return 1;
}


int CTestProjectType::GetProjectFileMaxCount()
{
	return 1;
}


int CTestProjectType::GetProjectFileCount()
{
	return ChildCount(Element, _T(""), _T("ProjectFile"));
}


bool CTestProjectType::HasProjectFile()
{
	return GetProjectFileCount() > 0;
}


void CTestProjectType::AddProjectFile(CProjectFileType ProjectFile)
{
	AppendChild(Element, _T(""), _T("ProjectFile"), ProjectFile);
}


CProjectFileType CTestProjectType::GetProjectFileAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("ProjectFile"), nIndex)->text);
}


CProjectFileType CTestProjectType::GetProjectFile()
{
	return GetProjectFileAt(0);
}


void CTestProjectType::RemoveProjectFileAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("ProjectFile"), nIndex);
}


void CTestProjectType::RemoveProjectFile()
{
	while (HasProjectFile())
		RemoveProjectFileAt(0);
}

int CTestProjectType::GetBuildTypeMinCount()
{
	return 1;
}


int CTestProjectType::GetBuildTypeMaxCount()
{
	return 1;
}


int CTestProjectType::GetBuildTypeCount()
{
	return ChildCount(Element, _T(""), _T("BuildType"));
}


bool CTestProjectType::HasBuildType()
{
	return GetBuildTypeCount() > 0;
}


void CTestProjectType::AddBuildType(CBuildTypeType BuildType)
{
	AppendChild(Element, _T(""), _T("BuildType"), BuildType);
}


CBuildTypeType CTestProjectType::GetBuildTypeAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("BuildType"), nIndex)->text);
}


CBuildTypeType CTestProjectType::GetBuildType()
{
	return GetBuildTypeAt(0);
}


void CTestProjectType::RemoveBuildTypeAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("BuildType"), nIndex);
}


void CTestProjectType::RemoveBuildType()
{
	while (HasBuildType())
		RemoveBuildTypeAt(0);
}

int CTestProjectType::GetProjectVersionMinCount()
{
	return 1;
}


int CTestProjectType::GetProjectVersionMaxCount()
{
	return 1;
}


int CTestProjectType::GetProjectVersionCount()
{
	return ChildCount(Element, _T(""), _T("ProjectVersion"));
}


bool CTestProjectType::HasProjectVersion()
{
	return GetProjectVersionCount() > 0;
}


void CTestProjectType::AddProjectVersion(CProjectVersionType ProjectVersion)
{
	AppendChild(Element, _T(""), _T("ProjectVersion"), ProjectVersion);
}


CProjectVersionType CTestProjectType::GetProjectVersionAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("ProjectVersion"), nIndex)->text);
}


CProjectVersionType CTestProjectType::GetProjectVersion()
{
	return GetProjectVersionAt(0);
}


void CTestProjectType::RemoveProjectVersionAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("ProjectVersion"), nIndex);
}


void CTestProjectType::RemoveProjectVersion()
{
	while (HasProjectVersion())
		RemoveProjectVersionAt(0);
}

//////////////////////////////////////////////////////////////////////////////
//
// class CTestProjectsType
//
//////////////////////////////////////////////////////////////////////////////


int CTestProjectsType::GetTestProjectMinCount()
{
	return 1;
}


int CTestProjectsType::GetTestProjectMaxCount()
{
	return 1;
}


int CTestProjectsType::GetTestProjectCount()
{
	return ChildCount(Element, _T(""), _T("TestProject"));
}


bool CTestProjectsType::HasTestProject()
{
	return GetTestProjectCount() > 0;
}


void CTestProjectsType::AddTestProject(CTestProjectType TestProject)
{
	AppendChildElement(_T(""), _T("TestProject"), &TestProject);
}


CTestProjectType CTestProjectsType::GetTestProjectAt(int nIndex)
{
	return CTestProjectType(*this, GetChildAt(Element, _T(""), _T("TestProject"), nIndex));
}


CTestProjectType CTestProjectsType::GetTestProject()
{
	return GetTestProjectAt(0);
}


void CTestProjectsType::RemoveTestProjectAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("TestProject"), nIndex);
}


void CTestProjectsType::RemoveTestProject()
{
	while (HasTestProject())
		RemoveTestProjectAt(0);
}

//////////////////////////////////////////////////////////////////////////////
//
// class CUserNameType
//
//////////////////////////////////////////////////////////////////////////////


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


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


void CUserNameType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CVSSInfoType
//
//////////////////////////////////////////////////////////////////////////////


int CVSSInfoType::GetDataBasePathMinCount()
{
	return 1;
}


int CVSSInfoType::GetDataBasePathMaxCount()
{
	return 1;
}


int CVSSInfoType::GetDataBasePathCount()
{
	return ChildCount(Element, _T(""), _T("DataBasePath"));
}


bool CVSSInfoType::HasDataBasePath()
{
	return GetDataBasePathCount() > 0;
}


void CVSSInfoType::AddDataBasePath(CDataBasePathType DataBasePath)
{
	AppendChild(Element, _T(""), _T("DataBasePath"), DataBasePath);
}


CDataBasePathType CVSSInfoType::GetDataBasePathAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("DataBasePath"), nIndex)->text);
}


CDataBasePathType CVSSInfoType::GetDataBasePath()
{
	return GetDataBasePathAt(0);
}


void CVSSInfoType::RemoveDataBasePathAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("DataBasePath"), nIndex);
}


void CVSSInfoType::RemoveDataBasePath()
{
	while (HasDataBasePath())
		RemoveDataBasePathAt(0);
}

int CVSSInfoType::GetUserNameMinCount()
{
	return 1;
}


int CVSSInfoType::GetUserNameMaxCount()
{
	return 1;
}


int CVSSInfoType::GetUserNameCount()
{
	return ChildCount(Element, _T(""), _T("UserName"));
}


bool CVSSInfoType::HasUserName()
{
	return GetUserNameCount() > 0;
}


void CVSSInfoType::AddUserName(CUserNameType UserName)
{
	AppendChild(Element, _T(""), _T("UserName"), UserName);
}


CUserNameType CVSSInfoType::GetUserNameAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("UserName"), nIndex)->text);
}


CUserNameType CVSSInfoType::GetUserName()
{
	return GetUserNameAt(0);
}


void CVSSInfoType::RemoveUserNameAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("UserName"), nIndex);
}


void CVSSInfoType::RemoveUserName()
{
	while (HasUserName())
		RemoveUserNameAt(0);
}

int CVSSInfoType::GetPasswordMinCount()
{
	return 1;
}


int CVSSInfoType::GetPasswordMaxCount()
{
	return 1;
}


int CVSSInfoType::GetPasswordCount()
{
	return ChildCount(Element, _T(""), _T("Password"));
}


bool CVSSInfoType::HasPassword()
{
	return GetPasswordCount() > 0;
}


void CVSSInfoType::AddPassword(CSchemaString Password)
{
	AppendChild(Element, _T(""), _T("Password"), Password);
}


CSchemaString CVSSInfoType::GetPasswordAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("Password"), nIndex)->text);
}


CSchemaString CVSSInfoType::GetPassword()
{
	return GetPasswordAt(0);
}


void CVSSInfoType::RemovePasswordAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("Password"), nIndex);
}


void CVSSInfoType::RemovePassword()
{
	while (HasPassword())
		RemovePasswordAt(0);
}

//////////////////////////////////////////////////////////////////////////////
//
// class CVSSPathType
//
//////////////////////////////////////////////////////////////////////////////


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


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


void CVSSPathType::Validate()
{
}