public static ArmNestedTemplate CreateFromTemplates(IEnumerable <ArmTemplate> templates)
{
var resourceArray = new ArmArray <ArmResource>();
var templateNames = new Dictionary <string, int>();
foreach (ArmTemplate template in templates)
{
string templateName = template.TemplateName;
if (templateNames.TryGetValue(templateName, out int count))
{
count++;
templateName = $"{templateName}_{count}";
templateNames[templateName] = count;
}
else
{
templateNames[templateName] = 0;
}
resourceArray.Add(new ArmTemplateResource(new ArmStringLiteral(templateName))
{
Template = template,
});
}
return(new ArmNestedTemplate
{
Resources = resourceArray,
});
}
protected override void EndProcessing()
{
if (Body != null)
{
WriteArmArrayElement(Body);
return;
}
var armArray = new ArmArray();
for (int i = 0; i < Values.Length; i++)
{
object currVal = Values[i];
if (!ArmElementConversion.TryConvertToArmElement(currVal, out ArmElement element))
{
this.ThrowTerminatingError(
new InvalidCastException($"Unable to convert value '{currVal}' of type '{currVal.GetType()}' to type '{typeof(ArmElement)}'"),
"InvalidArmTypeCase",
ErrorCategory.InvalidArgument,
currVal);
return;
}
armArray.Add(element);
}
WriteObject(armArray);
}
private bool TryGetAllowedValues(ParameterAst parameter, out ArmArray allowedValues)
{
if (parameter.Attributes is null)
{
allowedValues = null;
return(false);
}
foreach (AttributeBaseAst attributeBase in parameter.Attributes)
{
if (attributeBase is not AttributeAst attribute ||
attribute.TypeName.GetReflectionType() != typeof(ValidateSetAttribute) ||
attribute.PositionalArguments is null ||
attribute.PositionalArguments.Count == 0)
{
continue;
}
allowedValues = new ArmArray();
foreach (ExpressionAst allowedExpression in attribute.PositionalArguments)
{
if (!ArmElementConversion.TryConvertToArmElement(allowedExpression.SafeGetValue(), out ArmElement allowedArmElement))
{
throw new ArgumentException($"ValidateSet value '{allowedExpression}' on parameter '{parameter.Name}' is not a value ARM value");
}
allowedValues.Add(allowedArmElement);
}
return(true);
}
allowedValues = null;
return(false);
}
public JToken VisitArray(ArmArray array)
{
var arr = new JArray();
foreach (ArmElement element in array)
{
arr.Add(element.RunVisit(this));
}
return(arr);
}
private ArmArray ReadArmArray(JArray jArray)
{
var armArray = new ArmArray();
foreach (JToken item in jArray)
{
armArray.Add(ReadValue(item));
}
return(armArray);
}
VisitAction IArmVisitor <VisitAction> .VisitArray(ArmArray array)
{
if (ShouldStop(VisitArray(array), out VisitAction parentAction))
{
return(parentAction);
}
if (VisitCollectionAndCheckStop(array, out parentAction))
{
return(parentAction);
}
return(VisitAction.Continue);
}
protected ArmArray <TArmElement> AggregateArmArray <TArmElement>(
ScriptBlock body)
where TArmElement : ArmElement
{
var array = new ArmArray <TArmElement>();
foreach (PSObject output in InvokeBody(body))
{
if (output.BaseObject is TArmElement element)
{
array.Add(element);
}
}
return(array);
}
private static bool TryConvertEnumerableToArmArray(IEnumerable enumerable, out ArmElement armArray)
{
var array = new ArmArray();
foreach (object element in enumerable)
{
if (!TryConvertToArmElement(element, out ArmElement armElement))
{
armArray = null;
return(false);
}
array.Add(armElement);
}
armArray = array;
return(true);
}
private void WriteArray(IArmString key, ArmArray values)
{
bool needsSeparator = false;
foreach (ArmElement element in values)
{
if (needsSeparator)
{
WriteLine();
}
WriteKeyword(key);
Write(" ");
element.RunVisit(this);
needsSeparator = true;
}
}
public object VisitArray(ArmArray array)
{
Write("@(");
bool needSeparator = false;
foreach (ArmElement element in array)
{
if (needSeparator)
{
Write(",");
}
element.RunVisit(this);
needSeparator = true;
}
Write(")");
return(null);
}
protected override void EndProcessing()
{
var array = new ArmArray();
if (Value != null)
{
foreach (IArmString value in Value)
{
array.Add((ArmElement)value);
}
WriteArmValueEntry(ArmTemplateKeys.DependsOn, array);
return;
}
foreach (PSObject output in InvokeBody(Body))
{
if (LanguagePrimitives.TryConvertTo(output, typeof(IArmString), out object result))
{
array.Add((ArmElement)result);
}
}
WriteArmValueEntry(ArmTemplateKeys.DependsOn, array);
}
public ArmNestedTemplateBuilder()
{
_templateResources = new ArmArray <ArmResource>();
_templateNameCounts = new Dictionary <string, int>();
}
public virtual VisitAction VisitArray(ArmArray array) => DefaultVisit(array);
public object VisitArray(ArmArray array)
{
throw new InvalidOperationException($"Cannot directly visit arrays");
}