protected DvStateVariable _relatedStateVariable; // References the related state variable in our parent action's parent service /// <summary> /// Creates a new formal argument for a device's action. /// </summary> /// <param name="name">Name of the argument. The name SHOULD be chosen to reflect the semantic use /// of the argument. MUST NOT contain a hyphen character ("-") nor /// a hash character (“#”, 23 Hex in UTF-8). Case sensitive. First character MUST be a USASCII /// letter ("A"-"Z", "a"-"z"), USASCII digit ("0"-"9"), an underscore ("_"), or a non-experimental /// Unicode letter or digit greater than U+007F. Succeeding characters MUST be a USASCII letter /// ("A"-"Z", "a"-"z"), USASCII digit ("0"-"9"), an underscore ("_"), a period ("."), a Unicode /// combiningchar, an extender, or a non-experimental Unicode letter or digit greater than /// U+007F. The first three letters MUST NOT be "XML" in any combination of case. /// Case sensitive. SHOULD be < 32 characters. /// </param> /// <param name="relatedStateVariable">Defines the type of the argument; see further explanation in (DevArch).</param> /// <param name="direction">Defines whether argument is an input or output parameter.</param> /// <param name="isReturnValue">Returns the information if this argument is the return value of the parent /// action. This argument is allowed to be <c>true</c> at most for one argument per action. If it is set to /// <c>true</c> for an argument, that argument MUST be the first output argument of the action.</param> public DvArgument(string name, DvStateVariable relatedStateVariable, ArgumentDirection direction, bool isReturnValue) { _name = name; _relatedStateVariable = relatedStateVariable; _direction = direction; _isReturnValue = isReturnValue; }
public RuntimeDelegateArgument (string name, Type type, ArgumentDirection direction, DelegateArgument boundArgument) { Name = name; Type = type; Direction = direction; BoundArgument = boundArgument; }
public RuntimeDelegateArgument(string name, Type type, ArgumentDirection direction, DelegateArgument boundArgument) { if (string.IsNullOrEmpty(name)) { throw FxTrace.Exception.ArgumentNullOrEmpty("name"); } if (type == null) { throw FxTrace.Exception.ArgumentNull("type"); } ArgumentDirectionHelper.Validate(direction, "direction"); if (boundArgument != null) { // Validations that the bound argument matches are done // in CacheMetadata for ActivityDelegate. boundArgument.Bind(this); } this.Name = name; this.Type = type; this.Direction = direction; this.BoundArgument = boundArgument; }
public InlinedLocationReference(LocationReference innerReference, Activity validAccessor, ArgumentDirection accessDirection) { this.innerReference = innerReference; this.validAccessor = validAccessor; this.allowReads = accessDirection != ArgumentDirection.Out; this.allowWrites = accessDirection != ArgumentDirection.In; }
public static void Validate(ArgumentDirection direction, string argumentName) { if (!IsDefined(direction)) { throw FxTrace.Exception.AsError(new InvalidEnumArgumentException(argumentName, (int) direction, typeof(ArgumentDirection))); } }
internal UPnPArgument(XmlElement Xml) { this.xml = Xml; foreach (XmlNode N in Xml.ChildNodes) { switch (N.LocalName) { case "name": this.name = N.InnerText; break; case "direction": if (N.InnerText.ToLower() == "out") this.direction = ArgumentDirection.Out; else this.direction = ArgumentDirection.In; break; case "retval": this.returnValue = true; break; case "relatedStateVariable": this.relatedStateVariable = N.InnerText; break; } } }
public static bool IsOut(ArgumentDirection direction) { if (direction != ArgumentDirection.Out) { return (direction == ArgumentDirection.InOut); } return true; }
public static void Validate(ArgumentDirection direction, string argumentName) { if (!IsDefined(direction)) { throw FxTrace.Exception.AsError( new InvalidEnumArgumentException(argumentName, (int)direction, typeof(ArgumentDirection))); } }
//internal RuntimeArgument(string name, Type argumentType, ArgumentDirection direction, bool isRequired, List<string> overloadGroups, PropertyDescriptor bindingProperty, object propertyOwner) // : this(name, argumentType, direction, isRequired, overloadGroups) //{ // this.bindingProperty = bindingProperty; // this.bindingPropertyOwner = propertyOwner; //} internal RuntimeArgument(string name, Type argumentType, ArgumentDirection direction, bool isRequired, List <string> overloadGroups, Argument argument) : this(name, argumentType, direction, isRequired, overloadGroups) { Fx.Assert(argument != null, "This ctor is only for arguments discovered via reflection in an IDictionary and therefore cannot be null."); // Bind straightway since we're not dealing with a property and empty binding isn't an issue. Argument.Bind(argument, this); }
internal static bool IsDefined(ArgumentDirection direction) { if ((direction != ArgumentDirection.In) && (direction != ArgumentDirection.Out)) { return (direction == ArgumentDirection.InOut); } return true; }
void AddGeneratedArgument(Type argumentType, ArgumentDirection direction, ActivityWithResult expression) { Argument argument = ActivityUtilities.CreateArgument(argumentType, direction); argument.Expression = expression; RuntimeArgument runtimeArgument = this.metadata.CurrentActivity.AddTempAutoGeneratedArgument(argumentType, direction); Argument.TryBind(argument, runtimeArgument, this.metadata.CurrentActivity); }
protected CpStateVariable _relatedStateVariable; // References the related state variable in our parent action's parent service public CpArgument(CpAction parentAction, string name, CpStateVariable relatedStateVariable, ArgumentDirection direction, bool isReturnValue) { _parentAction = parentAction; _name = name; _relatedStateVariable = relatedStateVariable; _direction = direction; _isReturnValue = isReturnValue; }
public Argument(string name, string relatedStateVariable, ArgumentDirection direction, bool isReturnValue) : this(name, relatedStateVariable, direction) { if (isReturnValue && direction == ArgumentDirection.In) { throw new ArgumentException("The direction is In, but isReturnValue is true. " + "An IsReturnValue argument must have the direction Out."); } IsReturnValue = isReturnValue; }
protected internal Argument(string name, ArgumentDirection direction, bool isReturnValue, StateVariable relatedStateVariable) { if (name == null) throw new ArgumentNullException ("name"); if (isReturnValue && direction == ArgumentDirection.In) throw new ArgumentException ("If the argument is a return value, it must have an 'Out' direction."); if (relatedStateVariable == null) throw new ArgumentNullException ("relatedStateVariable"); this.name = name; this.direction = direction; this.is_return_value = isReturnValue; this.related_state_variable = relatedStateVariable; }
public bool TryGetAccessToPublicLocation(LocationReference publicLocation, ArgumentDirection accessDirection, out LocationReference equivalentLocation) { if (publicLocation == null) { throw FxTrace.Exception.ArgumentNull("publicLocation"); } ThrowIfUninitialized(); return TryGetAccessToPublicLocation(publicLocation, accessDirection, false, out equivalentLocation); }
public bool TryGetAccessToPublicLocation(LocationReference publicLocation, ArgumentDirection accessDirection, out LocationReference equivalentLocation) { if (publicLocation == null) { throw FxTrace.Exception.ArgumentNull("publicLocation"); } ThrowIfUninitialized(); return(TryGetAccessToPublicLocation(publicLocation, accessDirection, false, out equivalentLocation)); }
public Argument(string name, string relatedStateVariable, ArgumentDirection direction) { if (direction < ArgumentDirection.In || direction > ArgumentDirection.Out) { throw new ArgumentOutOfRangeException("direction"); } Name = name; RelatedStateVariable = relatedStateVariable; Direction = direction; }
private static Type CreateArgumentType(Type type, ArgumentDirection direction) { if (direction == ArgumentDirection.In) { return(ActivityUtilities.inArgumentGenericType.MakeGenericType(new Type[] { type })); } if (direction == ArgumentDirection.Out) { return(ActivityUtilities.outArgumentGenericType.MakeGenericType(new Type[] { type })); } return(ActivityUtilities.inOutArgumentGenericType.MakeGenericType(new Type[] { type })); }
public static Argument CreateArgumentOfObject(ArgumentDirection direction) { if (direction == ArgumentDirection.In) { return((Argument)Activator.CreateInstance(inArgumentOfObjectType)); } if (direction == ArgumentDirection.Out) { return((Argument)Activator.CreateInstance(outArgumentOfObjectType)); } return((Argument)Activator.CreateInstance(inOutArgumentOfObjectType)); }
private static void AddRuntimeArgument(this CodeActivityMetadata metadata, Argument argument, Type argumentType, ArgumentDirection direction, string argumentName, bool isRequired) { var arg = new RuntimeArgument(argumentName, argumentType, direction, isRequired); metadata.Bind(argument, arg); metadata.AddArgument(arg); }
/// <summary> /// Counts the number of arguments with a specified direction. /// </summary> /// <param name="dir">The direction of the arguments.</param> /// <returns>The number of arguments matching the direction.</returns> protected int ArgDirCount(ArgumentDirection dir) { int liCount = 0; foreach (ArgumentDescription ladDesc in this.Values) { if (ladDesc.DirectionValue == dir) { liCount++; } } return(liCount); }
public static void AddRuntimeArgument( this NativeActivityMetadata metadata, Argument messageArgument, string runtimeArgumentName, Type runtimeArgumentType, ArgumentDirection runtimeArgumentDirection, bool isRequired, List <string> overloadGroupNames) { RuntimeArgument runtimeArgument = new RuntimeArgument(runtimeArgumentName, runtimeArgumentType, runtimeArgumentDirection, isRequired, overloadGroupNames); metadata.Bind(messageArgument, runtimeArgument); metadata.AddArgument(runtimeArgument); }
private static ParameterDirection WokflowDbParameterToParameterDirection(ArgumentDirection argumentDirection) { switch (argumentDirection) { case ArgumentDirection.In: return(ParameterDirection.Input); case ArgumentDirection.Out: return(ParameterDirection.Output); default: return(ParameterDirection.InputOutput); } }
public RuntimeArgument(string name, Type argumentType, ArgumentDirection direction, bool isRequired, List <string> overloadGroupNames) { if (string.IsNullOrEmpty(name)) { throw FxTrace.Exception.ArgumentNullOrEmpty(nameof(name)); } ArgumentDirectionHelper.Validate(direction, "direction"); this.name = name; this.type = argumentType ?? throw FxTrace.Exception.ArgumentNull(nameof(argumentType)); this.Direction = direction; this.IsRequired = isRequired; this.overloadGroupNames = overloadGroupNames; }
public static Argument CreateFromAttributes(string name, string type) { Argument arg = new Argument(name); int parenthesisIndex = type.IndexOf('('); string dirType = type.Substring(0, parenthesisIndex); ArgumentDirection argDirection = ArgumentDirectionMethods.Parse(dirType); arg.Direction = argDirection; arg.Type = type.Substring(parenthesisIndex + 1, type.Length - parenthesisIndex - 2); return(arg); }
public static string Prefix(this ArgumentDirection type) { switch (type) { case ArgumentDirection.In: return("in_"); case ArgumentDirection.InOut: return("io_"); case ArgumentDirection.Out: return("out_"); } return(string.Empty); }
public static Argument CreateReferenceArgument(Type argumentType, ArgumentDirection direction, string referencedArgumentName) { Argument argument = Argument.Create(argumentType, direction); object obj2 = null; if (direction == ArgumentDirection.In) { obj2 = Activator.CreateInstance(argumentValueGenericType.MakeGenericType(new Type[] { argumentType }), new object[] { referencedArgumentName }); } else { obj2 = Activator.CreateInstance(argumentReferenceGenericType.MakeGenericType(new Type[] { argumentType }), new object[] { referencedArgumentName }); } argument.Expression = (ActivityWithResult)obj2; return(argument); }
// In 4.0 the expression type for publicly inspectable auto-generated arguments was // LocationReferenceValue<T>, whether the argument was actually used as an L-Value or R-Value. // We keep that for back-compat (useLocationReferenceValue == true), and only use the new // EnvironmentLocationValue/Reference classes for new activities. internal bool TryGetAccessToPublicLocation(LocationReference publicLocation, ArgumentDirection accessDirection, bool useLocationReferenceValue, out LocationReference equivalentLocation) { Fx.Assert(!useLocationReferenceValue || this.ActivityMetadata.CurrentActivity.UseOldFastPath, "useLocationReferenceValue should only be used for back-compat"); if (this.metadata.Environment.IsVisible(publicLocation)) { if (!this.withoutArgument) { CreateArgument(publicLocation, accessDirection, useLocationReferenceValue); } equivalentLocation = new InlinedLocationReference(publicLocation, this.metadata.CurrentActivity, accessDirection); return(true); } equivalentLocation = null; return(false); }
public static bool TryGetArgumentDirectionAndType(Type propertyType, out ArgumentDirection direction, out Type argumentType) { direction = ArgumentDirection.In; argumentType = TypeHelper.ObjectType; if (propertyType.IsGenericType) { argumentType = propertyType.GetGenericArguments()[0]; Type genericTypeDefinition = propertyType.GetGenericTypeDefinition(); if (genericTypeDefinition == inArgumentGenericType) { return(true); } if (genericTypeDefinition == outArgumentGenericType) { direction = ArgumentDirection.Out; return(true); } if (genericTypeDefinition == inOutArgumentGenericType) { direction = ArgumentDirection.InOut; return(true); } } else { if (propertyType == inArgumentType) { return(true); } if (propertyType == outArgumentType) { direction = ArgumentDirection.Out; return(true); } if (propertyType == inOutArgumentType) { direction = ArgumentDirection.InOut; return(true); } } return(false); }
protected internal Argument(string name, ArgumentDirection direction, bool isReturnValue, StateVariable relatedStateVariable) { if (name == null) { throw new ArgumentNullException("name"); } if (isReturnValue && direction == ArgumentDirection.In) { throw new ArgumentException("If the argument is a return value, it must have an 'Out' direction."); } if (relatedStateVariable == null) { throw new ArgumentNullException("relatedStateVariable"); } this.name = name; this.direction = direction; this.is_return_value = isReturnValue; this.related_state_variable = relatedStateVariable; }
public RuntimeArgument(string name, Type argumentType, ArgumentDirection direction, bool isRequired, List <string> overloadGroupNames) { if (string.IsNullOrEmpty(name)) { throw CoreWf.Internals.FxTrace.Exception.ArgumentNullOrEmpty("name"); } if (argumentType == null) { throw CoreWf.Internals.FxTrace.Exception.ArgumentNull("argumentType"); } ArgumentDirectionHelper.Validate(direction, "direction"); _name = name; _type = argumentType; this.Direction = direction; this.IsRequired = isRequired; _overloadGroupNames = overloadGroupNames; }
public RuntimeDelegateArgument(string name, System.Type type, ArgumentDirection direction, DelegateArgument boundArgument) { if (string.IsNullOrEmpty(name)) { throw FxTrace.Exception.ArgumentNullOrEmpty("name"); } if (type == null) { throw FxTrace.Exception.ArgumentNull("type"); } ArgumentDirectionHelper.Validate(direction, "direction"); if (boundArgument != null) { boundArgument.Bind(this); } this.Name = name; this.Type = type; this.Direction = direction; this.BoundArgument = boundArgument; }
public RuntimeDelegateArgument(string name, Type type, ArgumentDirection direction, DelegateArgument boundArgument) { if (string.IsNullOrEmpty(name)) { throw FxTrace.Exception.ArgumentNullOrEmpty(nameof(name)); } ArgumentDirectionHelper.Validate(direction, "direction"); if (boundArgument != null) { // Validations that the bound argument matches are done // in CacheMetadata for ActivityDelegate. boundArgument.Bind(this); } this.Name = name; this.Type = type ?? throw FxTrace.Exception.ArgumentNull(nameof(type)); this.Direction = direction; this.BoundArgument = boundArgument; }
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture) { Argument target = null; ArgumentDirection direction = ArgumentDirection.In; string directionString = parameter as string; if (!string.IsNullOrEmpty(directionString)) { direction = (ArgumentDirection)Enum.Parse(typeof(ArgumentDirection), directionString); } Activity expression = null; ModelItem valueExpressionModelItem = value as ModelItem; if (valueExpressionModelItem != null && typeof(Activity).IsAssignableFrom(valueExpressionModelItem.ItemType)) { expression = (Activity)valueExpressionModelItem.GetCurrentValue(); } ActivityWithResult activityWithResult = expression as ActivityWithResult; if (expression != null && activityWithResult != null) { // In the In case the expression is of type Activity<T> so we want to create InArgument<T> // In Out and InOut case the expresion is Activity<Location<T>> we want to create OutArgument<T>,InOutArgument<T> Type argumentType; if (direction == ArgumentDirection.In) { argumentType = activityWithResult.ResultType; } else { // if expression type is Location<T> argument type is T argumentType = activityWithResult.ResultType.GetGenericArguments()[0]; } target = Argument.Create(argumentType, direction); target.Expression = activityWithResult; } return(new object[] { target }); }
internal static bool IsDefined(ArgumentDirection direction) { return (direction == ArgumentDirection.In || direction == ArgumentDirection.Out || direction == ArgumentDirection.InOut); }
public ServiceActionArgument(string name, string type, ArgumentDirection direction) { Name = name; Type = type; Direction = direction; }
internal void CreateArgument(LocationReference sourceReference, ArgumentDirection accessDirection, bool useLocationReferenceValue = false) { ActivityWithResult expression = ActivityUtilities.CreateLocationAccessExpression(sourceReference, accessDirection != ArgumentDirection.In, useLocationReferenceValue); AddGeneratedArgument(sourceReference.Type, accessDirection, expression); }
public static bool IsOut(ArgumentDirection direction) { return (direction == ArgumentDirection.Out) || (direction == ArgumentDirection.InOut); }
public DvArgument(string name, DvStateVariable relatedStateVariable, ArgumentDirection direction) : this(name, relatedStateVariable, direction, false) { }
protected virtual Argument CreateArgument(string name, ArgumentDirection direction, bool isRetVal, StateVariable relatedStateVariable) { return new Argument (this, direction, isRetVal, relatedStateVariable); }
internal static bool IsDefined(ArgumentDirection direction) { return(direction == ArgumentDirection.In || direction == ArgumentDirection.Out || direction == ArgumentDirection.InOut); }
public CpArgument(CpAction parentAction, string name, CpStateVariable relatedStateVariable, ArgumentDirection direction) : this(parentAction, name, relatedStateVariable, direction, false) { }
public static bool IsOut(ArgumentDirection direction) { return((direction == ArgumentDirection.Out) || (direction == ArgumentDirection.InOut)); }
public static Argument Create(Type type, ArgumentDirection direction) { return(ActivityUtilities.CreateArgument(type, direction)); }
public static void FixMessageArgument(Argument messageArgument, ArgumentDirection direction, ActivityMetadata metadata) { Type messageType = (messageArgument == null) ? TypeHelper.ObjectType : messageArgument.ArgumentType; AddRuntimeArgument(messageArgument, "Message", messageType, direction, metadata); }
// In 4.0 the expression type for publicly inspectable auto-generated arguments was // LocationReferenceValue<T>, whether the argument was actually used as an L-Value or R-Value. // We keep that for back-compat (useLocationReferenceValue == true), and only use the new // EnvironmentLocationValue/Reference classes for new activities. internal bool TryGetAccessToPublicLocation(LocationReference publicLocation, ArgumentDirection accessDirection, bool useLocationReferenceValue, out LocationReference equivalentLocation) { Fx.Assert(!useLocationReferenceValue || this.ActivityMetadata.CurrentActivity.UseOldFastPath, "useLocationReferenceValue should only be used for back-compat"); if (this.metadata.Environment.IsVisible(publicLocation)) { if (!this.withoutArgument) { CreateArgument(publicLocation, accessDirection, useLocationReferenceValue); } equivalentLocation = new InlinedLocationReference(publicLocation, this.metadata.CurrentActivity, accessDirection); return true; } equivalentLocation = null; return false; }