public override async Task <ITriggerData> BindAsync(TTriggerValue value, ValueBindingContext context)
{
Dictionary <string, object> bindingData = Hooks.GetBindingData(value);
TMessage[] arrayRaw = Hooks.BindMultiple(value, context);
int len = arrayRaw.Length;
Type elementType = _innerBinding.ElementType;
var arrayUser = Array.CreateInstance(elementType, len);
for (int i = 0; i < len; i++)
{
TMessage item = arrayRaw[i];
object obj = await _innerBinding.ConvertAsync(item, null, context);
arrayUser.SetValue(obj, i);
}
Type arrayType = elementType.MakeArrayType();
IValueProvider valueProvider = new ConstantValueProvider(arrayUser, arrayType, "???");
var triggerData = new TriggerData(valueProvider, bindingData);
return(triggerData);
}
public virtual Task <ITriggerData> BindAsync(TTriggerValue value, ValueBindingContext context)
{
Dictionary <string, object> bindingData = Hooks.GetBindingData(value);
TMessage eventData = Hooks.BindSingle(value, context);
object userValue = this.Convert(eventData, bindingData);
string invokeString = _stringConverter(eventData, null, null);
IValueProvider valueProvider = new ConstantValueProvider(userValue, this.ElementType, invokeString);
var triggerData = new TriggerData(valueProvider, bindingData);
return(Task.FromResult <ITriggerData>(triggerData));
}
public virtual async Task <ITriggerData> BindAsync(TTriggerValue value, ValueBindingContext context)
{
Dictionary <string, object> bindingData = Hooks.GetBindingData(value);
TMessage eventData = Hooks.BindSingle(value, context);
object userValue = await this.ConvertAsync(eventData, bindingData, context);
string invokeString = await ConvertToStringAsync(eventData);
IValueProvider valueProvider = new ConstantValueProvider(userValue, this.ElementType, invokeString);
var triggerData = new TriggerData(valueProvider, bindingData);
return(triggerData);
}
private void Init(ConstantValueProvider Target)
{
if (ConstantValueProviderEd.varEdLabels == null || ConstantValueProviderEd.varEditors == null)
{
ConstantValueProviderEd.varEditors = new List <plyVarEd>();
plyVariablesEditor.LoadVarEds();
foreach (plyVarEd value in plyVariablesEditor.editors.Values)
{
if (!((plyVarEdAttribute)value.nfo).UsesAdvancedEditor)
{
ConstantValueProviderEd.varEditors.Add(value);
}
}
ConstantValueProviderEd.varEdLabels = new GUIContent[ConstantValueProviderEd.varEditors.Count];
for (int i = 0; i < ConstantValueProviderEd.varEditors.Count; i++)
{
ConstantValueProviderEd.varEdLabels[i] = new GUIContent(((plyVarEdAttribute)ConstantValueProviderEd.varEditors[i].nfo).VarTypeName);
}
}
if (this.currVarEd == null)
{
this.selectedEdType = Target.constant.ValueHandler.GetType();
for (int j = 0; j < ConstantValueProviderEd.varEditors.Count; j++)
{
plyVarEdAttribute plyVarEdAttribute = (plyVarEdAttribute)ConstantValueProviderEd.varEditors[j].nfo;
if (this.selectedEdType == plyVarEdAttribute.TargetType)
{
this.currVarEd = ConstantValueProviderEd.varEditors[j];
this.varTypeIdx = j;
break;
}
}
}
if (this.varTypeIdx < 0)
{
this.varTypeIdx = 0;
this.currVarEd = ConstantValueProviderEd.varEditors[0];
Target.constant = plyVar.Create(this.currVarEd.nfo.TargetType);
Target.constant.name = "constant";
}
}
protected override void Draw(Rect rect, DataProvider target, bool isSetter)
{
ConstantValueProvider constantValueProvider = (ConstantValueProvider)target;
this.Init(constantValueProvider);
rect.height = EditorGUIUtility.singleLineHeight;
EditorGUI.BeginChangeCheck();
this.varTypeIdx = EditorGUI.Popup(rect, ConstantValueProviderEd.GC_ValueType, this.varTypeIdx, ConstantValueProviderEd.varEdLabels);
if (EditorGUI.EndChangeCheck())
{
this.currVarEd = ConstantValueProviderEd.varEditors[this.varTypeIdx];
constantValueProvider.constant = plyVar.Create(this.currVarEd.nfo.TargetType);
constantValueProvider.constant.name = "constant";
}
if (this.currVarEd != null && constantValueProvider.constant != null)
{
rect.y += (float)(EditorGUIUtility.singleLineHeight + 2.0);
rect.x += EditorGUIUtility.labelWidth;
rect.width -= EditorGUIUtility.labelWidth;
this.currVarEd.DrawEditor(rect, false, constantValueProvider.constant, constantValueProvider.constant, 0);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testConstantDecisionRef()
public virtual void testConstantDecisionRef()
{
// given:
string decisionRef = "aDecisionToCall";
decisionTask.Decision = decisionRef;
// when
CmmnActivity activity = handler.handleElement(planItem, context);
// then
DecisionTaskActivityBehavior behavior = (DecisionTaskActivityBehavior)activity.ActivityBehavior;
BaseCallableElement callableElement = behavior.CallableElement;
ParameterValueProvider decisionRefValueProvider = callableElement.DefinitionKeyValueProvider;
assertNotNull(decisionRefValueProvider);
assertTrue(decisionRefValueProvider is ConstantValueProvider);
ConstantValueProvider valueProvider = (ConstantValueProvider)decisionRefValueProvider;
assertEquals(decisionRef, valueProvider.getValue(null));
}
internal static ParameterProfile BuildParameterProfile(string name, Type type, FunctionParameterAttribute attribute, Type controllerType)
{
BaseValueProvider defaultValueProvider = new NoValueValueProvider();
string label = name;
string helpText = String.Empty;
if (!attribute.Label.IsNullOrEmpty())
{
label = attribute.Label;
}
if (!attribute.Help.IsNullOrEmpty())
{
helpText = attribute.Help;
}
bool isRequired = !attribute.HasDefaultValue;
if (!isRequired)
{
defaultValueProvider = new ConstantValueProvider(attribute.DefaultValue);
}
WidgetFunctionProvider widgetProvider = attribute.GetWidgetFunctionProvider(controllerType, null);
bool hideInSimpleView = attribute.HideInSimpleView;
if (widgetProvider == null)
{
widgetProvider = StandardWidgetFunctions.GetDefaultWidgetFunctionProviderByType(type, isRequired);
}
return(new ParameterProfile(name, type, isRequired, defaultValueProvider, widgetProvider, label,
new HelpDefinition(helpText),
hideInSimpleView));
}
private IList <ParameterProfile> InitializeParamteres()
{
ParameterInfo[] parameterInfos = this.MethodInfo.GetParameters();
var defaultValues = new Dictionary <string, object>();
var labels = new Dictionary <string, string>();
var helpTexts = new Dictionary <string, string>();
var widgetProviders = new Dictionary <string, WidgetFunctionProvider>();
var parametersToHideInSimpleView = new HashSet <string>();
foreach (object obj in this.MethodInfo.GetCustomAttributes(typeof(MethodBasedDefaultValueAttribute), true))
{
MethodBasedDefaultValueAttribute attribute = (MethodBasedDefaultValueAttribute)obj;
defaultValues.Add(attribute.ParameterName, attribute.DefaultValue);
}
// Run through obsolete FunctionParameterDescriptionAttribute
#pragma warning disable 612,618
foreach (
object obj in this.MethodInfo.GetCustomAttributes(typeof(FunctionParameterDescriptionAttribute), true))
{
FunctionParameterDescriptionAttribute attribute = (FunctionParameterDescriptionAttribute)obj;
if (attribute.HasDefaultValue && !defaultValues.ContainsKey(attribute.ParameterName))
{
defaultValues.Add(attribute.ParameterName, attribute.DefaultValue);
}
labels.Add(attribute.ParameterName, attribute.ParameterLabel);
helpTexts.Add(attribute.ParameterName, attribute.ParameterHelpText);
}
#pragma warning restore 612,618
// Run trhough new and improved FunctionParameterAttribute. Many may exist for one parameter.
foreach (object obj in this.MethodInfo.GetCustomAttributes(typeof(FunctionParameterAttribute), true))
{
var attribute = (FunctionParameterAttribute)obj;
Verify.That(attribute.HasName,
"All [FunctionParameter(...)] definitions on the method '{0}' must have 'Name' specified.",
this.MethodInfo.Name);
string parameterName = attribute.Name;
if (attribute.HasDefaultValue && !defaultValues.ContainsKey(parameterName))
{
defaultValues.Add(parameterName, attribute.DefaultValue);
}
if (attribute.HasLabel && !labels.ContainsKey(parameterName))
{
labels.Add(parameterName, attribute.Label);
}
if (attribute.HasHelp && !helpTexts.ContainsKey(parameterName))
{
helpTexts.Add(parameterName, attribute.Help);
}
if (attribute.HasWidgetMarkup && !widgetProviders.ContainsKey(parameterName))
{
try
{
var widgetFunctionProvider = attribute.GetWidgetFunctionProvider(null, null);
widgetProviders.Add(parameterName, widgetFunctionProvider);
}
catch (Exception ex)
{
string errText = "Failed to set Widget Markup for parameter '{0}' on method '{1}'. {2}"
.FormatWith(parameterName, this.MethodInfo.Name, ex.Message);
throw new InvalidOperationException(errText);
}
}
if (attribute.HideInSimpleView)
{
parametersToHideInSimpleView.Add(parameterName);
}
}
var result = new List <ParameterProfile>();
foreach (ParameterInfo parameterInfo in parameterInfos)
{
string parameterName = parameterInfo.Name;
BaseValueProvider valueProvider;
object defaultValue = null;
if (defaultValues.TryGetValue(parameterName, out defaultValue))
{
valueProvider = new ConstantValueProvider(defaultValue);
}
else
{
valueProvider = new NoValueValueProvider();
}
bool isRequired = !defaultValues.ContainsKey(parameterName);
string parameterLabel = parameterInfo.Name;
if (labels.ContainsKey(parameterName))
{
parameterLabel = labels[parameterName];
}
string parameterHelpText = "";
if (helpTexts.ContainsKey(parameterName))
{
parameterHelpText = helpTexts[parameterName];
}
WidgetFunctionProvider widgetFunctionProvider =
(widgetProviders.ContainsKey(parameterName)
? widgetProviders[parameterName]
: StandardWidgetFunctions.GetDefaultWidgetFunctionProviderByType(parameterInfo.ParameterType));
bool hideInSimpleView = parametersToHideInSimpleView.Contains(parameterName);
result.Add(new ParameterProfile(parameterName, parameterInfo.ParameterType, isRequired,
valueProvider, widgetFunctionProvider, parameterLabel,
new HelpDefinition(parameterHelpText),
hideInSimpleView));
}
return(result);
}
