windows-server-2003/admin/wmi/wbem/providers/dsprovider/adsiclas.cpp

//

// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
//
// ***************************************************************************
//
//	Original Author: Rajesh Rao
//
// 	$Author: rajeshr $
//	$Date: 6/11/98 4:43p $
// 	$Workfile:adsiclas.cpp $
//
//	$Modtime: 6/11/98 11:21a $
//	$Revision: 1 $	
//	$Nokeywords:  $
//
// 
//  Description: Contains the implementation of the CADSIClass which encapsulates an ADSI class
//
//***************************************************************************

#include "precomp.h"

//***************************************************************************
//
// CADSIClass::CADSIClass
//
// Purpose : Constructor 
//
// Parameters:
//  lpszWBEMClassName : The WBEM name of the Class being created. A copy of this is made
//  lpszADSIClassName : The ADSI name of the Class being created. A copy of this is made
//***************************************************************************
CADSIClass :: CADSIClass(LPCWSTR lpszWBEMClassName, LPCWSTR lpszADSIClassName)
	: CRefCountedObject(lpszADSIClassName)
{
	if(lpszWBEMClassName)
	{
		m_lpszWBEMClassName = new WCHAR[wcslen(lpszWBEMClassName) + 1];
		wcscpy(m_lpszWBEMClassName, lpszWBEMClassName);
	}
	else
	{
		m_lpszWBEMClassName = NULL;
	}

	// Set the attributes to theri default values
	m_lpszCommonName = NULL;
	m_lpszSuperClassLDAPName = NULL;
	m_lpszGovernsID = NULL;
	m_pSchemaIDGUIDOctets = NULL;
	m_dwSchemaIDGUIDLength = 0;
	m_lpszRDNAttribute = NULL;
	m_lpszDefaultSecurityDescriptor = NULL;
	m_dwObjectClassCategory = 0;
	m_dwNTSecurityDescriptorLength = 0;
	m_pNTSecurityDescriptor = NULL;
	m_lpszDefaultObjectCategory = NULL;
	m_bSystemOnly = FALSE;

	// Initialize the property book keeping
	m_lppszAuxiliaryClasses = NULL;
	m_dwAuxiliaryClassesCount = 0;
	m_lppszSystemAuxiliaryClasses = NULL;
	m_dwSystemAuxiliaryClassesCount = 0;
	m_lppszPossibleSuperiors = NULL;
	m_dwPossibleSuperiorsCount = 0;
	m_lppszSystemPossibleSuperiors = NULL;
	m_dwSystemPossibleSuperiorsCount = 0;
	m_lppszMayContains = NULL;
	m_dwMayContainsCount = 0;
	m_lppszSystemMayContains = NULL;
	m_dwSystemMayContainsCount = 0;
	m_lppszMustContains = NULL;
	m_dwMustContainsCount = 0;
	m_lppszSystemMustContains = NULL;
	m_dwSystemMustContainsCount = 0;
}


