public void Visit(IConstruct construct)
{
if (construct.GetType().Name.CompareTo("CfnFunction") == 0)
{
((CfnResource)construct).AddPropertyOverride("Runtime", "nodejs12.x");
}
}
public static JTokenType ConvertInterpreterArrayTypeIntoJTokenType(IConstruct l)
{
string expectedValueType = l.GetType().Name;
if (expectedValueType == "Variable")
{
Variable v = l as Variable;
return(ConvertInterpreterArrayTypeIntoJTokenType(v.Value));
}
else if (expectedValueType == "Array")
{
var a = (l as HiSystems.Interpreter.Array).ToList();
if (a.Count > 0)
{
return(ConvertInterpreterTypeIntoJTokenType(a[0]));
}
else
{
throw new System.ArgumentException($"ConvertInterpreterArrayTypeIntoJTokenType() cannot infer the type of the array because the array is empty, l:{l.ToString()} ");
}
}
else
{
throw new System.ArgumentException($"ConvertInterpreterArrayTypeIntoJTokenType() requires an array as first parameter, received:${l.ToString()}");
}
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
var argument1Transformed = base.GetTransformedConstruct <Literal>(argument1);
var argument2Transformed = base.GetTransformedConstruct <Literal>(argument2);
if (argument1Transformed is Number && argument2Transformed is Number)
{
return(((Number)argument1Transformed) == ((Number)argument2Transformed));
}
else if (argument1Transformed is Boolean && argument2Transformed is Boolean)
{
return(((Boolean)argument1Transformed) == ((Boolean)argument2Transformed));
}
else if (argument1Transformed is DateTime && argument2Transformed is DateTime)
{
return(((DateTime)argument1Transformed) == ((DateTime)argument2Transformed));
}
else if (argument1Transformed is Text && argument2Transformed is Text)
{
return(((Text)argument1Transformed) == ((Text)argument2Transformed));
}
else if (argument1Transformed is Text && argument2Transformed is Number)
{
return(((Text)argument1Transformed) == ((Number)argument2Transformed).ToString());
}
else if (argument1Transformed is Number && argument2Transformed is Text)
{
return(((Number)argument1Transformed).ToString() == ((Text)argument2Transformed));
}
else
{
return(new Error(String.Format("Equality operator requires arguments of type Number, DateTime or Boolean. Argument types are {0} {1}.", argument1Transformed.GetType().Name, argument2Transformed.GetType().Name)));
}
}
public override Literal Execute(IConstruct[] arguments)
{
base.EnsureArgumentCountIsBetween(arguments, 1, 2);
var value = base.GetTransformedArgument<Literal>(arguments, argumentIndex: 0);
string format;
if (arguments.Length > 1)
format = base.GetTransformedArgument<Text>(arguments, argumentIndex: 1);
else
format = null;
if (value is Number)
{
if (format == null)
return (Text)((Number)value).ToString();
else
return (Text)((Number)value).ToString(format);
}
else if (value is HiSystems.Interpreter.DateTime)
{
if (format == null)
return (Text)((HiSystems.Interpreter.DateTime)value).ToString();
else
return (Text)((HiSystems.Interpreter.DateTime)value).ToString(format);
}
else
throw new NotImplementedException(value.GetType().Name);
}
/// <summary>
/// </summary>
public Variable(string name, IConstruct value)
{
if (String.IsNullOrEmpty(name))
throw new ArgumentNullException("Name");
this.name = name;
this.construct = value;
}
public FunctionOperation(Function function, IConstruct[] arguments)
{
if (function == null)
throw new ArgumentNullException();
this.function = function;
this.arguments = arguments;
}
public override Literal Execute(IConstruct[] arguments)
{
base.EnsureArgumentCountIs(arguments, 1);
decimal inputValue = base.GetTransformedArgument<Number>(arguments, argumentIndex: 0);
return new Number(-inputValue);
}
//static protected internal bool IsNull(IConstructable am)
//{
// if (am == null) return true;
// return false;
//}
public override bool IsNull(IConstruct am)
{
if (am == null)
{
return(true);
}
return(false);
}
private static void ApplyDefaultTags(IConstruct construct, string environment, string project)
{
Tags.Of(construct).Add("Stack-Author", "Eric Wilson");
Tags.Of(construct).Add("Stack-Version", "0.0.1-beta");
Tags.Of(construct).Add("Stack-Tool", "GeekCafe-AWS-CDK");
Tags.Of(construct).Add("Stack-Environment", environment);
Tags.Of(construct).Add("Stack-Project", project);
}
public static void Tag(IConstruct construct, IConfigSettings config, List <Configuration.Tag> tags)
{
foreach (var tag in tags)
{
var value = (config != null) ? config.Parse(tag.Value) : tag.Value;
Amazon.CDK.Tags.Of(construct).Add($"{tag.Name}", $"{value}");
}
}
public ConstructToken(IConstruct value)
{
if (value == null)
{
throw new ArgumentNullException();
}
this.value = value;
}
/// <summary>
/// Throws an exception if the argument passed is not the expected type.
/// </summary>
private T CastConstructToType <T>(IConstruct construct)
{
if (!(construct is T))
{
throw new InvalidOperationException(String.Format("{0} construct is not of type {1} and cannot be used with the {2} operator", construct.ToString(), typeof(T).Name, this.Token));
}
return((T)construct);
}
private T CastConstructToType <T>(IConstruct construct)
{
if (!(construct is T))
{
return(default(T));
}
return((T)construct);
}
/// <summary>
/// Parses the expression if it has not yet been parsed.
/// </summary>
private void EnsureExpressionParsed()
{
if (this.construct == null)
{
var variablesList = new List <Variable>();
this.construct = this.parseToConstruct(base.Source, variablesList);
this.variables = TranslateVariablesToDictionary(variablesList);
}
}
/// <summary>
/// Throws an exception if the argument passed, via the argument index is not the expected type.
/// ArgumentIndex is only used for the error message and should match the index of the argument that is passed.
/// </summary>
private T CastArgumentToType <T>(IConstruct argument, int argumentIndex)
{
if (!(argument is T))
{
throw new InvalidOperationException(String.Format("Argument {1}: {0} is not of type {2} and cannot be used with the {3} function", argument.ToString(), argumentIndex + 1, typeof(T).Name, this.Name));
}
return((T)argument);
}
internal ExpressionParsed(string expression, IConstruct value, List<Variable> variables)
: base(expression)
{
if (value == null)
throw new ArgumentNullException();
this.construct = value;
this.variables = TranslateVariablesToDictionary(variables);
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
var argument2Value = base.GetTransformedConstruct<Number>(argument2);
if (argument2Value == 0)
throw new DivideByZeroException(argument2.ToString());
return base.GetTransformedConstruct<Number>(argument1) / argument2Value;
}
/// <summary>
/// </summary>
public Variable(string name, IConstruct value)
{
if (String.IsNullOrEmpty(name))
{
throw new ArgumentNullException("Name");
}
this.name = name;
this.construct = value;
}
internal ExpressionParsed(string expression, IConstruct value, List <Variable> variables)
: base(expression)
{
if (value == null)
{
throw new ArgumentNullException();
}
this.construct = value;
this.variables = TranslateVariablesToDictionary(variables);
}
public override Literal Execute(IConstruct[] arguments)
{
base.EnsureArgumentCountIs(arguments, 3);
var condition = base.GetTransformedArgument<Boolean>(arguments, argumentIndex: 0);
if (condition)
return base.GetTransformedArgument<Literal>(arguments, argumentIndex: 1);
else
return base.GetTransformedArgument<Literal>(arguments, argumentIndex: 2);
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
var argument2Value = base.GetTransformedConstruct <Number>(argument2);
if (argument2Value == 0)
{
throw new DivideByZeroException(argument2.ToString());
}
return(base.GetTransformedConstruct <Number>(argument1) / argument2Value);
}
/// <summary>
/// Indicates the left hand side value, and right hand side values
/// and the operation to be applied to the left hand side and right
/// hand side values.
/// </summary>
public Operation(IConstruct leftValue, Operator operation, IConstruct rightValue)
{
if (leftValue == null || rightValue == null || operation == null)
{
throw new ArgumentNullException();
}
this.leftValue = leftValue;
this.@operator = operation;
this.rightValue = rightValue;
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
var argument2Value = base.GetTransformedConstruct <Number>(argument2);
if (argument2Value == 0)
{
return(new Error("Divide by zero"));
}
return(base.GetTransformedConstruct <Number>(argument1) / argument2Value);
}
public void AddTag(IConstruct scope, string name, string value)
{
var tags = new List <Configuration.Tag>
{
new Configuration.Tag()
{
Name = name, Value = value
}
};
Utilities.Tagging.Tag(scope, _config, tags);
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
var argument1Transformed = base.GetTransformedConstruct<Literal>(argument1);
var argument2Transformed = base.GetTransformedConstruct<Literal>(argument2);
if (argument1Transformed is Number && argument2Transformed is Number)
return ((Number)argument1Transformed) <= ((Number)argument2Transformed);
else if (argument1Transformed is DateTime && argument2Transformed is DateTime)
return ((DateTime)argument1Transformed) <= ((DateTime)argument2Transformed);
else
throw new InvalidOperationException(String.Format("Less than or equal to operator requires arguments of type Number or DateTime. Argument types are {0} {1}.", argument1Transformed.GetType().Name, argument2Transformed.GetType().Name));
}
public VirtualWindowShare(String id, String windowName, String applicationName, IConstruct _iIConstruct)
{
_mIConstruct = _iIConstruct;
IntPtr nId = MarshalPtrToUtf8.GetInstance().MarshalManagedToNative(id ?? string.Empty);
IntPtr nWindowName = MarshalPtrToUtf8.GetInstance().MarshalManagedToNative(windowName ?? string.Empty);
IntPtr nApplicationName = MarshalPtrToUtf8.GetInstance().MarshalManagedToNative(applicationName ?? string.Empty);
objPtr = VidyoVirtualWindowShareConstructNative(nId, nWindowName, nApplicationName, _mStartCallback, _mReconfigureCallback, _mStopCallback);
Marshal.FreeHGlobal(nApplicationName);
Marshal.FreeHGlobal(nWindowName);
Marshal.FreeHGlobal(nId);
VidyoVirtualWindowShareSetUserDataNative(objPtr, GCHandle.ToIntPtr(GCHandle.Alloc(this, GCHandleType.Weak)));
}
public static JTokenType ConvertInterpreterTypeIntoJTokenType(IConstruct l)
{
string expectedValueType = l.GetType().Name;
if (expectedValueType == "Variable")
{
Variable v = l as Variable;
return(ConvertInterpreterTypeIntoJTokenType(v.Value));
}
if (expectedValueType == "Operation")
{
var r = l.Transform();
return(ConvertInterpreterTypeIntoJTokenType(r));
}
if (expectedValueType == "FunctionOperation")
{
return(ConvertInterpreterTypeIntoJTokenType(l.Transform()));
}
if (expectedValueType == "Array")
{
return(JTokenType.Array);
}
if (expectedValueType == "Number")
{
return(JTokenType.Float);
}
if (expectedValueType == "Text")
{
return(JTokenType.String);
}
if (expectedValueType == "DateTime")
{
return(JTokenType.Date);
}
if (expectedValueType == "Boolean")
{
return(JTokenType.Boolean);
}
if (expectedValueType == "Null")
{
return(JTokenType.Null);
}
if (expectedValueType == "Array")
{
return(JTokenType.Array);
}
return(JTokenType.Undefined);
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
var argument2Transformed = base.GetTransformedConstruct <Literal>(argument2);
var existingVariable = Program.Variables.SingleOrDefault(x => x.Name == argument1.ToString().Split(':')[0]);
if (existingVariable == null)
{
Program.Variables.Add(new Variable(argument1.ToString().Split(':')[0], argument2Transformed));
}
else
{
existingVariable.Construct = argument2Transformed;
}
return(base.Empty());
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
var argument1Transformed = base.GetTransformedConstruct <Literal>(argument1);
var argument2Transformed = base.GetTransformedConstruct <Literal>(argument2);
if (argument1Transformed is Number && argument2Transformed is Number)
{
return(((Number)argument1Transformed) >= ((Number)argument2Transformed));
}
else if (argument1Transformed is DateTime && argument2Transformed is DateTime)
{
return(((DateTime)argument1Transformed) >= ((DateTime)argument2Transformed));
}
else
{
return(new Error(String.Format("Greater than or equal to operator requires arguments of type Number or DateTime. Argument types are {0} {1}.", argument1Transformed.GetType().Name, argument2Transformed.GetType().Name)));
}
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
var argument1Transformed = base.GetTransformedConstruct <Literal>(argument1);
var argument2Transformed = base.GetTransformedConstruct <Literal>(argument2);
if (argument1Transformed is Number && argument2Transformed is Number)
{
return(((Number)argument1Transformed) < ((Number)argument2Transformed));
}
else if (argument1Transformed is DateTime && argument2Transformed is DateTime)
{
return(((DateTime)argument1Transformed) < ((DateTime)argument2Transformed));
}
else
{
throw new InvalidOperationException(String.Format("Less than operator requires arguments of type Number or DateTime. Argument types are {0} {1}.", argument1Transformed.GetType().Name, argument2Transformed.GetType().Name));
}
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
var argument1Transformed = base.GetTransformedConstruct <Literal>(argument1);
var argument2Transformed = base.GetTransformedConstruct <Literal>(argument2);
/* fred null support */
if (argument1Transformed is Null && argument2Transformed is Null)
{
return(new Boolean(true));
}
if (argument1Transformed is Null && (!(argument2Transformed is Null)))
{
return(new Boolean(false));
}
if ((!(argument1Transformed is Null)) && argument2Transformed is Null)
{
return(new Boolean(false));
}
if (argument1Transformed is Number && argument2Transformed is Number)
{
return(((Number)argument1Transformed) == ((Number)argument2Transformed));
}
else if (argument1Transformed is Boolean && argument2Transformed is Boolean)
{
return(((Boolean)argument1Transformed) == ((Boolean)argument2Transformed));
}
else if (argument1Transformed is DateTime && argument2Transformed is DateTime)
{
return(((DateTime)argument1Transformed) == ((DateTime)argument2Transformed));
}
else if (argument1Transformed is Text && argument2Transformed is Text)
{
return(((Text)argument1Transformed) == ((Text)argument2Transformed));
}
else
{
throw new InvalidOperationException(String.Format("Equality operator requires arguments of type Number, DateTime or Boolean. Argument types are {0} {1}.", argument1Transformed.GetType().Name, argument2Transformed.GetType().Name));
}
}
public override Literal Execute(IConstruct[] arguments)
{
base.EnsureArgumentCountIs(arguments, 0);
return new DateTime(System.DateTime.Today);
}
public void Add(IConstruct construct)
{
_constructs.Add(construct);
}
public override Literal Execute(IConstruct[] arguments)
{
base.EnsureArgumentCountIs(arguments, 2);
var fieldIndex = (decimal)base.GetTransformedArgument<Number>(arguments, 0);
var dataSet = base.GetTransformedArgument<DataSet>(arguments, 1);
return new Array(dataSet.Select((int)fieldIndex));
}
public ConstructToken(IConstruct value)
{
if (value == null)
throw new ArgumentNullException();
this.value = value;
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
return(!(Boolean)equalToOperator.Execute(argument1, argument2));
}
public override Literal Execute(IConstruct[] arguments)
{
base.EnsureArgumentCountIs(arguments, 1);
return new Number(base.GetTransformedArgument<Text>(arguments, argumentIndex:0).Length);
}
public override Literal Execute(IConstruct[] arguments)
{
base.EnsureArgumentCountIs(arguments, 1);
return new Number(base.GetTransformedArgumentDecimalArray(arguments, argumentIndex:0).Average());
}
/// <summary>
/// Add custom Tags to the CFN resource
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="result"></param>
public void AddCustomTag(string key, string value, IConstruct result)
{
Tags.Of(result).Add(key, value);
}
public void LogTag(string name, IConstruct result)
{
Tags.Of(result).Add("Name", name.ToLowerInvariant());
Console.WriteLine($"Entity name: {name}");
}
public override Literal Execute(IConstruct[] arguments)
{
base.EnsureArgumentCountIsAtLeast(arguments, 1);
return new Array(arguments.Select(argument => argument.Transform()).ToArray());
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
return !(Boolean)equalToOperator.Execute(argument1, argument2);
}
public override Literal Execute(IConstruct[] arguments)
{
base.EnsureArgumentCountIs(arguments, 1);
var tableName = base.GetTransformedArgument<Text>(arguments, 0);
return new DataSet(tableName);
}
/// <summary>
/// Non-zero arguments are considered true.
/// </summary>
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
return(base.GetTransformedConstruct <Boolean>(argument1) || base.GetTransformedConstruct <Boolean>(argument2));
}
public override bool IsNull(IConstruct am)
{
throw new NotImplementedException();
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
return base.GetTransformedConstruct<Number>(argument1) * base.GetTransformedConstruct<Number>(argument2);
}
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
return(base.GetTransformedConstruct <Number>(argument1) * base.GetTransformedConstruct <Number>(argument2));
}
public ConstructVM(IConstruct construct)
{
this.construct = construct;
}
/// <summary>
/// Parses the expression if it has not yet been parsed.
/// </summary>
private void EnsureExpressionParsed()
{
if (this.construct == null)
{
var variablesList = new List<Variable>();
this.construct = this.parseToConstruct(base.Source, variablesList);
this.variables = TranslateVariablesToDictionary(variablesList);
}
}
/// <summary>
/// Non-zero arguments are considered true.
/// </summary>
internal override Literal Execute(IConstruct argument1, IConstruct argument2)
{
return base.GetTransformedConstruct<Boolean>(argument1) || base.GetTransformedConstruct<Boolean>(argument2);
}
public void Add(IConstruct construct)
{
_constructs.Add(construct);
}
