/// <summary>
/// constructor
/// </summary>
/// <param name="toClone"></param>
internal ParameterSetEntry(ParameterSetEntry toClone)
{
this.mandatoryParameterCount = toClone.MandatoryParameterCount;
this.isDefaultParameterSet = toClone.IsDefaultParameterSet;
reset();
}
/// <summary>
/// Get the parameter set name based on current binding results
/// </summary>
/// <returns></returns>
internal string GetParameterSet()
{
DebugHelper.WriteLogEx();
string boundParameterSetName = null;
string defaultParameterSetName = null;
List <string> noMandatoryParameterSet = new List <string>();
// Looking for parameter set which have mandatory parameters
foreach (string parameterSetName in this.parameterSetEntries.Keys)
{
ParameterSetEntry entry = this.parameterSetEntries[parameterSetName];
DebugHelper.WriteLogEx(
"parameterset name = {0}, {1}/{2} mandatory parameters.",
1,
parameterSetName,
entry.SetMandatoryParameterCount,
entry.MandatoryParameterCount);
// Ignore the parameter set which has no mandatory parameter firstly
if (entry.MandatoryParameterCount == 0)
{
if (entry.IsDefaultParameterSet)
{
defaultParameterSetName = parameterSetName;
}
if (entry.IsValueSet)
{
noMandatoryParameterSet.Add(parameterSetName);
}
continue;
}
if ((entry.SetMandatoryParameterCount == entry.MandatoryParameterCount) &&
this.parametersetNamesList.Contains(parameterSetName))
{
if (boundParameterSetName != null)
{
throw new PSArgumentException(Strings.UnableToResolveParameterSetName);
}
boundParameterSetName = parameterSetName;
}
}
// Looking for parameter set which has no mandatory parameters
if (boundParameterSetName == null)
{
// throw if there are > 1 parameter set
if (noMandatoryParameterSet.Count > 1)
{
throw new PSArgumentException(Strings.UnableToResolveParameterSetName);
}
else if (noMandatoryParameterSet.Count == 1)
{
boundParameterSetName = noMandatoryParameterSet[0];
}
}
// Looking for default parameter set
if (boundParameterSetName == null)
{
boundParameterSetName = defaultParameterSetName;
}
// throw if still can not find the parameter set name
if (boundParameterSetName == null)
{
throw new PSArgumentException(Strings.UnableToResolveParameterSetName);
}
return(boundParameterSetName);
}
/// <summary>
/// <para>
/// A given parameter's value was set by cmdlet caller,
/// check and change the status of parameter set,
/// throw exception if confliction occurred
/// </para>
/// </summary>
/// <param name="parameterName"></param>
/// <exception cref="PSArgumentException">throw if conflict parameter was set</exception>
internal void SetParameter(string parameterName, bool isBeginProcess)
{
DebugHelper.WriteLogEx("ParameterName = {0}, isBeginProcess = {1}", 0, parameterName, isBeginProcess);
if (this.parameterNamesList.Contains(parameterName))
{
DebugHelper.WriteLogEx("ParameterName {0} is already bound ", 1, parameterName);
return;
}
else
{
this.parameterNamesList.Add(parameterName);
if (isBeginProcess)
{
this.parameterNamesListAtBeginProcess.Add(parameterName);
}
}
if (this.parametersetNamesList.Count == 0)
{
List <string> nameset = new List <string>();
foreach (ParameterDefinitionEntry parameterDefinitionEntry in this.parameterDefinitionEntries[parameterName])
{
DebugHelper.WriteLogEx("parameterset name = '{0}'; mandatory = '{1}'", 1, parameterDefinitionEntry.ParameterSetName, parameterDefinitionEntry.IsMandatory);
ParameterSetEntry psEntry = this.parameterSetEntries[parameterDefinitionEntry.ParameterSetName];
if (psEntry == null)
{
continue;
}
if (parameterDefinitionEntry.IsMandatory)
{
psEntry.SetMandatoryParameterCount++;
if (isBeginProcess)
{
psEntry.SetMandatoryParameterCountAtBeginProcess++;
}
DebugHelper.WriteLogEx("parameterset name = '{0}'; SetMandatoryParameterCount = '{1}'", 1, parameterDefinitionEntry.ParameterSetName, psEntry.SetMandatoryParameterCount);
}
if (!psEntry.IsValueSet)
{
psEntry.IsValueSet = true;
if (isBeginProcess)
{
psEntry.IsValueSetAtBeginProcess = true;
}
}
nameset.Add(parameterDefinitionEntry.ParameterSetName);
}
this.parametersetNamesList = nameset;
if (isBeginProcess)
{
this.parametersetNamesListAtBeginProcess = nameset;
}
}
else
{
List <string> nameset = new List <string>();
foreach (ParameterDefinitionEntry entry in this.parameterDefinitionEntries[parameterName])
{
if (this.parametersetNamesList.Contains(entry.ParameterSetName))
{
nameset.Add(entry.ParameterSetName);
if (entry.IsMandatory)
{
ParameterSetEntry psEntry = this.parameterSetEntries[entry.ParameterSetName];
psEntry.SetMandatoryParameterCount++;
if (isBeginProcess)
{
psEntry.SetMandatoryParameterCountAtBeginProcess++;
}
DebugHelper.WriteLogEx("parameterset name = '{0}'; SetMandatoryParameterCount = '{1}'",
1,
entry.ParameterSetName,
psEntry.SetMandatoryParameterCount);
}
}
}
if (nameset.Count == 0)
{
throw new PSArgumentException(Strings.UnableToResolveParameterSetName);
}
else
{
this.parametersetNamesList = nameset;
if (isBeginProcess)
{
this.parametersetNamesListAtBeginProcess = nameset;
}
}
}
}
internal ParameterSetEntry(ParameterSetEntry toClone)
{
this.mandatoryParameterCount = toClone.MandatoryParameterCount;
this.isDefaultParameterSet = toClone.IsDefaultParameterSet;
this.reset();
}
internal string GetParameterSet()
{
DebugHelper.WriteLogEx();
string item = null;
string str = null;
List <string> strs = new List <string>();
foreach (string key in this.parameterSetEntries.Keys)
{
ParameterSetEntry parameterSetEntry = this.parameterSetEntries[key];
object[] setMandatoryParameterCount = new object[3];
setMandatoryParameterCount[0] = key;
setMandatoryParameterCount[1] = parameterSetEntry.SetMandatoryParameterCount;
setMandatoryParameterCount[2] = parameterSetEntry.MandatoryParameterCount;
DebugHelper.WriteLogEx("parameterset name = {0}, {1}/{2} mandatory parameters.", 1, setMandatoryParameterCount);
if (parameterSetEntry.MandatoryParameterCount != 0)
{
if (parameterSetEntry.SetMandatoryParameterCount != parameterSetEntry.MandatoryParameterCount || !this.parametersetNamesList.Contains(key))
{
continue;
}
if (item == null)
{
item = key;
}
else
{
throw new PSArgumentException(Strings.UnableToResolvePareameterSetName);
}
}
else
{
if (parameterSetEntry.IsDefaultParameterSet)
{
str = key;
}
if (!parameterSetEntry.IsValueSet)
{
continue;
}
strs.Add(key);
}
}
if (item == null)
{
if (strs.Count <= 1)
{
if (strs.Count == 1)
{
item = strs[0];
}
}
else
{
throw new PSArgumentException(Strings.UnableToResolvePareameterSetName);
}
}
if (item == null)
{
item = str;
}
if (item != null)
{
return(item);
}
else
{
throw new PSArgumentException(Strings.UnableToResolvePareameterSetName);
}
}
internal void SetParameter(string parameterName, bool isBeginProcess)
{
object[] objArray = new object[2];
objArray[0] = parameterName;
objArray[1] = isBeginProcess;
DebugHelper.WriteLogEx("ParameterName = {0}, isBeginProcess = {1}", 0, objArray);
if (!this.parameterNamesList.Contains(parameterName))
{
this.parameterNamesList.Add(parameterName);
if (isBeginProcess)
{
this.parameterNamesListAtBeginProcess.Add(parameterName);
}
if (this.parametersetNamesList.Count != 0)
{
List <string> strs = new List <string>();
foreach (ParameterDefinitionEntry item in this.parameterDefinitionEntries[parameterName])
{
if (!this.parametersetNamesList.Contains(item.ParameterSetName))
{
continue;
}
strs.Add(item.ParameterSetName);
if (!item.IsMandatory)
{
continue;
}
ParameterSetEntry parameterSetEntry = this.parameterSetEntries[item.ParameterSetName];
ParameterSetEntry setMandatoryParameterCount = parameterSetEntry;
setMandatoryParameterCount.SetMandatoryParameterCount = setMandatoryParameterCount.SetMandatoryParameterCount + 1;
if (isBeginProcess)
{
ParameterSetEntry setMandatoryParameterCountAtBeginProcess = parameterSetEntry;
setMandatoryParameterCountAtBeginProcess.SetMandatoryParameterCountAtBeginProcess = setMandatoryParameterCountAtBeginProcess.SetMandatoryParameterCountAtBeginProcess + 1;
}
object[] parameterSetName = new object[2];
parameterSetName[0] = item.ParameterSetName;
parameterSetName[1] = parameterSetEntry.SetMandatoryParameterCount;
DebugHelper.WriteLogEx("parameterset name = '{0}'; SetMandatoryParameterCount = '{1}'", 1, parameterSetName);
}
if (strs.Count != 0)
{
this.parametersetNamesList = strs;
if (isBeginProcess)
{
this.parametersetNamesListAtBeginProcess = strs;
}
}
else
{
throw new PSArgumentException(Strings.UnableToResolvePareameterSetName);
}
}
else
{
List <string> strs1 = new List <string>();
foreach (ParameterDefinitionEntry parameterDefinitionEntry in this.parameterDefinitionEntries[parameterName])
{
object[] isMandatory = new object[2];
isMandatory[0] = parameterDefinitionEntry.ParameterSetName;
isMandatory[1] = parameterDefinitionEntry.IsMandatory;
DebugHelper.WriteLogEx("parameterset name = '{0}'; mandatory = '{1}'", 1, isMandatory);
ParameterSetEntry item1 = this.parameterSetEntries[parameterDefinitionEntry.ParameterSetName];
if (item1 == null)
{
continue;
}
if (parameterDefinitionEntry.IsMandatory)
{
ParameterSetEntry setMandatoryParameterCount1 = item1;
setMandatoryParameterCount1.SetMandatoryParameterCount = setMandatoryParameterCount1.SetMandatoryParameterCount + 1;
if (isBeginProcess)
{
ParameterSetEntry setMandatoryParameterCountAtBeginProcess1 = item1;
setMandatoryParameterCountAtBeginProcess1.SetMandatoryParameterCountAtBeginProcess = setMandatoryParameterCountAtBeginProcess1.SetMandatoryParameterCountAtBeginProcess + 1;
}
object[] parameterSetName1 = new object[2];
parameterSetName1[0] = parameterDefinitionEntry.ParameterSetName;
parameterSetName1[1] = item1.SetMandatoryParameterCount;
DebugHelper.WriteLogEx("parameterset name = '{0}'; SetMandatoryParameterCount = '{1}'", 1, parameterSetName1);
}
if (!item1.IsValueSet)
{
item1.IsValueSet = true;
if (isBeginProcess)
{
item1.IsValueSetAtBeginProcess = true;
}
}
strs1.Add(parameterDefinitionEntry.ParameterSetName);
}
this.parametersetNamesList = strs1;
if (isBeginProcess)
{
this.parametersetNamesListAtBeginProcess = strs1;
return;
}
}
return;
}
else
{
object[] objArray1 = new object[1];
objArray1[0] = parameterName;
DebugHelper.WriteLogEx("ParameterName {0} is already bound ", 1, objArray1);
return;
}
}