//***************************************************************************
//
// CADSIClass :: ~CADSIClass
// 
// Purpose : Destructor
//***************************************************************************
CADSIClass :: ~CADSIClass()
{
	// Delete the WBEM Name. The ADSI Name is deleted in the base class destructor
	if ( m_lpszWBEMClassName )
	{
		delete [] m_lpszWBEMClassName;
		m_lpszWBEMClassName = NULL;
	}

	// Delete the attributes
	if ( m_lpszCommonName )
	{
		delete [] m_lpszCommonName;
		m_lpszCommonName = NULL;
	}
	if ( m_lpszSuperClassLDAPName )
	{
		delete [] m_lpszSuperClassLDAPName;
		m_lpszSuperClassLDAPName = NULL;
	}
	if ( m_lpszGovernsID )
	{
		delete [] m_lpszGovernsID;
		m_lpszGovernsID = NULL;
	}
	if ( m_pSchemaIDGUIDOctets ) 
	{
		delete [] m_pSchemaIDGUIDOctets;
		m_pSchemaIDGUIDOctets = NULL;
	}
	if ( m_lpszRDNAttribute )
	{
		delete [] m_lpszRDNAttribute;
		m_lpszRDNAttribute = NULL;
	}
	if ( m_lpszDefaultSecurityDescriptor )
	{
		delete [] m_lpszDefaultSecurityDescriptor;
		m_lpszDefaultSecurityDescriptor = NULL;
	}
	if ( m_pNTSecurityDescriptor )
	{
		delete [] m_pNTSecurityDescriptor;
		m_pNTSecurityDescriptor = NULL;
	}
	if ( m_lpszDefaultObjectCategory )
	{
		delete [] m_lpszDefaultObjectCategory;
		m_lpszDefaultObjectCategory = NULL;
	}

	DWORD i;
	// Delete the list of Auxiliary Classes
	if ( m_lppszAuxiliaryClasses )
	{
		for(i=0; i<m_dwAuxiliaryClassesCount; i++)
		{
			delete [] m_lppszAuxiliaryClasses[i];
			m_lppszAuxiliaryClasses[i] = NULL;
		}
		delete[] m_lppszAuxiliaryClasses;
		m_lppszAuxiliaryClasses = NULL;
	}

	// Delete the list of System Auxiliary Classes
	if ( m_lppszSystemAuxiliaryClasses )
	{
		for(i=0; i<m_dwSystemAuxiliaryClassesCount; i++)
		{
			delete [] m_lppszSystemAuxiliaryClasses[i];
			m_lppszSystemAuxiliaryClasses[i] = NULL;
		}
		delete[] m_lppszSystemAuxiliaryClasses;
		m_lppszSystemAuxiliaryClasses = NULL;
	}

	// Delete the list of possible superiors
	if ( m_lppszPossibleSuperiors )
	{
		for(i=0; i<m_dwPossibleSuperiorsCount; i++)
		{
			delete [] m_lppszPossibleSuperiors[i];
			m_lppszPossibleSuperiors[i] = NULL;
		}
		delete[] m_lppszPossibleSuperiors;
		m_lppszPossibleSuperiors = NULL;
	}

	// Delete the list of System possible superiors
	if ( m_lppszSystemPossibleSuperiors )
	{
		for(i=0; i<m_dwSystemPossibleSuperiorsCount; i++)
		{
			delete [] m_lppszSystemPossibleSuperiors[i];
			m_lppszSystemPossibleSuperiors[i] = NULL;
		}
		delete[] m_lppszSystemPossibleSuperiors;
		m_lppszSystemPossibleSuperiors = NULL;
	}

	// Delete the list of may contains
	if ( m_lppszMayContains )
	{
		for(i=0; i<m_dwMayContainsCount; i++)
		{
			delete [] m_lppszMayContains[i];
			m_lppszMayContains[i] = NULL;
		}
		delete[] m_lppszMayContains;
		m_lppszMayContains = NULL;
	}

	// Delete the list of System may contains
	if ( m_lppszSystemMayContains )
	{
		for(i=0; i<m_dwSystemMayContainsCount; i++)
		{
			delete [] m_lppszSystemMayContains[i];
			m_lppszSystemMayContains[i] = NULL;
		}
		delete[] m_lppszSystemMayContains;
		m_lppszSystemMayContains = NULL;
	}

	// Delete the list of Must Contains
	if ( m_lppszMustContains )
	{
		for(i=0; i<m_dwMustContainsCount; i++)
		{
			delete [] m_lppszMustContains[i];
			m_lppszMustContains[i] = NULL;
		}
		delete[] m_lppszMustContains;
		m_lppszMustContains = NULL;
	}

	// Delete the list of System Must Contains
	if ( m_lppszSystemMustContains )
	{
		for(i=0; i<m_dwSystemMustContainsCount; i++)
		{
			delete [] m_lppszSystemMustContains[i];
			m_lppszSystemMustContains[i] = NULL;
		}
		delete[] m_lppszSystemMustContains;
		m_lppszSystemMustContains = NULL;
	}

}


//***************************************************************************
//
// CADSIClass :: GetWBEMClassName
// 
// Purpose : Returns the WBEM  Class name of this Class
//***************************************************************************
LPCWSTR CADSIClass :: GetWBEMClassName()
{
	return m_lpszWBEMClassName;
}

//***************************************************************************
//
// CADSIClass :: GetWBEMClassName
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass::SetWBEMClassName(LPCWSTR lpszName)
{
	if ( m_lpszWBEMClassName )
	{
		delete[] m_lpszWBEMClassName;
		m_lpszWBEMClassName = NULL;
	}

	if(lpszName)
	{
		m_lpszWBEMClassName = new WCHAR[wcslen(lpszName) + 1];
		wcscpy(m_lpszWBEMClassName, lpszName);
	}
}

