public override VisualizationResult Handle(VariableMetaData meta)
{
var variable = _helper.ReadVariable(meta.Entry);
var length = variable.Fields["length"].Data.Data;
return(new VisualizationResult($"{meta.TypeName} [{length}]", length > 0));
}
private static MethodMetadataDesc GetCheckMetadataVariable(
string methodName,
VariableMetaData variableMetaData,
ImportServiceCompileTime importService,
Type metadataClass)
{
var typeGetterMethod = GetRequiredTypeGetterMethodCanNonStatic(
methodName,
null,
variableMetaData.Type,
importService,
metadataClass);
if (typeGetterMethod.IsStatic) {
return InvokeMetadataMethod(null, variableMetaData.GetType().GetSimpleName(), typeGetterMethod);
}
// if the metadata is not a static method and we don't have an instance this is a problem
var messagePrefix = "Failed to access variable method invocation metadata: ";
var value = variableMetaData.ValueWhenAvailable;
if (value == null) {
throw new ExprValidationException(
messagePrefix + "The variable value is null and the metadata method is an instance method");
}
if (value is EventBean) {
value = ((EventBean) value).Underlying;
}
return InvokeMetadataMethod(value, variableMetaData.GetType().GetSimpleName(), typeGetterMethod);
}
public static string CheckVariableContextName(
string optionalStatementContextName,
VariableMetaData variableMetaData)
{
if (optionalStatementContextName == null) {
if (variableMetaData.OptionalContextName != null) {
return "Variable '" +
variableMetaData.VariableName +
"' defined for use with context '" +
variableMetaData.OptionalContextName +
"' can only be accessed within that context";
}
}
else {
if (variableMetaData.OptionalContextName != null &&
!variableMetaData.OptionalContextName.Equals(optionalStatementContextName)) {
return "Variable '" +
variableMetaData.VariableName +
"' defined for use with context '" +
variableMetaData.OptionalContextName +
"' is not available for use with context '" +
optionalStatementContextName +
"'";
}
}
return null;
}
public MethodTargetStrategyVariableForge(
VariableMetaData variableMetaData,
MethodInfo reflectionMethod)
{
this.variableMetaData = variableMetaData;
this.reflectionMethod = reflectionMethod;
}
public override bool CanHandle(VariableMetaData meta)
{
return(string.Equals(meta.TypeName, _stringTypeName, StringComparison.OrdinalIgnoreCase) ||
meta.TypeName.Contains(_dynamicStringTypeName) ||
string.Equals(meta.TypeName, _shortStringName, StringComparison.OrdinalIgnoreCase) ||
meta.TypeName.EndsWith($"{_dynamicStringTypeName} *"));
}
public bool TryHandle(VariableMetaData description, out VisualizationResult result)
{
var handler = _registry.FirstOrDefault(x => x.CanHandle(description)) ?? DefaultVisualizer;
if (handler != null)
{
try
{
result = handler.Handle(description);
return(true);
}
catch (Exception ex)
{
_logger.Error($"Error resolving variable '{description.Name}': {ex.Message}", ex);
_logger.Debug("Falling back to default visualizer ..");
try
{
result = DefaultVisualizer.Handle(description);
return(true);
}
catch (Exception defaultVisualizerException)
{
_logger.Error($"Default visualizer failed to resolve variable '{description.Name}': {defaultVisualizerException.Message}", defaultVisualizerException);
}
}
}
result = _defaultResult;
return(false);
}
private static ExprNode HandleVariable(
IList <Chainable> chain,
VariableMetaData variable,
StatementSpecMapContext mapContext,
Func <IList <Chainable>, ExprDotNodeImpl> dotNodeFunction)
{
var message = VariableUtil.CheckVariableContextName(mapContext.ContextName, variable);
if (message != null)
{
throw new ValidationException(message);
}
ExprNode rootNode = new ExprVariableNodeImpl(variable, null);
if (chain.Count == 1)
{
return(rootNode);
}
// Handle simple-subproperty by means of variable node
if (chain.Count == 2 && chain[1] is ChainableName)
{
return(new ExprVariableNodeImpl(variable, chain[1].GetRootNameOrEmptyString()));
}
var subchain = chain.SubList(1, chain.Count);
ExprDotNode dot = dotNodeFunction.Invoke(subchain);
dot.AddChildNode(rootNode);
return(dot);
}
public ExprVariableNodeImpl(
VariableMetaData variableMeta,
string optSubPropName)
{
VariableMetadata = variableMeta;
this.optSubPropName = optSubPropName;
}
public override IEnumerable <VariableMetaData> GetChildren(VariableMetaData descriptor)
{
var result = new List <VariableMetaData>();
var typedData = descriptor.Entry;
if (typedData.Tag == (uint)SymTag.PointerType)
{
var pointerValue = _helper.Dereference(typedData);
var meta = new VariableMetaData("inner", _symbols.GetSymbolType(pointerValue.ModBase, pointerValue.TypeId), pointerValue);
result.Add(meta);
}
else if (typedData.Tag == (uint)SymTag.ArrayType)
{
var arrayLength = GetArrayLength(typedData);
return(ReadArray(typedData, arrayLength));
}
else
{
var fieldNames = _helper.ReadFieldNames(typedData);
foreach (var field in fieldNames)
{
var fieldData = _helper.GetField(typedData, field);
var meta = new VariableMetaData(field, _symbols.GetSymbolType(fieldData.ModBase, fieldData.TypeId), fieldData);
result.Add(meta);
}
}
return(result);
}
public override IEnumerable <VariableMetaData> GetChildren(VariableMetaData meta)
{
var variable = _helper.ReadVariable(meta.Entry);
var length = variable.Fields["length"].Data.Data;
var pointer = variable.Fields["data_ptr"];
return(ReadArray(pointer.Data, length));
}
public StatementAgentInstanceFactoryCreateVariable(StatementContext statementContext, EPServicesContext services, VariableMetaData variableMetaData, EventType eventType)
: base(statementContext.Annotations)
{
_statementContext = statementContext;
_services = services;
_variableMetaData = variableMetaData;
_eventType = eventType;
}
public override IEnumerable <VariableMetaData> GetChildren(VariableMetaData meta)
{
var variable = _helper.ReadVariable(meta.Entry);
var result = new Dictionary <VariableMetaData, VisualizationResult>();
var pointerField = variable.Fields.First().Value.Data;
yield return(new VariableMetaData("inner", GetTypeName(pointerField), pointerField));
}
public void AddVariable(
string deploymentId,
VariableMetaData metaData,
string optionalDeploymentIdContext,
DataInputOutputSerde optionalSerde)
{
lock (this) {
// check if already exists
var deploymentEntry = DeploymentsWithVariables.Get(deploymentId);
if (deploymentEntry != null) {
var variableX = deploymentEntry.GetVariable(metaData.VariableName);
if (variableX != null) {
throw new ArgumentException(
"Variable already exists by name '" +
metaData.VariableName +
"' and deployment '" +
deploymentId +
"'");
}
}
else {
deploymentEntry = new VariableDeployment();
DeploymentsWithVariables.Put(deploymentId, deploymentEntry);
}
// find empty spot
var emptySpot = -1;
var count = 0;
foreach (var entry in variableVersionsPerCP) {
if (entry == null) {
emptySpot = count;
break;
}
count++;
}
int variableNumber;
if (emptySpot != -1) {
variableNumber = emptySpot;
variableVersionsPerCP[emptySpot] = new ConcurrentDictionary<int, VariableReader>();
changeCallbacksPerCP[emptySpot] = null;
}
else {
variableNumber = currentVariableNumber;
variableVersionsPerCP.Add(new ConcurrentDictionary<int, VariableReader>());
changeCallbacksPerCP.Add(null);
currentVariableNumber++;
}
var variable = new Variable(variableNumber, deploymentId, metaData, optionalDeploymentIdContext);
deploymentEntry.AddVariable(metaData.VariableName, variable);
if (OptionalStateHandler != null && !metaData.IsConstant) {
OptionalStateHandler.AddVariable(deploymentId, metaData.VariableName, variable, optionalSerde);
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="eventRate">is the number of old or new events thatmust arrive in order for the condition to be satisfied</param>
/// <param name="variableMetaData">is the variable metadata, if a variable was supplied, else null</param>
public OutputConditionCountFactory(int eventRate, VariableMetaData variableMetaData)
{
if ((eventRate < 1) && (variableMetaData == null))
{
throw new ArgumentException("Limiting output by event count requires an event count of at least 1 or a variable name");
}
EventRate = eventRate;
VariableMetaData = variableMetaData;
}
private VisualizationResult ReadStaticString(VariableMetaData meta)
{
var variableRead = _helper.ReadVariable(meta.Entry);
var stringLength = variableRead.Fields["length"].Data.Data;
string actualString = ReadString(variableRead, stringLength);
return(new VisualizationResult(actualString.WithQuotes(), false));
}
private IVisualizer FindHandler(VariableMetaData description)
{
var handler = _registry.FirstOrDefault(x => x.CanHandle(description)) ?? DefaultVisualizer;
if (handler == null)
{
throw new ArgumentException($"Visualizer for handling '{description.Name}' has not been registered.", nameof(description));
}
return(handler);
}
public override VisualizationResult Handle(VariableMetaData meta)
{
var typedData = meta.Entry;
var bigString = _helper.ReadString(typedData.Offset, (uint)Defaults.MaxStringSize);
var endIndex = bigString.IndexOf('\0');
string actualString = endIndex == Defaults.NotFound ? $"{bigString}..." : bigString.Substring(0, endIndex);
return(new VisualizationResult(actualString, false));
}
public string IsVariableOpGetName(VariableService variableService)
{
VariableMetaData metaData = null;
if (_chainSpec.Count > 0 && _chainSpec[0].IsProperty)
{
metaData = variableService.GetVariableMetaData(_chainSpec[0].Name);
}
return(metaData == null ? null : metaData.VariableName);
}
private VisualizationResult ReadPointerString(VariableMetaData meta)
{
var variableTree = _helper.ReadVariable(meta.Entry);
var stringLength = variableTree.Fields.First().Value.Fields["len"].Data.Data;
var stringContainer = variableTree.Fields.First().Value.Fields["buf"];
var actualString = ReadString(stringContainer, stringLength);
return(new VisualizationResult(actualString.WithQuotes(), false));
}
public StatementAgentInstanceFactoryCreateVariable(CreateVariableDesc createDesc, StatementSpecCompiled statementSpec, StatementContext statementContext, EPServicesContext services, VariableMetaData variableMetaData, EventType eventType)
: base(statementContext.Annotations)
{
_createDesc = createDesc;
_statementSpec = statementSpec;
_statementContext = statementContext;
_services = services;
_variableMetaData = variableMetaData;
_eventType = eventType;
}
public ExprDotNodeForgeVariable(
ExprDotNodeImpl parent,
VariableMetaData variable,
ExprDotStaticMethodWrap resultWrapLambda,
ExprDotForge[] chainForge)
{
ExprForgeRenderable = parent;
Variable = variable;
ResultWrapLambda = resultWrapLambda;
ChainForge = chainForge;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="variableMetaData">The variable meta data.</param>
/// <param name="optSubPropName">Name of the opt sub property.</param>
/// <exception cref="System.ArgumentException">Variables metadata is null</exception>
public ExprVariableNodeImpl(VariableMetaData variableMetaData, String optSubPropName)
{
if (variableMetaData == null)
{
throw new ArgumentException("Variables metadata is null");
}
_variableName = variableMetaData.VariableName;
_optSubPropName = optSubPropName;
_isConstant = variableMetaData.IsConstant;
_valueIfConstant = _isConstant ? variableMetaData.VariableStateFactory.InitialState : null;
}
public override VisualizationResult Handle(VariableMetaData meta)
{
var variable = _helper.ReadVariable(meta.Entry);
var names = ReadEnumNames(variable.Fields.First().Value.Data);
var enumValue = GetEnumValue(meta.Entry);
var enumName = names.ContainsKey(enumValue) ? names[enumValue] : Defaults.UnknownValue;
var hasChildren = GetChildFields(variable, enumValue).Count > 0;
return(new VisualizationResult($"{meta.TypeName}::{enumName}", hasChildren));
}
public Variable(
int variableNumber,
string deploymentId,
VariableMetaData metaData,
string optionalContextDeploymentId)
{
VariableNumber = variableNumber;
DeploymentId = deploymentId;
MetaData = metaData;
OptionalContextDeploymentId = optionalContextDeploymentId;
}
public VisualizationResult Handle(VariableMetaData description)
{
VisualizationResult result;
if (!TryHandle(description, out result))
{
return(_defaultResult);
}
return(result);
}
public override VisualizationResult Handle(VariableMetaData meta)
{
var typedData = meta.Entry;
var arrayField = _helper.GetField(typedData, "buf");
var arrayLengthField = _helper.GetField(typedData, "len");
long actualLength = _helper.ReadLong(arrayLengthField);
var value = $"Vec{meta.TypeName.Substring(_vectorTypeName.Length)} [{actualLength}]";
return(new VisualizationResult(value, actualLength > 0));
}
public static CodegenExpression MakeResolveVariable(
VariableMetaData variable,
CodegenExpression initSvc)
{
return StaticMethod(
typeof(VariableDeployTimeResolver),
"ResolveVariable",
Constant(variable.VariableName),
Constant(variable.VariableVisibility),
Constant(variable.VariableModuleName),
initSvc);
}
public override VisualizationResult Handle(VariableMetaData meta)
{
var variable = _helper.ReadVariable(meta.Entry);
var fullName = variable.Fields.First().Key;
var enumNames = ReadEnumNames(meta.Entry);
var pointerValue = BitConverter.ToUInt64(_helper.ReadValue(meta.Entry.Offset + meta.Entry.Size - 8, 8), 0);
var enumName = pointerValue == 0 ? enumNames.Item1 : enumNames.Item2;
var hasChildren = enumName != enumNames.Item1;
return(new VisualizationResult($"{meta.TypeName}::{enumName}", hasChildren));
}
public OutputConditionCountForge(
int eventRate,
VariableMetaData variableMetaData)
{
if (eventRate < 1 && variableMetaData == null) {
throw new ArgumentException(
"Limiting output by event count requires an event count of at least 1 or a variable name");
}
this.eventRate = eventRate;
this.variableMetaData = variableMetaData;
}
public override IEnumerable <VariableMetaData> GetChildren(VariableMetaData meta)
{
var typedData = meta.Entry;
var arrayField = _helper.GetField(typedData, "buf");
var arrayLengthField = _helper.GetField(typedData, "len");
var actualLength = _helper.ReadLong(arrayLengthField);
var fieldHierarchy = _helper.ReadVariable(arrayField);
var dataPointer = fieldHierarchy.Flatten().FirstOrDefault(x => (SymTag)x.Tag == SymTag.PointerType);
return(ReadArray(dataPointer, (ulong)actualLength));
}
