private void WritePropertyInvocation(IArmString keyword, ArmElement value)
{
if (value is ArmArray arrayBody)
{
bool needSeparator = false;
foreach (ArmElement element in arrayBody)
{
if (needSeparator)
{
WriteLine();
}
// TODO: Work out how nested arrays work...
WritePropertyInvocation(keyword, element);
needSeparator = true;
}
return;
}
WriteKeyword(keyword);
Write(" ");
value.RunVisit(this);
}
public static ArmResourceName CreateFromArmStrings(IArmString resourceNamespace, IArmString type, IArmString apiVersion)
{
return(new ArmResourceName(
(resourceNamespace as ArmStringLiteral)?.Value,
(type as ArmStringLiteral)?.Value,
(apiVersion as ArmStringLiteral)?.Value));
}
protected void WriteArmValueEntry(
IArmString key,
ArmElement value,
bool isArrayElement = false)
{
WriteObject(new ArmEntry(key, value, isArrayElement));
}
protected void WriteArmArrayEntry <TArmElement>(
IArmString key,
ScriptBlock body,
bool isArrayElement = false)
where TArmElement : ArmElement
{
WriteObject(new ArmEntry(key, AggregateArmArray <TArmElement>(body), isArrayElement));
}
private IArmString ParseFullExpression(ref ArmExpressionTokenizer tokenizer)
{
Expect(ref tokenizer, ArmExpressionTokenType.OpenBracket);
IArmString wholeExpression = ParseInnerExpression(ref tokenizer, noLiteral: true);
Expect(ref tokenizer, ArmExpressionTokenType.CloseBracket);
Expect(ref tokenizer, ArmExpressionTokenType.EOF);
return(wholeExpression);
}
protected void WriteArmObjectEntry <TArmObject>(
ArmBuilder <TArmObject> objectBuilder,
IArmString key,
ScriptBlock body,
bool isArrayElement = false)
where TArmObject : ArmObject
{
WriteObject(
new ArmEntry(
key,
AggregateArmObject(objectBuilder, body),
isArrayElement));
}
public ArmBuilder <TObject> AddSingleElement(IArmString key, ArmElement value)
{
if (!_armObject.TryGetValue(key, out ArmElement existingValue))
{
_armObject[key] = value;
}
else if (existingValue is ArmObject existingObject &&
value is ArmObject newObject)
{
foreach (KeyValuePair <IArmString, ArmElement> newEntry in newObject)
{
existingObject.Add(newEntry);
}
}
public ArmTemplateResource(IArmString name)
{
Name = name;
Type = s_type;
ApiVersion = s_apiVersion;
this[ArmTemplateKeys.Properties] = new ArmObject
{
[ArmTemplateKeys.Mode] = s_incrementalMode,
[ArmTemplateKeys.ExpressionEvaluationOptions] = new ArmObject
{
[ArmTemplateKeys.Scope] = s_inner,
},
};
}
public static bool TryConvertToArmString(object value, out IArmString armString)
{
switch (value)
{
case string str:
armString = new ArmStringLiteral(str);
return(true);
case IArmString armStr:
armString = armStr;
return(true);
}
armString = null;
return(false);
}
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;
}
}
private void WriteKeyword(IArmString keyword)
{
Write(keyword.CoerceToString());
}
public ArmVariable(IArmString name, ArmElement value)
{
Name = name;
Value = value;
}
public ArmOutput(IArmString name)
{
Name = name;
}
TValue IDictionary <IArmString, TValue> .this[IArmString key]
{
get => (TValue)This[key];
public ArmEntry(IArmString key, ArmElement value, bool isArrayElement)
{
Key = key;
Value = value;
IsArrayElement = isArrayElement;
}
internal ArmVariableReferenceExpression(IArmString variableName)
: base(s_variableReferenceFunction, variableName)
{
}
public ArmParameter(IArmString name, IArmString type)
{
Name = name;
Type = type;
}
public static ArmStringLiteral CoerceToLiteral(this IArmString armString)
{
return((ArmStringLiteral)armString);
}
public static string CoerceToString(this IArmString armString)
{
return(armString.CoerceToLiteral().Value);
}
internal ArmParameterReferenceExpression(IArmString parameterName)
: base(s_parameterReferenceFunction, parameterName)
{
}
public ArmFunctionCallExpression(IArmString function, IReadOnlyList <ArmExpression> arguments)
: this()
{
Function = function;
Arguments.AddRange(arguments);
}
public ArmEntry(IArmString key, ArmElement value) : this(key, value, isArrayElement : false)
{
}
protected ArmReferenceExpression(ArmStringLiteral referenceFunction, IArmString referencedName)
: base(referenceFunction, new[] { (ArmExpression)referencedName })
{
ReferenceName = referencedName;
}
private void WriteExpression(IArmString value) => WriteExpression((ArmElement)value);
public ArmMemberAccessExpression(ArmOperation expression, IArmString member)
{
InnerExpression = expression;
Member = member;
}
private JToken VisitArmString(IArmString str)
{
return(new JValue(str.ToExpressionString()));
}