//***************************************************************************
//
// CADSIClass :: GetADSIClassName
// 
// Purpose : See Header
//***************************************************************************
LPCWSTR CADSIClass :: GetADSIClassName()
{
	return GetName();
}

//***************************************************************************
//
// CADSIClass :: GetADSIClassName
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetADSIClassName(LPCWSTR lpszName)
{
	SetName(lpszName);
}

//***************************************************************************
//
// CADSIClass :: GetCommonName
// 
// Purpose : See Header
//
//***************************************************************************
LPCWSTR CADSIClass :: GetCommonName()
{
	return m_lpszCommonName;
}

//***************************************************************************
//
// CADSIClass :: SetCommonName
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetCommonName(LPCWSTR lpszCommonName)
{
	if ( m_lpszCommonName )
	{
		delete[] m_lpszCommonName;
		m_lpszCommonName = NULL;
	}

	if(lpszCommonName)
	{
		m_lpszCommonName = new WCHAR[wcslen(lpszCommonName) + 1];
		wcscpy(m_lpszCommonName, lpszCommonName);
	}
}


//***************************************************************************
//
// CADSIClass :: GetSuperClassLDAPName
// 
// Purpose : See Header
//
//***************************************************************************
LPCWSTR CADSIClass :: GetSuperClassLDAPName()
{
	return m_lpszSuperClassLDAPName;
}

//***************************************************************************
//
// CADSIClass :: SetSuperClassLDAPName
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetSuperClassLDAPName(LPCWSTR lpszSuperClassLDAPName)
{
	if ( m_lpszSuperClassLDAPName )
	{
		delete[] m_lpszSuperClassLDAPName;
		m_lpszSuperClassLDAPName = NULL;
	}

	if(lpszSuperClassLDAPName)
	{
		m_lpszSuperClassLDAPName = new WCHAR[wcslen(lpszSuperClassLDAPName) + 1];
		wcscpy(m_lpszSuperClassLDAPName, lpszSuperClassLDAPName);
	}
}

//***************************************************************************
//
// CADSIClass :: GetGovernsID
// 
// Purpose : See Header
//***************************************************************************
LPCWSTR CADSIClass :: GetGovernsID()
{
	return m_lpszGovernsID;
}

//***************************************************************************
//
// CADSIClass :: SetGovernsID
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetGovernsID(LPCWSTR lpszGovernsID)
{
	if ( m_lpszGovernsID )
	{
		delete[] m_lpszGovernsID;
		m_lpszGovernsID = NULL;
	}

	if(lpszGovernsID)
	{
		m_lpszGovernsID = new WCHAR[wcslen(lpszGovernsID) + 1];
		wcscpy(m_lpszGovernsID, lpszGovernsID);
	}
}

//***************************************************************************
//
// CADSIClass :: GetSchemaIDGUID
// 
// Purpose : See Header
//***************************************************************************
const LPBYTE CADSIClass :: GetSchemaIDGUID(DWORD *pdwLength)
{
	*pdwLength = m_dwSchemaIDGUIDLength;
	return m_pSchemaIDGUIDOctets;
}

//***************************************************************************
//
// CADSIClass :: SetSchemaIDGUID
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetSchemaIDGUID(LPBYTE pOctets, DWORD dwLength)
{
	if ( m_pSchemaIDGUIDOctets )
	{
		delete[] m_pSchemaIDGUIDOctets;
		m_pSchemaIDGUIDOctets = NULL;
	}

	m_dwSchemaIDGUIDLength = 0;

	if(pOctets)
	{
		m_dwSchemaIDGUIDLength = dwLength;
		if(m_pSchemaIDGUIDOctets = new BYTE[dwLength])
		{
			for(DWORD i=0; i<dwLength; i++)
				m_pSchemaIDGUIDOctets[i] = pOctets[i];
		}
	}
}

//***************************************************************************
//
// CADSIClass :: GetRDNAttribute
// 
// Purpose : See Header
//
//***************************************************************************
LPCWSTR CADSIClass :: GetRDNAttribute()
{
	return m_lpszRDNAttribute;
}

//***************************************************************************
//
// CADSIClass :: SetRDNAttribute
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetRDNAttribute(LPCWSTR lpszRDNAttribute)
{
	if ( m_lpszRDNAttribute )
	{
		delete[] m_lpszRDNAttribute;
		m_lpszRDNAttribute = NULL;
	}

	if(lpszRDNAttribute)
	{
		m_lpszRDNAttribute = new WCHAR[wcslen(lpszRDNAttribute) + 1];
		wcscpy(m_lpszRDNAttribute, lpszRDNAttribute);
	}
}


