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())); }