//***************************************************************************
//
// CADSIClass :: GetDefaultSecurityDescriptor
// 
// Purpose : See Header
//***************************************************************************
LPCWSTR CADSIClass :: GetDefaultSecurityDescriptor()
{
	return m_lpszDefaultSecurityDescriptor;
}

//***************************************************************************
//
// CADSIClass :: SetDefaultSecurityDescriptor
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetDefaultSecurityDescriptor(LPCWSTR lpszDefaultSecurityDescriptor)
{
	if ( m_lpszDefaultSecurityDescriptor )
	{
		delete[] m_lpszDefaultSecurityDescriptor;
		m_lpszDefaultSecurityDescriptor = NULL;
	}

	if( lpszDefaultSecurityDescriptor)
	{
		m_lpszDefaultSecurityDescriptor = new WCHAR[wcslen(lpszDefaultSecurityDescriptor) + 1];
		wcscpy(m_lpszDefaultSecurityDescriptor, lpszDefaultSecurityDescriptor);
	}
}

//***************************************************************************
//
// CADSIClass :: GetObjectClassCategory
// 
// Purpose : See Header
//***************************************************************************
DWORD CADSIClass :: GetObjectClassCategory()
{
	return m_dwObjectClassCategory;
}

//***************************************************************************
//
// CADSIClass :: SetObjectClassCategory
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetObjectClassCategory(DWORD dwObjectClassCategory)
{
	m_dwObjectClassCategory = dwObjectClassCategory;
}

//***************************************************************************
//
// CADSIClass :: GetNTSecurityDescriptor
// 
// Purpose : See Header
//***************************************************************************
const LPBYTE CADSIClass :: GetNTSecurityDescriptor(DWORD *pdwLength)
{
	*pdwLength = m_dwNTSecurityDescriptorLength;
	return m_pNTSecurityDescriptor;
}

//***************************************************************************
//
// CADSIClass :: SetNTSecurityDescriptor
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetNTSecurityDescriptor(LPBYTE pOctets, DWORD dwLength)
{
	if ( m_pNTSecurityDescriptor )
	{
		delete[] m_pNTSecurityDescriptor;
		m_pNTSecurityDescriptor = NULL;
	}

	m_dwNTSecurityDescriptorLength = 0;

	if(pOctets)
	{
		m_dwNTSecurityDescriptorLength = dwLength;
		if(m_pNTSecurityDescriptor = new BYTE[dwLength])
		{
			for(DWORD i=0; i<dwLength; i++)
				m_pNTSecurityDescriptor[i] = pOctets[i];
		}
	}
}

//***************************************************************************
//
// CADSIClass :: GetDefaultObjectCategory
// 
// Purpose : See Header
//***************************************************************************
LPCWSTR CADSIClass :: GetDefaultObjectCategory()
{
	return m_lpszDefaultObjectCategory;
}

//***************************************************************************
//
// CADSIClass :: SetDefaultObjectCategory
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetDefaultObjectCategory(LPCWSTR lpszDefaultObjectCategory)
{
	if ( m_lpszDefaultObjectCategory )
	{
		delete[] m_lpszDefaultObjectCategory;
		m_lpszDefaultObjectCategory = NULL;
	}

	if (lpszDefaultObjectCategory)
	{
		m_lpszDefaultObjectCategory = new WCHAR[wcslen(lpszDefaultObjectCategory) + 1];
		wcscpy(m_lpszDefaultObjectCategory, lpszDefaultObjectCategory);
	}
}

//***************************************************************************
//
// CADSIClass :: GetSystemOnly
// 
// Purpose : See Header
//***************************************************************************
BOOLEAN CADSIClass :: GetSystemOnly()
{
	return m_bSystemOnly;
}

//***************************************************************************
//
// CADSIClass :: SetSystemOnly
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetSystemOnly(BOOLEAN bSystemOnly)
{
	m_bSystemOnly = bSystemOnly;
}

//***************************************************************************
//
// CADSIClass :: GetAuxiliaryClasses
// 
// Purpose : See Header
//***************************************************************************
LPCWSTR *CADSIClass :: GetAuxiliaryClasses(DWORD *pdwCount)
{
	*pdwCount = m_dwAuxiliaryClassesCount;
	return (LPCWSTR *)m_lppszAuxiliaryClasses;
}

//***************************************************************************
//
// CADSIClass :: SetAuxiliaryClasses
// 
// Purpose : See Header

//***************************************************************************
void CADSIClass :: SetAuxiliaryClasses(PADSVALUE pValues, DWORD dwNumValues)
{
	DWORD i = 0;

	// Delete the list of possible superiors
	if ( m_lppszAuxiliaryClasses )
	{
		for ( i = 0; i<m_dwAuxiliaryClassesCount; i++ )
		{
			if ( m_lppszAuxiliaryClasses [ i ] )
			{
				delete [] m_lppszAuxiliaryClasses [ i ];
				m_lppszAuxiliaryClasses [ i ] = NULL;
			}
		}

		delete [] m_lppszAuxiliaryClasses;
		m_lppszAuxiliaryClasses = NULL;
		m_dwAuxiliaryClassesCount = 0;
	}

	// Set the new list of values
	m_dwAuxiliaryClassesCount = dwNumValues;
	m_lppszAuxiliaryClasses = new LPWSTR[m_dwAuxiliaryClassesCount];
	for(i=0; i<m_dwAuxiliaryClassesCount; i++)
	{
		try
		{
			m_lppszAuxiliaryClasses[i] = new WCHAR[wcslen(pValues->CaseIgnoreString) + 1];
			wcscpy(m_lppszAuxiliaryClasses[i], pValues->CaseIgnoreString);
		}
		catch ( ... )
		{
			if ( m_lppszAuxiliaryClasses )
			{
				m_dwAuxiliaryClassesCount = 0;

				for ( DWORD dw = 0; dw < i; dw++ )
				{
					if ( m_lppszAuxiliaryClasses [ dw ] )
					{
						delete [] m_lppszAuxiliaryClasses [ dw ];
						m_lppszAuxiliaryClasses [ dw ] = NULL;
					}
				}

				delete [] m_lppszAuxiliaryClasses;
				m_lppszAuxiliaryClasses = NULL;
			}

			throw;
		}

		pValues ++;
	}
}

//***************************************************************************
//
// CADSIClass :: GetSystemAuxiliaryClasses
// 
// Purpose : See Header
//***************************************************************************
LPCWSTR *CADSIClass :: GetSystemAuxiliaryClasses(DWORD *pdwCount)
{
	*pdwCount = m_dwSystemAuxiliaryClassesCount;
	return (LPCWSTR *)m_lppszSystemAuxiliaryClasses;
}

//***************************************************************************
//
// CADSIClass :: SetSystemAuxiliaryClasses
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetSystemAuxiliaryClasses(PADSVALUE pValues, DWORD dwNumValues)
{
	DWORD i = 0;

	// Delete the list of possible superiors
	if ( m_lppszSystemAuxiliaryClasses )
	{
		for ( i = 0; i<m_dwSystemAuxiliaryClassesCount; i++ )
		{
			if ( m_lppszSystemAuxiliaryClasses [ i ] )
			{
				delete [] m_lppszSystemAuxiliaryClasses [ i ];
				m_lppszSystemAuxiliaryClasses [ i ] = NULL;
			}
		}

		delete [] m_lppszSystemAuxiliaryClasses;
		m_lppszSystemAuxiliaryClasses = NULL;
		m_dwSystemAuxiliaryClassesCount = 0;
	}
	
	// Set the new list of values
	m_dwSystemAuxiliaryClassesCount = dwNumValues;
	m_lppszSystemAuxiliaryClasses = new LPWSTR[m_dwSystemAuxiliaryClassesCount];
	for(i=0; i<m_dwSystemAuxiliaryClassesCount; i++)
	{
		try
		{
			m_lppszSystemAuxiliaryClasses[i] = new WCHAR[wcslen(pValues->CaseIgnoreString) + 1];
			wcscpy(m_lppszSystemAuxiliaryClasses[i], pValues->CaseIgnoreString);
		}
		catch ( ... )
		{
			if ( m_lppszSystemAuxiliaryClasses )
			{
				m_dwSystemAuxiliaryClassesCount = 0;

				for ( DWORD dw = 0; dw < i; dw++ )
				{
					if ( m_lppszSystemAuxiliaryClasses [ dw ] )
					{
						delete [] m_lppszSystemAuxiliaryClasses [ dw ];
						m_lppszSystemAuxiliaryClasses [ dw ] = NULL;
					}
				}

				delete [] m_lppszSystemAuxiliaryClasses;
				m_lppszSystemAuxiliaryClasses = NULL;
			}

			throw;
		}

		pValues ++;
	}
}

//***************************************************************************
//
// CADSIClass :: GetPossibleSuperiors
// 
// Purpose : See Header
//***************************************************************************
LPCWSTR *CADSIClass :: GetPossibleSuperiors(DWORD *pdwCount)
{
	*pdwCount = m_dwPossibleSuperiorsCount;
	return (LPCWSTR *)m_lppszPossibleSuperiors;
}

//***************************************************************************
//
// CADSIClass :: SetPossibleSuperiors
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetPossibleSuperiors(PADSVALUE pValues, DWORD dwNumValues)
{
	DWORD i = 0;

	// Delete the list of possible superiors
	if ( m_lppszPossibleSuperiors )
	{
		for ( i = 0; i<m_dwPossibleSuperiorsCount; i++ )
		{
			if ( m_lppszPossibleSuperiors [ i ] )
			{
				delete [] m_lppszPossibleSuperiors [ i ];
				m_lppszPossibleSuperiors [ i ] = NULL;
			}
		}

		delete [] m_lppszPossibleSuperiors;
		m_lppszPossibleSuperiors = NULL;
		m_dwPossibleSuperiorsCount = 0;
	}

	// Set the new list of values
	m_dwPossibleSuperiorsCount = dwNumValues;
	m_lppszPossibleSuperiors = new LPWSTR[m_dwPossibleSuperiorsCount];
	for(i=0; i<m_dwPossibleSuperiorsCount; i++)
	{
		try
		{
			m_lppszPossibleSuperiors[i] = new WCHAR[wcslen(pValues->CaseIgnoreString) + 1];
			wcscpy(m_lppszPossibleSuperiors[i], pValues->CaseIgnoreString);
		}
		catch ( ... )
		{
			if ( m_lppszPossibleSuperiors )
			{
				m_dwPossibleSuperiorsCount = 0;

				for ( DWORD dw = 0; dw < i; dw++ )
				{
					if ( m_lppszPossibleSuperiors [ dw ] )
					{
						delete [] m_lppszPossibleSuperiors [ dw ];
						m_lppszPossibleSuperiors [ dw ] = NULL;
					}
				}

				delete [] m_lppszPossibleSuperiors;
				m_lppszPossibleSuperiors = NULL;
			}

			throw;
		}

		pValues ++;
	}
}

//***************************************************************************
//
// CADSIClass :: GetSystemPossibleSuperiors
// 
// Purpose : See Header
//***************************************************************************
LPCWSTR *CADSIClass :: GetSystemPossibleSuperiors(DWORD *pdwCount)
{
	*pdwCount = m_dwSystemPossibleSuperiorsCount;
	return (LPCWSTR *)m_lppszSystemPossibleSuperiors;
}

//***************************************************************************
//
// CADSIClass :: SetSystemPossibleSuperiors
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetSystemPossibleSuperiors(PADSVALUE pValues, DWORD dwNumValues)
{
	DWORD i = 0;

	// Delete the list of possible superiors
	if ( m_lppszSystemPossibleSuperiors )
	{
		for ( i = 0; i<m_dwSystemPossibleSuperiorsCount; i++ )
		{
			if ( m_lppszSystemPossibleSuperiors [ i ] )
			{
				delete [] m_lppszSystemPossibleSuperiors [ i ];
				m_lppszSystemPossibleSuperiors [ i ] = NULL;
			}
		}

		delete [] m_lppszSystemPossibleSuperiors;
		m_lppszSystemPossibleSuperiors = NULL;
		m_dwSystemPossibleSuperiorsCount = 0;
	}

	// Set the new list of values
	m_dwSystemPossibleSuperiorsCount = dwNumValues;
	m_lppszSystemPossibleSuperiors = new LPWSTR[m_dwSystemPossibleSuperiorsCount];
	for(i=0; i<m_dwSystemPossibleSuperiorsCount; i++)
	{
		try
		{
			m_lppszSystemPossibleSuperiors[i] = new WCHAR[wcslen(pValues->CaseIgnoreString) + 1];
			wcscpy(m_lppszSystemPossibleSuperiors[i], pValues->CaseIgnoreString);
		}
		catch ( ... )
		{
			if ( m_lppszSystemPossibleSuperiors )
			{
				m_dwSystemPossibleSuperiorsCount = 0;

				for ( DWORD dw = 0; dw < i; dw++ )
				{
					if ( m_lppszSystemPossibleSuperiors [ dw ] )
					{
						delete [] m_lppszSystemPossibleSuperiors [ dw ];
						m_lppszSystemPossibleSuperiors [ dw ] = NULL;
					}
				}

				delete [] m_lppszSystemPossibleSuperiors;
				m_lppszSystemPossibleSuperiors = NULL;
			}

			throw;
		}

		pValues ++;
	}
}


//***************************************************************************
//
// CADSIClass :: GetMayContains
// 
// Purpose : See Header
//***************************************************************************
LPCWSTR *CADSIClass :: GetMayContains(DWORD *pdwCount)
{
	*pdwCount = m_dwMayContainsCount;
	return (LPCWSTR *)m_lppszMayContains;
}

//***************************************************************************
//
// CADSIClass :: SetMayContains
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetMayContains(PADSVALUE pValues, DWORD dwNumValues)
{
	DWORD i = 0;

	// Delete the list of possible superiors
	if ( m_lppszMayContains )
	{
		for ( i = 0; i<m_dwMayContainsCount; i++ )
		{
			if ( m_lppszMayContains [ i ] )
			{
				delete [] m_lppszMayContains [ i ];
				m_lppszMayContains [ i ] = NULL;
			}
		}

		delete [] m_lppszMayContains;
		m_lppszMayContains = NULL;
		m_dwMayContainsCount = 0;
	}

	// Set the new list of values
	m_dwMayContainsCount = dwNumValues;
	m_lppszMayContains = new LPWSTR[m_dwMayContainsCount];
	for(i=0; i<m_dwMayContainsCount; i++)
	{
		try
		{
			m_lppszMayContains[i] = new WCHAR[wcslen(pValues->CaseIgnoreString) + 1];
			wcscpy(m_lppszMayContains[i], pValues->CaseIgnoreString);
		}
		catch ( ... )
		{
			if ( m_lppszMayContains )
			{
				m_dwMayContainsCount = 0;

				for ( DWORD dw = 0; dw < i; dw++ )
				{
					if ( m_lppszMayContains [ dw ] )
					{
						delete [] m_lppszMayContains [ dw ];
						m_lppszMayContains [ dw ] = NULL;
					}
				}

				delete [] m_lppszMayContains;
				m_lppszMayContains = NULL;
			}

			throw;
		}

		pValues ++;
	}
}

//***************************************************************************
//
// CADSIClass :: GetSystemMayContains
// 
// Purpose : See Header
//***************************************************************************
LPCWSTR *CADSIClass :: GetSystemMayContains(DWORD *pdwCount)
{
	*pdwCount = m_dwSystemMayContainsCount;
	return (LPCWSTR *)m_lppszSystemMayContains;
}

//***************************************************************************
//
// CADSIClass :: SetSystemMayContains
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetSystemMayContains(PADSVALUE pValues, DWORD dwNumValues)
{
	DWORD i = 0;

	// Delete the list of possible superiors
	if ( m_lppszSystemMayContains )
	{
		for ( i = 0; i<m_dwSystemMayContainsCount; i++ )
		{
			if ( m_lppszSystemMayContains [ i ] )
			{
				delete [] m_lppszSystemMayContains [ i ];
				m_lppszSystemMayContains [ i ] = NULL;
			}
		}

		delete [] m_lppszSystemMayContains;
		m_lppszSystemMayContains = NULL;
		m_dwSystemMayContainsCount = 0;
	}

	// Set the new list of values
	m_dwSystemMayContainsCount = dwNumValues;
	m_lppszSystemMayContains = new LPWSTR[m_dwSystemMayContainsCount];
	for(i=0; i<m_dwSystemMayContainsCount; i++)
	{
		try
		{
			m_lppszSystemMayContains[i] = new WCHAR[wcslen(pValues->CaseIgnoreString) + 1];
			wcscpy(m_lppszSystemMayContains[i], pValues->CaseIgnoreString);
		}
		catch ( ... )
		{
			if ( m_lppszSystemMayContains )
			{
				m_dwSystemMayContainsCount = 0;

				for ( DWORD dw = 0; dw < i; dw++ )
				{
					if ( m_lppszSystemMayContains [ dw ] )
					{
						delete [] m_lppszSystemMayContains [ dw ];
						m_lppszSystemMayContains [ dw ] = NULL;
					}
				}

				delete [] m_lppszSystemMayContains;
				m_lppszSystemMayContains = NULL;
			}

			throw;
		}

		pValues ++;
	}
}

//***************************************************************************
//
// CADSIClass :: GetMustContains
// 
// Purpose : See Header
//***************************************************************************
LPCWSTR *CADSIClass :: GetMustContains(DWORD *pdwCount)
{
	*pdwCount = m_dwMustContainsCount;
	return (LPCWSTR *)m_lppszMustContains;
}

//***************************************************************************
//
// CADSIClass :: SetMustContains
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetMustContains(PADSVALUE pValues, DWORD dwNumValues)
{
	DWORD i = 0;

	// Delete the list of possible superiors
	if ( m_lppszMustContains )
	{
		for ( i = 0; i<m_dwMustContainsCount; i++ )
		{
			if ( m_lppszMustContains [ i ] )
			{
				delete [] m_lppszMustContains [ i ];
				m_lppszMustContains [ i ] = NULL;
			}
		}

		delete [] m_lppszMustContains;
		m_lppszMustContains = NULL;
		m_dwMustContainsCount = 0;
	}

	// Set the new list of values
	m_dwMustContainsCount = dwNumValues;
	m_lppszMustContains = new LPWSTR[m_dwMustContainsCount];
	for(i=0; i<m_dwMustContainsCount; i++)
	{
		try
		{
			m_lppszMustContains[i] = new WCHAR[wcslen(pValues->CaseIgnoreString) + 1];
			wcscpy(m_lppszMustContains[i], pValues->CaseIgnoreString);
		}
		catch ( ... )
		{
			if ( m_lppszMustContains )
			{
				m_dwMustContainsCount = 0;

				for ( DWORD dw = 0; dw < i; dw++ )
				{
					if ( m_lppszMustContains [ dw ] )
					{
						delete [] m_lppszMustContains [ dw ];
						m_lppszMustContains [ dw ] = NULL;
					}
				}

				delete [] m_lppszMustContains;
				m_lppszMustContains = NULL;
			}

			throw;
		}

		pValues ++;
	}
}

//***************************************************************************
//
// CADSIClass :: GetSystemMustContains
// 
// Purpose : See Header
//***************************************************************************
LPCWSTR *CADSIClass :: GetSystemMustContains(DWORD *pdwCount)
{
	*pdwCount = m_dwSystemMustContainsCount;
	return (LPCWSTR *)m_lppszSystemMustContains;
}

//***************************************************************************
//
// CADSIClass :: SetSystemMustContains
// 
// Purpose : See Header
//***************************************************************************
void CADSIClass :: SetSystemMustContains(PADSVALUE pValues, DWORD dwNumValues)
{
	DWORD i = 0;

	// Delete the list of possible superiors
	if ( m_lppszSystemMustContains )
	{
		for ( i = 0; i<m_dwSystemMustContainsCount; i++ )
		{
			if ( m_lppszSystemMustContains [ i ] )
			{
				delete [] m_lppszSystemMustContains [ i ];
				m_lppszSystemMustContains [ i ] = NULL;
			}
		}

		delete [] m_lppszSystemMustContains;
		m_lppszSystemMustContains = NULL;
		m_dwSystemMustContainsCount = 0;
	}

	// Set the new list of values
	m_dwSystemMustContainsCount = dwNumValues;
	m_lppszSystemMustContains = new LPWSTR[m_dwSystemMustContainsCount];
	for(i=0; i<m_dwSystemMustContainsCount; i++)
	{
		try
		{
			m_lppszSystemMustContains[i] = new WCHAR[wcslen(pValues->CaseIgnoreString) + 1];
			wcscpy(m_lppszSystemMustContains[i], pValues->CaseIgnoreString);
		}
		catch ( ... )
		{
			if ( m_lppszSystemMustContains )
			{
				m_dwSystemMustContainsCount = 0;

				for ( DWORD dw = 0; dw < i; dw++ )
				{
					if ( m_lppszSystemMustContains [ dw ] )
					{
						delete [] m_lppszSystemMustContains [ dw ];
						m_lppszSystemMustContains [ dw ] = NULL;
					}
				}

				delete [] m_lppszSystemMustContains;
				m_lppszSystemMustContains = NULL;
			}

			throw;
		}

		pValues ++;
	}
}