public Parameter(ParameterType parType, TokenTypes tokType, object column, object value) { this.TokType = tokType; this.ParType = parType; this.Column = column.ToString(); this.Value = value; }
/// <summary> /// Converts the object to an array of RestSharp parameters. /// </summary> /// <returns>The array of RestSharp parameters.</returns> public IEnumerable<Parameter> ToParameters(ParameterType type) { List<Parameter> output = new List<Parameter>(); //Inspiration for this code from https://github.com/jaymedavis/stripe.net foreach (PropertyInfo property in GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)) { object value = property.GetValue(this, null); string propName = property.Name; if (value == null) { continue; } if (property.CustomAttributes.Any(x => x.AttributeType == typeof(JsonPropertyAttribute))) { //Get the JsonPropertyAttribute for this property, which will give us its JSON name JsonPropertyAttribute attribute = property.GetCustomAttributes(typeof(JsonPropertyAttribute), false).Cast<JsonPropertyAttribute>().FirstOrDefault(); propName = attribute != null ? attribute.PropertyName : property.Name; } var parameter = ToSingleParameter(propName, value, property, type); output.Add(parameter); } return output; }
public override void DrawGUI(IntelligenceState parentState, Intelligence intelligence, CallbackCollection callbacks) { #if UNITY_EDITOR UnityEditor.EditorGUILayout.BeginHorizontal(); UnityEngine.GUILayout.Label("Method name:"); methodName = UnityEditor.EditorGUILayout.TextField(methodName); UnityEditor.EditorGUILayout.EndHorizontal(); useTargetVar = UnityEditor.EditorGUILayout.Toggle("Use other target", useTargetVar); if (useTargetVar) { UnityEditor.EditorGUILayout.BeginHorizontal(); UnityEngine.GUILayout.Label("Target var name:"); targetVarName = UnityEditor.EditorGUILayout.TextField(targetVarName); UnityEditor.EditorGUILayout.EndHorizontal(); } paramType = (ParameterType)UnityEditor.EditorGUILayout.EnumPopup("Parameter:", paramType); if (paramType == ParameterType.VarValue) { UnityEditor.EditorGUILayout.BeginHorizontal(); UnityEngine.GUILayout.Label("Var name:"); paramTypeValue = UnityEditor.EditorGUILayout.TextField(paramTypeValue); UnityEditor.EditorGUILayout.EndHorizontal(); } if (paramType == ParameterType.String) { UnityEditor.EditorGUILayout.BeginHorizontal(); UnityEngine.GUILayout.Label("Value:"); paramTypeValue = UnityEditor.EditorGUILayout.TextField(paramTypeValue); UnityEditor.EditorGUILayout.EndHorizontal(); } #endif }
public PersistedParameterInfo(string name, ParameterType parameterType, bool nullable, string defaultValue) { Name = name; ParameterType = parameterType; Nullable = nullable; DefaultValue = defaultValue; }
public Parameter(ParameterInfo parameterInfo, object value, ParameterType parameterType) { ParameterInfo = parameterInfo; ParameterValue = value; ParameterType = parameterType; Type = value.GetType(); }
public Parameter(string name, ParameterType type, string desc, int value = 0) { Name = name; ParameterType = type; Description = desc; Value = value; }
public ParameterSchema (ParameterSchema param) : base (param) { this.dataType = param.dataType; this.paramType = param.paramType; this.position = param.position; }
public Parameter(string name, ParameterType type, string minValue, string maxValue) { this.nameField = name; this.typeField = type; this.minValueField = minValue; this.maxValueField = maxValue; }
public ProcedureParameter(string name, ParameterType type, object value, int size) { Name = name; Type = type; Value = value; Size = size; }
public JConnect(IDbConnection connection) { this.connection = connection; commandTimeout = 30; Type type = connection.GetType(); if (type == typeof(System.Data.Odbc.OdbcConnection)) { typeOfParameter = ParameterType.QuestionMark; typeOfVendor = VendorType.Odbc; } else if (type == typeof(System.Data.OleDb.OleDbConnection)) { typeOfParameter = ParameterType.QuestionMark; typeOfVendor = VendorType.OleDb; } else if (type == typeof(System.Data.SqlClient.SqlConnection)) { typeOfParameter = ParameterType.AtSymbol; typeOfVendor = VendorType.SqlServer; GetReturningProc += new GetReturningHandler(SqlServerReturning); } else { typeOfParameter = ParameterType.Colon; typeOfVendor = VendorType.Oracle; GetReturningProc += new GetReturningHandler(OracleReturning); } GetTimeStampProc += new GetTimeStampHandler(DefaultGetTimeStampProc); }
public ProcedureParameter(string name, ParameterType type, ParameterDirection direction, object value) { Name = name; Type = type; Direction = direction; Value = value; }
private static Anito.Data.ParameterType GetParameterType(ParameterType parameterType) { switch (parameterType) { case ParameterType.Binary: return Anito.Data.ParameterType.Binary; case ParameterType.Boolean: return Anito.Data.ParameterType.Boolean; case ParameterType.Byte: return Anito.Data.ParameterType.Byte; case ParameterType.Currency: return Anito.Data.ParameterType.Currency; case ParameterType.DateTime: return Anito.Data.ParameterType.DateTime; case ParameterType.Decimal: return Anito.Data.ParameterType.Decimal; case ParameterType.Double: return Anito.Data.ParameterType.Double; case ParameterType.Int16: return Anito.Data.ParameterType.Int16; case ParameterType.Int32: return Anito.Data.ParameterType.Int32; case ParameterType.Int64: return Anito.Data.ParameterType.Int64; case ParameterType.Single: return Anito.Data.ParameterType.Single; case ParameterType.String: return Anito.Data.ParameterType.String; case ParameterType.UId: return Anito.Data.ParameterType.UId; default: return Anito.Data.ParameterType.String; } }
public ParameterControl(ArticleRecord article, ParameterType type, int batchNumber) : this() { Article = article; _parameterType = type; InitPropertiesByType(type); BatchNumber = batchNumber; NewMeasurementsDataGrid.ItemsSource = _batch; InitUpdateMeasuredValueTimer(); _inputDevice.DataReceived += inputDevice_DataReceived; _inputDevice.ErrorReceived += inputDevice_ErrorReceived; _bwloader.DoWork += bwloader_DoWork; _bwloader.RunWorkerCompleted += bwloader_RunWorkerCompleted; //MeasuringValueBG1.Minimum = MeasuringValueBG2.Minimum = _nominalValue; //MeasuringValueBG2.Maximum = _maxValue + 3; //_difference = _nominalValue - _minValue; //MeasuringValueBG1.Maximum = _nominalValue + _difference +3; MeasuringValueBG1.Minimum = MeasuringValueBG2.Minimum = _nominalValue; MeasuringValueBG2.Maximum = 14; _difference = _nominalValue - _minValue; MeasuringValueBG1.Maximum = 14; _bwloader.RunWorkerAsync(); }
/// <summary> /// Returns shared or built-in parameter of the specified name. parameter.IsShared property identifies the type. /// If it does not exist it is created in the shared parameters file with specified name in the specified group. That must be defined in advance /// using SetDefinitionFile() function. /// </summary> /// <param name="paramType">Type of the parameter (simplified to base data types)</param> /// <param name="groupName">Name of the group of the shared parameters</param> /// <param name="parameterName">Name of the parameter</param> /// <param name="group">Revit built in parameter group where the parameter is to be created if it doesn't exist</param> /// <returns>Existing or new parameter</returns> public static Parameter GetParameter(this Element element, ParameterType paramType, string parameterName, BuiltInParameterGroup group) { Parameter parameter = element.get_Parameter(parameterName); if (parameter != null) { //check type and throw error if the type is different if (parameter.Definition.ParameterType == paramType) return parameter; //returns existing parameter (it could be any type of parameter not only shared parameter) else throw new Exception(String.Format("Parameter type mismatch for pID '{0}': existing type: {1}, desired type {2}.", parameterName, parameter.Definition.ParameterType, paramType)); } // Create a category set and insert category of wall to it CategorySet myCategories = element.Document.Application.Create.NewCategorySet(); // Use BuiltInCategory to get category of wall Category myCategory = element.Category; myCategories.Insert(myCategory); bool success = SetNewSharedParameter(element, paramType, myCategories, parameterName, group); if (!success) { Debug.WriteLine("Parameter creation not successfull.\nParameter name: " + parameterName + "\n Existing parameters:"); foreach (Parameter par in element.Parameters) { Debug.WriteLine("Parameter name: " + par.Definition.Name + ", group: " + Enum.GetName(typeof(BuiltInParameterGroup), par.Definition.ParameterGroup)); } throw new Exception("Parameter creation failed."); } parameter = element.get_Parameter(parameterName); return parameter; }
internal WrongParameterTypeException(string parameterName, ParameterType oldParameterType, ParameterType newParameterType) { mParameterName = parameterName; mOldParameterType = oldParameterType; mNewParameterType = newParameterType; }
public ParameterDefinition(string name, ParameterType type, int min, int max) { this.name = name; this.type = type; this.min = min; this.max = max; }
public InvocationParameterInfo(string name, int index, Type type, ParameterType parameterType) { Name = name; Index = index; Type = type; ParameterType = parameterType; }
public ParameterDefinition(string name, Function defaultValue, int min, int max) { this.name = name; this.type = defaultValue.OutputParameter.type; this.defaultValue = defaultValue; this.min = min; this.max = max; }
public Parameter(string id, Object val, List<Object> possibleVal, Object defVal, ParameterType typ) { this.ID = id; this.value = val; this.possibleValues = possibleVal; this.defaultValue = defVal; this.paramType = typ; }
public SignatureParameter( string name, ParameterType type) : this() { this.Name = name; this.Type = type; }
public SerialCommand(string name, ParameterType type) { Initialize(); this.nameField = name; this.parameterTypeField = type; InitialDefault(); }
public Binding(PhpReference/*!*/ variable, IDataParameter/*!*/ parameter, ParameterType type) { Debug.Assert(variable != null && parameter != null && type != ParameterType.Invalid); this.Variable = variable; this.Parameter = parameter; this.Type = type; }
public SignatureParameter( string name, string holder, ParameterType type) : this(name, type) { this.Holder = holder; }
public InterceptedParameter(string name, int index, Type type, object value, ParameterType parametertype) { Name = name; Index = index; Type = type; Value = value; ParameterType = parametertype; }
public static IntegerParameter Create(ParameterType.Integer name, bool isRequired) { IntegerParameterDefinition definition = IntegerMap[name]; string nameString = Enum.GetName(typeof (ParameterType.Integer), name); string nameStringNotNull = Assertions.InternalValueIsNotNull(() => nameString, () => nameString); return new IntegerParameter(nameStringNotNull, definition.Id, definition.MinValue, definition.MaxValue, isRequired); }
/// <summary> /// Initializes a new instance of the <see cref="CommandLineOption"/> class. /// </summary> /// <param name="shortName"> Single character name of this parameter. Optional. </param> /// <param name="longName"> The long name of this parameter. Optional. </param> /// <param name="description"> Description of this parameter, to be used in the Usings function. </param> /// <param name="parameterType"> Type of parameter </param> /// <param name="setFunction"> Function to call when this parameter is found. Function parameter is found value </param> public CommandLineOption(char shortName, string longName, string description, ParameterType parameterType, SetOptionDelegate setFunction) { this.ShortName = shortName; this.LongName = longName; this.Description = description; this.ParameterType = parameterType; this.SetFunction = setFunction; this.IsOptional = true; }
public override bool Equals(ParameterType other) { var otherSimple = other as SimpleParameterType; if (otherSimple == null) return false; return this.Name == otherSimple.Name; }
/// <summary> /// Initializes a new instance of the <see cref="CommandLineOption"/> class. /// This constructor is used to create an unnamed parameter /// </summary> /// <param name="description"> Description of this parameter, to be used in the Usings function. </param> /// <param name="parameterType"> Type of parameter </param> /// <param name="setFunction"> Function to call when this parameter is found. Function parameter is found value </param> /// <param name="optional"> If false an exception will be thrown if this parameter can not be found. </param> public CommandLineOption(string description, ParameterType parameterType, SetOptionDelegate setFunction, bool optional = false) { this.ShortName = '\0'; this.LongName = null; this.Description = description; this.ParameterType = parameterType; this.SetFunction = setFunction; this.IsOptional = optional; }
public override bool Equals(ParameterType other) { var otherEnum = other as EnumParameterType; if (otherEnum == null) return false; return this.Values.SequenceEqual(otherEnum.Values); }
public static Parameter BuildParameter(string Name, object Value, ParameterType Type) { return new Parameter { Name = Name, Value = Value, Type = Type }; }
public override int GetHashCode() { int hashCode = ControllerName.ToUpperInvariant().GetHashCode() ^ ActionName.ToUpperInvariant().GetHashCode(); if (MediaType != null) { hashCode ^= MediaType.GetHashCode(); } if (SampleDirection != null) { hashCode ^= SampleDirection.GetHashCode(); } if (ParameterType != null) { hashCode ^= ParameterType.GetHashCode(); } foreach (string parameterName in ParameterNames) { hashCode ^= parameterName.ToUpperInvariant().GetHashCode(); } return(hashCode); }
public CommandBuilder Parameter(string name, ParameterType type = ParameterType.Required) { if (_areParamsClosed) { throw new Exception($"No parameters may be added after a {nameof(ParameterType.Multiple)} or {nameof(ParameterType.Unparsed)} parameter."); } if (!_allowRequiredParams && type == ParameterType.Required) { throw new Exception($"{nameof(ParameterType.Required)} parameters may not be added after an optional one"); } _params.Add(new CommandParameter(name, type)); if (type == ParameterType.Optional) { _allowRequiredParams = false; } if (type == ParameterType.Multiple || type == ParameterType.Unparsed) { _areParamsClosed = true; } return(this); }
private Parameter AddParameter( ElementDefinition elementDefinition, ParameterType parameterType, DomainOfExpertise owner, string value) { var parameter = new Parameter(Guid.NewGuid(), this.cache, null) { ParameterType = parameterType, Owner = owner, Scale = this.scale }; var valueSet = new ParameterValueSet(Guid.NewGuid(), this.cache, null) { Published = new ValueArray <string>(new List <string> { value }), Manual = new ValueArray <string>(new List <string> { value }), Computed = new ValueArray <string>(new List <string> { value }), Formula = new ValueArray <string>(new List <string> { value }), ValueSwitch = ParameterSwitchKind.MANUAL }; parameter.ValueSet.Add(valueSet); elementDefinition.Parameter.Add(parameter); return(parameter); }
public void Init() { var requestAttribute = ParameterType.CustomAttribute <HttpRequestAttribute>(true); if (null != requestAttribute) { UrlPattern = requestAttribute.Api; Method = requestAttribute.Method; Host = requestAttribute.Host; ParameterType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).ToList().ForEach(propertyInfo => { var propertyName = propertyInfo.Name; var getter = ResolveGetter(propertyInfo); Getters.AddOrUpdate(propertyName, getter, (k, v) => getter); var attribute = propertyInfo.CustomAttribute <HttpComponentAttribute>(true); if (null == attribute) { return; } var component = new HttpComponentInfo(propertyName, attribute, NamingRule); Components.AddOrUpdate(propertyName, component, (p, a) => component); }); } }
public Parameter(string name, object value, string contentType, ParameterType type) : this(name, value, type) => ContentType = contentType;
/// <summary> /// Adds a parameter to the request. There are four types of parameters: /// - GetOrPost: Either a QueryString value or encoded form value based on method /// - HttpHeader: Adds the name/value pair to the HTTP request's Headers collection /// - UrlSegment: Inserted into URL if there is a matching url token e.g. {AccountId} /// - RequestBody: Used by AddBody() (not recommended to use directly) /// </summary> /// <param name="restClient">The IRestClient instance</param> /// <param name="name">Name of the parameter</param> /// <param name="value">Value of the parameter</param> /// <param name="type">The type of parameter to add</param> /// <returns>This request</returns> public static void AddDefaultParameter(this IRestClient restClient, string name, object value, ParameterType type) { restClient.AddDefaultParameter(new Parameter { Name = name, Value = value, Type = type }); }
public FormatTagParameterTypeInfo(ParameterType type, bool canBeQuantifier) { Type = type; CanBeQuantifier = canBeQuantifier; }
/// <summary> /// Adds a parameter to the request. There are four types of parameters: /// - GetOrPost: Either a QueryString value or encoded form value based on method /// - HttpHeader: Adds the name/value pair to the HTTP request's Headers collection /// - UrlSegment: Inserted into URL if there is a matching url token e.g. {AccountId} /// - RequestBody: Used by AddBody() (not recommended to use directly) /// </summary> /// <param name="name">Name of the parameter</param> /// <param name="value">Value of the parameter</param> /// <param name="type">The type of parameter to add</param> /// <returns>This request</returns> public IRestRequest AddParameter(string name, object value, ParameterType type) { return(AddParameter(new Parameter { Name = name, Value = value, Type = type })); }
public Parameter(ParameterType type, String value) { mParameterType = type; mValue = value; }
private void ShowVarGUI(List <GVar> vars, List <ActionParameter> parameters, ParameterType parameterType) { // Create a string List of the field's names (for the PopUp box) List <string> labelList = new List <string>(); int i = 0; if (parameterID == -1) { variableNumber = -1; } if (vars.Count > 0) { foreach (GVar _var in vars) { labelList.Add(_var.label); // If a GlobalVar variable has been removed, make sure selected variable is still valid if (_var.id == variableID) { variableNumber = i; } i++; } if (variableNumber == -1 && (parameters == null || parameters.Count == 0 || parameterID == -1)) { // Wasn't found (variable was deleted?), so revert to zero Debug.LogWarning("Previously chosen variable no longer exists!"); variableNumber = 0; variableID = 0; } parameterID = Action.ChooseParameterGUI("Variable:", parameters, parameterID, parameterType); if (parameterID >= 0) { //variableNumber = 0; variableNumber = Mathf.Min(variableNumber, vars.Count - 1); variableID = -1; } else { variableNumber = EditorGUILayout.Popup("Variable:", variableNumber, labelList.ToArray()); variableID = vars [variableNumber].id; } string label = "Statement: "; if (vars [variableNumber].type == VariableType.Boolean) { setVarMethodIntBool = (SetVarMethodIntBool)EditorGUILayout.EnumPopup("New value is:", setVarMethodIntBool); label += "="; if (setVarMethodIntBool == SetVarMethodIntBool.EnteredHere) { setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.Boolean); if (setParameterID < 0) { boolValue = (BoolValue)EditorGUILayout.EnumPopup(label, boolValue); } } else if (setVarMethodIntBool == SetVarMethodIntBool.SetAsMecanimParameter) { ShowMecanimGUI(); } } if (vars [variableNumber].type == VariableType.PopUp) { label += "="; intValue = EditorGUILayout.Popup(label, intValue, vars[variableNumber].popUps); } else if (vars [variableNumber].type == VariableType.Integer) { setVarMethodIntBool = (SetVarMethodIntBool)EditorGUILayout.EnumPopup("New value is:", setVarMethodIntBool); if (setVarMethodIntBool == SetVarMethodIntBool.EnteredHere) { setVarMethod = (SetVarMethod)EditorGUILayout.EnumPopup("Method:", setVarMethod); if (setVarMethod == SetVarMethod.Formula) { label += "="; setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.String); if (setParameterID < 0) { formula = EditorGUILayout.TextField(label, formula); } #if UNITY_WP8 EditorGUILayout.HelpBox("This feature is not available for Windows Phone 8.", MessageType.Warning); #endif } else { if (setVarMethod == SetVarMethod.IncreaseByValue) { label += "+="; } else if (setVarMethod == SetVarMethod.SetValue) { label += "="; } else if (setVarMethod == SetVarMethod.SetAsRandom) { label += ("= 0 to"); } setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.Integer); if (setParameterID < 0) { intValue = EditorGUILayout.IntField(label, intValue); if (setVarMethod == SetVarMethod.SetAsRandom && intValue < 0) { intValue = 0; } } } } else if (setVarMethodIntBool == SetVarMethodIntBool.SetAsMecanimParameter) { ShowMecanimGUI(); } } else if (vars [variableNumber].type == VariableType.Float) { setVarMethodIntBool = (SetVarMethodIntBool)EditorGUILayout.EnumPopup("New value is:", setVarMethodIntBool); if (setVarMethodIntBool == SetVarMethodIntBool.EnteredHere) { setVarMethod = (SetVarMethod)EditorGUILayout.EnumPopup("Method:", setVarMethod); if (setVarMethod == SetVarMethod.Formula) { label += "="; setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.String); if (setParameterID < 0) { formula = EditorGUILayout.TextField(label, formula); } #if UNITY_WP8 EditorGUILayout.HelpBox("This feature is not available for Windows Phone 8.", MessageType.Warning); #endif } else { if (setVarMethod == SetVarMethod.IncreaseByValue) { label += "+="; } else if (setVarMethod == SetVarMethod.SetValue) { label += "="; } else if (setVarMethod == SetVarMethod.SetAsRandom) { label += "= 0 to"; } setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.Float); if (setParameterID < 0) { floatValue = EditorGUILayout.FloatField(label, floatValue); if (setVarMethod == SetVarMethod.SetAsRandom && floatValue < 0f) { floatValue = 0f; } } } } else if (setVarMethodIntBool == SetVarMethodIntBool.SetAsMecanimParameter) { ShowMecanimGUI(); } } else if (vars [variableNumber].type == VariableType.String) { setVarMethodString = (SetVarMethodString)EditorGUILayout.EnumPopup("New value is:", setVarMethodString); label += "="; if (setVarMethodString == SetVarMethodString.EnteredHere) { setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.String); if (setParameterID < 0) { stringValue = EditorGUILayout.TextField(label, stringValue); } } else if (setVarMethodString == SetVarMethodString.SetAsMenuElementText) { menuName = EditorGUILayout.TextField("Menu name:", menuName); elementName = EditorGUILayout.TextField("Element name:", elementName); slotNumberParameterID = Action.ChooseParameterGUI("Slot # (optional):", parameters, slotNumberParameterID, ParameterType.Integer); if (slotNumberParameterID < 0) { slotNumber = EditorGUILayout.IntField("Slot # (optional):", slotNumber); } } } AfterRunningOption(); } else { EditorGUILayout.HelpBox("No variables exist!", MessageType.Info); variableID = -1; variableNumber = -1; } }
public Command(string name, Action <State> action) { Name = name; Action = (state, param) => action(state); Parameter = ParameterType.None; }
/// <summary> /// Adds a default parameter to the request. There are four types of parameters: /// - GetOrPost: Either a QueryString value or encoded form value based on method /// - HttpHeader: Adds the name/value pair to the HTTP request's Headers collection /// - UrlSegment: Inserted into URL if there is a matching url token e.g. {AccountId} /// - RequestBody: Used by AddBody() (not recommended to use directly) /// Used on every request made by this client instance /// </summary> /// <param name="restClient">The IRestClient instance</param> /// <param name="name">Name of the parameter</param> /// <param name="value">Value of the parameter</param> /// <param name="type">The type of parameter to add</param> /// <returns>This request</returns> public static IRestClient AddDefaultParameter(this IRestClient restClient, string name, object value, ParameterType type) => restClient.AddDefaultParameter(new Parameter(name, value, type));
private static (string err, List <ParamInfo> @params) CheckMethodAssign(MethodInfo minfo, Nancy.Rest.Annotations.Atributes.Rest attribute) { List <ParamInfo> parms = new List <ParamInfo>(); MatchCollection collection = rpath.Matches(attribute.Route); foreach (Match m in collection) { if (m.Success) { string value = m.Groups[1].Value; bool optional = false; string constraint = null; int idx = value.LastIndexOf("?", StringComparison.InvariantCulture); if (idx > 0) { value = value.Substring(0, idx); optional = true; } idx = value.LastIndexOf(':'); if (idx >= 0) { constraint = value.Substring(idx + 1); value = value.Substring(0, idx); idx = constraint.LastIndexOf("(", StringComparison.InvariantCulture); if (idx > 0) { constraint = constraint.Substring(0, idx); } } ParamInfo info = new ParamInfo(); info.Name = value; info.Optional = optional; if (constraint != null) { ParameterType ptype = ParameterType.InstanceTypes.FirstOrDefault(a => a.Name == constraint); if (ptype == null) { return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' has an unknown constraint '" + constraint + "'", null); } info.Constraint = ptype; } parms.Add(info); } } List <ParameterInfo> infos = minfo.GetParameters().ToList(); foreach (ParamInfo p in parms) { ParameterInfo pinf = infos.FirstOrDefault(a => a.Name == p.Name); if (pinf == null) { return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' has an unknown variable in the route path '" + p.Name + "'", null); } if (p.Optional && !pinf.ParameterType.IsNullable()) { return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' with variable '" + p.Name + "' is marked in the route path as nullable, but the method variable is not", null); } if (p.Constraint != null && !p.Constraint.Types.Contains(pinf.ParameterType)) { return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' with variable '" + p.Name + "' is constrained to type " + p.Constraint.BaseType + " but the method variable is not of the same type", null); } if (!pinf.ParameterType.IsRouteable()) { return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' the variable '" + p.Name + "' is not a value type and is the route path", null); } infos.Remove(pinf); } if (infos.Count > 0 && attribute.Verb == Verbs.Get) { return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' has post variables in a GET operation", null); } if (infos.Count > 1) { return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' has more than one Body object", null); } return(null, parms); }
public CommandParameter(string name, ParameterType type) { Name = name; Type = type; }
/// <summary> /// Initializes a new instance of the <see cref="T:GenericDbParameter" /> class. /// </summary> /// <param name="type">The type of the parameter.</param> /// <param name="name">The name of the parameter.</param> /// <param name="value">The value of the parameter.</param> public Parameter(ParameterType type, string name, object value) { this.type = type; this.name = name; this.value = value; }
public NotSupportedParameterException(ParameterType parameterType, string language) : base(parameterType.GetDisplayName() + " not supported in " + language) { }
/// <summary> /// Tries the get the ParameterType value for the given UnitType value. /// </summary> /// <param name="unitType">The unit type.</param> /// <param name="parameterType">The resulting ParameterType value.</param> /// <returns></returns> public static bool TryGetParameterType(this UnitType unitType, out ParameterType parameterType) { return(parameterTypes.TryGetValue(unitType, out parameterType)); }
/// <summary> /// Adds a <see cref="ParameterTypeRowViewModel"/> /// </summary> /// <param name="parameterType"> /// The associated <see cref="ParameterType"/> for which the row is to be added. /// </param> private void AddParameterTypeRowViewModel(ParameterType parameterType) { var row = new ParameterTypeRowViewModel(parameterType, this.Session, this); this.ParameterTypes.Add(row); }
/// <summary> /// Initializes a new instance of the <see cref="CustomParameter"/> class. /// </summary> /// <param name="name">The name of the parameter</param> /// <param name="value">The value of the parameter. The caller is responsible for ensuring the value and type contains the correct capitalization and is formatted corectly when converted <see cref="ToString"/>.</param> public CustomParameter(string name, object value) { Name = name; Value = value; ParameterType = ParameterType.SingleValue; }
/// <inheritdoc/> public bool Remove(ParameterType type, string name) { var key = new ParameterKey(type, name); return(_dictionary.Remove(key)); }
/// <summary> /// Initializes a new instance of the <see cref="CustomParameter"/> class with a specified parameter type. /// </summary> /// <param name="name">The name of the parameter</param> /// <param name="value">The value of the parameter. The caller is responsible for ensuring the value and type contains the correct capitalization and is formatted corectly when converted <see cref="ToString"/>.</param> /// <param name="parameterType">How the <paramref name="value"/> should be formatted if it contains a string.</param> public CustomParameter(string name, object value, ParameterType parameterType) { Name = name; Value = value; ParameterType = parameterType; }
public Document settingParamenters(string eleName, string eleXPath, string elefName, Document Revit_Doc) { //MessageBox.Show(elefName); //根据名称在工程文件中查找出对应族 FilteredElementCollector allElements = new FilteredElementCollector(Revit_Doc); ElementClassFilter familyFilter = new ElementClassFilter(typeof(Family)); allElements = allElements.WherePasses(familyFilter); var filterFamilyList = from f in allElements where f.Name.ToString() == elefName select f as Family; //MessageBox.Show(filterFamilyList.ToList<Family>()[0].ToString()); //allElements = new FilteredElementCollector(Revit_Doc); //ElementClassFilter familySymbolFilter = new ElementClassFilter(typeof(FamilySymbol)); //allElements = allElements.WherePasses(familySymbolFilter); //var filterList = from f in allElements // where f.Name.ToString() == eleName && (f as FamilySymbol).Family.ToString() == elefName // select (f as FamilySymbol).Family ; //Family filtedFamily = filterList.ToList<Family>().FirstOrDefault(); ////if (filterList != null) ////{ MessageBox.Show(filterList.ToList<Family>()[0].ToString()); } Family filtedFamily = filterFamilyList.ToList <Family>().FirstOrDefault();; MessageBox.Show(filtedFamily.Name.ToString()); //--------------------------------------------------- //MessageBox.Show(eleName); //if (filtedFamily == null) //{ MessageBox.Show("filtedFamily is null!!"); } //--------------------------------------------------- // Document familyDoc = Revit_Doc.EditFamily(filtedFamily); if (null != familyDoc && familyDoc.IsFamilyDocument == true) { DataTable xdte = new DataTable(); //读取xls文件 ExcelHelper ExcelHelper = new ExcelHelper(); DataTable xdt = ExcelHelper.Reading_Excel_Information(eleXPath); //获取参数集 FamilyParameterSet rfadocParas = familyDoc.FamilyManager.Parameters; List <string> rfadocParasListName = new List <string>(); foreach (FamilyParameter rfadocPara in rfadocParas) { rfadocParasListName.Add(rfadocPara.Definition.Name); } FamilyManager familyMgr = familyDoc.FamilyManager; if (clearsymbol == true) { //清空族内所有类型 仅保留默认族类型 int typesizes = familyMgr.Types.Size; if (familyMgr.Types.Size > 1 && familyMgr.Types.Size != 0) { for (int typenumber = 0; typenumber < typesizes - 1; typenumber++) { if (familyMgr.CurrentType != null) { Transaction DeleteType = new Transaction(familyDoc, "DeleteType"); DeleteType.Start(); familyMgr.DeleteCurrentType(); DeleteType.Commit(); } } } } if (clearpara == true) { //清空族内所有参数条目 foreach (FamilyParameter fp in familyMgr.Parameters) { if (fp.Definition.ParameterGroup == BuiltInParameterGroup.PG_ELECTRICAL) { Transaction RemoveParameter = new Transaction(familyDoc, "RemoveParameter"); RemoveParameter.Start(); familyMgr.RemoveParameter(fp); RemoveParameter.Commit(); } } } //开始添加 Transaction addParameter = new Transaction(familyDoc, "AddParameters"); addParameter.Start(); string paraname = null; BuiltInParameterGroup paragroup = BuiltInParameterGroup.PG_ELECTRICAL;; ParameterType paraType = ParameterType.Text;; bool isInstance = false; string paravalue = null; List <string> distinctparanames = new List <string>(); //判断xls表中与原有rfa文件内重复的条目 放入distinctparanames列表 for (int i = 0; i < xdt.Rows.Count; i++) { foreach (FamilyParameter fp in familyMgr.Parameters) { if (fp.Definition.Name == xdt.Rows[i]["paraname"].ToString()) { distinctparanames.Add(fp.Definition.Name); MessageBox.Show(fp.Definition.Name); } } } //遍历xls添加属性条目 for (int i = 0; i < xdt.Rows.Count; i++) { //获取表中条目名称判断是否重复 重复则继续下一次循环 paraname = xdt.Rows[i]["paraname"].ToString(); foreach (string disstr in distinctparanames) { if (disstr == paraname) { continue; } } //通过的条目名称 if (xdt.Rows[i]["paragroup"] == null) { paragroup = BuiltInParameterGroup.PG_ELECTRICAL; } else { #region 参数分组对照 用于RevitAPI2016A switch (xdt.Rows[i]["paragroup"].ToString()) { case "PG_RELEASES_MEMBER_FORCES": paragroup = BuiltInParameterGroup.PG_RELEASES_MEMBER_FORCES; break; case "PG_SECONDARY_END": paragroup = BuiltInParameterGroup.PG_SECONDARY_END; break; case "PG_PRIMARY_END": paragroup = BuiltInParameterGroup.PG_PRIMARY_END; break; case "PG_MOMENTS": paragroup = BuiltInParameterGroup.PG_MOMENTS; break; case "PG_FORCES": paragroup = BuiltInParameterGroup.PG_FORCES; break; case "PG_FABRICATION_PRODUCT_DATA": paragroup = BuiltInParameterGroup.PG_GEOMETRY_POSITIONING; break; case "PG_REFERENCE": paragroup = BuiltInParameterGroup.PG_REFERENCE; break; case "PG_GEOMETRY_POSITIONING": paragroup = BuiltInParameterGroup.PG_GEOMETRY_POSITIONING; break; case "PG_DIVISION_GEOMETRY": paragroup = BuiltInParameterGroup.PG_DIVISION_GEOMETRY; break; case "PG_SEGMENTS_FITTINGS": paragroup = BuiltInParameterGroup.PG_SEGMENTS_FITTINGS; break; case "PG_CONTINUOUSRAIL_END_TOP_EXTENSION": paragroup = BuiltInParameterGroup.PG_CONTINUOUSRAIL_END_TOP_EXTENSION; break; case "PG_CONTINUOUSRAIL_BEGIN_BOTTOM_EXTENSION": paragroup = BuiltInParameterGroup.PG_CONTINUOUSRAIL_BEGIN_BOTTOM_EXTENSION; break; case "PG_STAIRS_WINDERS": paragroup = BuiltInParameterGroup.PG_STAIRS_WINDERS; break; case "PG_STAIRS_SUPPORTS": paragroup = BuiltInParameterGroup.PG_STAIRS_SUPPORTS; break; case "PG_STAIRS_OPEN_END_CONNECTION": paragroup = BuiltInParameterGroup.PG_STAIRS_OPEN_END_CONNECTION; break; case "PG_RAILING_SYSTEM_SECONDARY_FAMILY_HANDRAILS": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_SECONDARY_FAMILY_HANDRAILS; break; case "PG_TERMINTATION": paragroup = BuiltInParameterGroup.PG_TERMINTATION; break; case "PG_STAIRS_TREADS_RISERS": paragroup = BuiltInParameterGroup.PG_STAIRS_TREADS_RISERS; break; case "PG_STAIRS_CALCULATOR_RULES": paragroup = BuiltInParameterGroup.PG_STAIRS_CALCULATOR_RULES; break; case "PG_SPLIT_PROFILE_DIMENSIONS": paragroup = BuiltInParameterGroup.PG_SPLIT_PROFILE_DIMENSIONS; break; case "PG_LENGTH": paragroup = BuiltInParameterGroup.PG_LENGTH; break; case "PG_NODES": paragroup = BuiltInParameterGroup.PG_NODES; break; case "PG_ANALYTICAL_PROPERTIES": paragroup = BuiltInParameterGroup.PG_ANALYTICAL_PROPERTIES; break; case "PG_ANALYTICAL_ALIGNMENT": paragroup = BuiltInParameterGroup.PG_ANALYTICAL_ALIGNMENT; break; case "PG_SYSTEMTYPE_RISEDROP": paragroup = BuiltInParameterGroup.PG_SYSTEMTYPE_RISEDROP; break; case "PG_LINING": paragroup = BuiltInParameterGroup.PG_LINING; break; case "PG_INSULATION": paragroup = BuiltInParameterGroup.PG_INSULATION; break; case "PG_OVERALL_LEGEND": paragroup = BuiltInParameterGroup.PG_OVERALL_LEGEND; break; case "PG_VISIBILITY": paragroup = BuiltInParameterGroup.PG_VISIBILITY; break; case "PG_SUPPORT": paragroup = BuiltInParameterGroup.PG_SUPPORT; break; case "PG_RAILING_SYSTEM_SEGMENT_V_GRID": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_SEGMENT_V_GRID; break; case "PG_RAILING_SYSTEM_SEGMENT_U_GRID": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_SEGMENT_U_GRID; break; case "PG_RAILING_SYSTEM_SEGMENT_POSTS": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_SEGMENT_POSTS; break; case "PG_RAILING_SYSTEM_SEGMENT_PATTERN_REMAINDER": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_SEGMENT_PATTERN_REMAINDER; break; case "PG_RAILING_SYSTEM_SEGMENT_PATTERN_REPEAT": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_SEGMENT_PATTERN_REPEAT; break; case "PG_RAILING_SYSTEM_FAMILY_SEGMENT_PATTERN": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_FAMILY_SEGMENT_PATTERN; break; case "PG_RAILING_SYSTEM_FAMILY_HANDRAILS": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_FAMILY_HANDRAILS; break; case "PG_RAILING_SYSTEM_FAMILY_TOP_RAIL": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_FAMILY_TOP_RAIL; break; case "PG_CONCEPTUAL_ENERGY_DATA_BUILDING_SERVICES": paragroup = BuiltInParameterGroup.PG_CONCEPTUAL_ENERGY_DATA_BUILDING_SERVICES; break; case "PG_DATA": paragroup = BuiltInParameterGroup.PG_DATA; break; case "PG_ELECTRICAL_CIRCUITING": paragroup = BuiltInParameterGroup.PG_ELECTRICAL_CIRCUITING; break; case "PG_GENERAL": paragroup = BuiltInParameterGroup.PG_GENERAL; break; case "PG_FLEXIBLE": paragroup = BuiltInParameterGroup.PG_FLEXIBLE; break; case "PG_ENERGY_ANALYSIS_CONCEPTUAL_MODEL": paragroup = BuiltInParameterGroup.PG_ENERGY_ANALYSIS_CONCEPTUAL_MODEL; break; case "PG_ENERGY_ANALYSIS_DETAILED_MODEL": paragroup = BuiltInParameterGroup.PG_ENERGY_ANALYSIS_DETAILED_MODEL; break; case "PG_ENERGY_ANALYSIS_DETAILED_AND_CONCEPTUAL_MODELS": paragroup = BuiltInParameterGroup.PG_ENERGY_ANALYSIS_DETAILED_AND_CONCEPTUAL_MODELS; break; case "PG_FITTING": paragroup = BuiltInParameterGroup.PG_FITTING; break; case "PG_CONCEPTUAL_ENERGY_DATA": paragroup = BuiltInParameterGroup.PG_CONCEPTUAL_ENERGY_DATA; break; case "PG_AREA": paragroup = BuiltInParameterGroup.PG_AREA; break; case "PG_ADSK_MODEL_PROPERTIES": paragroup = BuiltInParameterGroup.PG_ADSK_MODEL_PROPERTIES; break; case "PG_CURTAIN_GRID_V": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID_V; break; case "PG_CURTAIN_GRID_U": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID_U; break; case "PG_DISPLAY": paragroup = BuiltInParameterGroup.PG_DISPLAY; break; case "PG_ANALYSIS_RESULTS": paragroup = BuiltInParameterGroup.PG_ANALYSIS_RESULTS; break; case "PG_SLAB_SHAPE_EDIT": paragroup = BuiltInParameterGroup.PG_SLAB_SHAPE_EDIT; break; case "PG_LIGHT_PHOTOMETRICS": paragroup = BuiltInParameterGroup.PG_LIGHT_PHOTOMETRICS; break; case "PG_PATTERN_APPLICATION": paragroup = BuiltInParameterGroup.PG_PATTERN_APPLICATION; break; case "PG_GREEN_BUILDING": paragroup = BuiltInParameterGroup.PG_GREEN_BUILDING; break; case "PG_PROFILE_2": paragroup = BuiltInParameterGroup.PG_PROFILE_2; break; case "PG_PROFILE_1": paragroup = BuiltInParameterGroup.PG_PROFILE_1; break; case "PG_PROFILE": paragroup = BuiltInParameterGroup.PG_PROFILE; break; case "PG_TRUSS_FAMILY_BOTTOM_CHORD": paragroup = BuiltInParameterGroup.PG_TRUSS_FAMILY_BOTTOM_CHORD; break; case "PG_TRUSS_FAMILY_TOP_CHORD": paragroup = BuiltInParameterGroup.PG_TRUSS_FAMILY_TOP_CHORD; break; case "PG_TRUSS_FAMILY_DIAG_WEB": paragroup = BuiltInParameterGroup.PG_TRUSS_FAMILY_DIAG_WEB; break; case "PG_TRUSS_FAMILY_VERT_WEB": paragroup = BuiltInParameterGroup.PG_TRUSS_FAMILY_VERT_WEB; break; case "PG_TITLE": paragroup = BuiltInParameterGroup.PG_TITLE; break; case "PG_FIRE_PROTECTION": paragroup = BuiltInParameterGroup.PG_FIRE_PROTECTION; break; case "PG_ROTATION_ABOUT": paragroup = BuiltInParameterGroup.PG_ROTATION_ABOUT; break; case "PG_TRANSLATION_IN": paragroup = BuiltInParameterGroup.PG_TRANSLATION_IN; break; case "PG_ANALYTICAL_MODEL": paragroup = BuiltInParameterGroup.PG_ANALYTICAL_MODEL; break; case "PG_REBAR_ARRAY": paragroup = BuiltInParameterGroup.PG_REBAR_ARRAY; break; case "PG_REBAR_SYSTEM_LAYERS": paragroup = BuiltInParameterGroup.PG_REBAR_SYSTEM_LAYERS; break; case "PG_CURTAIN_GRID": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID; break; case "PG_CURTAIN_MULLION_2": paragroup = BuiltInParameterGroup.PG_CURTAIN_MULLION_2; break; case "PG_CURTAIN_MULLION_HORIZ": paragroup = BuiltInParameterGroup.PG_CURTAIN_MULLION_HORIZ; break; case "PG_CURTAIN_MULLION_1": paragroup = BuiltInParameterGroup.PG_CURTAIN_MULLION_1; break; case "PG_CURTAIN_MULLION_VERT": paragroup = BuiltInParameterGroup.PG_CURTAIN_MULLION_VERT; break; case "PG_CURTAIN_GRID_2": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID_2; break; case "PG_CURTAIN_GRID_HORIZ": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID_HORIZ; break; case "PG_CURTAIN_GRID_1": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID_1; break; case "PG_CURTAIN_GRID_VERT": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID_VERT; break; case "PG_IFC": paragroup = BuiltInParameterGroup.PG_IFC; break; case "PG_AELECTRICAL": paragroup = BuiltInParameterGroup.PG_AELECTRICAL; break; case "PG_ENERGY_ANALYSIS": paragroup = BuiltInParameterGroup.PG_ENERGY_ANALYSIS; break; case "PG_STRUCTURAL_ANALYSIS": paragroup = BuiltInParameterGroup.PG_STRUCTURAL_ANALYSIS; break; case "PG_MECHANICAL_AIRFLOW": paragroup = BuiltInParameterGroup.PG_MECHANICAL_AIRFLOW; break; case "PG_MECHANICAL_LOADS": paragroup = BuiltInParameterGroup.PG_MECHANICAL_LOADS; break; case "PG_ELECTRICAL_LOADS": paragroup = BuiltInParameterGroup.PG_ELECTRICAL_LOADS; break; case "PG_ELECTRICAL_LIGHTING": paragroup = BuiltInParameterGroup.PG_ELECTRICAL_LIGHTING; break; case "PG_TEXT": paragroup = BuiltInParameterGroup.PG_TEXT; break; case "PG_VIEW_CAMERA": paragroup = BuiltInParameterGroup.PG_VIEW_CAMERA; break; case "PG_VIEW_EXTENTS": paragroup = BuiltInParameterGroup.PG_VIEW_EXTENTS; break; case "PG_PATTERN": paragroup = BuiltInParameterGroup.PG_PATTERN; break; case "PG_CONSTRAINTS": paragroup = BuiltInParameterGroup.PG_CONSTRAINTS; break; case "PG_PHASING": paragroup = BuiltInParameterGroup.PG_PHASING; break; case "PG_MECHANICAL": paragroup = BuiltInParameterGroup.PG_MECHANICAL; break; case "PG_STRUCTURAL": paragroup = BuiltInParameterGroup.PG_STRUCTURAL; break; case "PG_PLUMBING": paragroup = BuiltInParameterGroup.PG_PLUMBING; break; case "PG_ELECTRICAL": paragroup = BuiltInParameterGroup.PG_ELECTRICAL; break; case "PG_STAIR_STRINGERS": paragroup = BuiltInParameterGroup.PG_STAIR_STRINGERS; break; case "PG_STAIR_RISERS": paragroup = BuiltInParameterGroup.PG_STAIR_RISERS; break; case "PG_STAIR_TREADS": paragroup = BuiltInParameterGroup.PG_STAIR_TREADS; break; case "PG_MATERIALS": paragroup = BuiltInParameterGroup.PG_MATERIALS; break; case "PG_GRAPHICS": paragroup = BuiltInParameterGroup.PG_GRAPHICS; break; case "PG_CONSTRUCTION": paragroup = BuiltInParameterGroup.PG_CONSTRUCTION; break; case "PG_GEOMETRY": paragroup = BuiltInParameterGroup.PG_GEOMETRY; break; case "PG_IDENTITY_DATA": paragroup = BuiltInParameterGroup.PG_IDENTITY_DATA; break; case "INVALID": paragroup = BuiltInParameterGroup.INVALID; break; } #endregion } if (xdt.Rows[i]["paratype"] == null) { paraType = ParameterType.Text; } else { #region 参数类型对照 用于RevitAPI2016 switch (xdt.Rows[i]["paratype"].ToString()) { case "Text": paraType = ParameterType.Text; break; //case "Invalid": paraType = ParameterType.Invalid; break; //case "Integer": paraType = ParameterType.Integer; break; //case "Number": paraType = ParameterType.Number; break; //case "Length": paraType = ParameterType.Length; break; //case "Volume": paraType = ParameterType.Volume; break; //case "Area": paraType = ParameterType.Area; break; //case "Angle": paraType = ParameterType.Angle; break; //case "URL": paraType = ParameterType.URL; break; //case "Material": paraType = ParameterType.Material; break; //case "YesNo": paraType = ParameterType.YesNo; break; //case "Force": paraType = ParameterType.Force; break; //case "NumberOfPoles": paraType = ParameterType.NumberOfPoles; break; //case "AreaForce": paraType = ParameterType.AreaForce; break; //case "Moment": paraType = ParameterType.Moment; break; //case "FixtureUnit": paraType = ParameterType.FixtureUnit; break; //case "FamilyType": paraType = ParameterType.FamilyType; break; //case "LoadClassification": paraType = ParameterType.LoadClassification; break; //case "Image": paraType = ParameterType.Image; break; //case "HVACDensity": paraType = ParameterType.HVACDensity; break; //case "HVACEnergy": paraType = ParameterType.HVACEnergy; break; //case "HVACFriction": paraType = ParameterType.HVACFriction; break; //case "HVACPower": paraType = ParameterType.HVACPower; break; //case "HVACPowerDensity": paraType = ParameterType.HVACPowerDensity; break; //case "HVACPressure": paraType = ParameterType.HVACPressure; break; //case "HVACTemperature": paraType = ParameterType.HVACTemperature; break; //case "HVACVelocity": paraType = ParameterType.HVACVelocity; break; //case "HVACAirflow": paraType = ParameterType.HVACAirflow; break; //case "HVACDuctSize": paraType = ParameterType.HVACDuctSize; break; //case "HVACCrossSection": paraType = ParameterType.HVACCrossSection; break; //case "HVACHeatGain": paraType = ParameterType.HVACHeatGain; break; //case "ElectricalCurrent": paraType = ParameterType.ElectricalCurrent; break; //case "ElectricalPotential": paraType = ParameterType.ElectricalPotential; break; //case "ElectricalFrequency": paraType = ParameterType.ElectricalFrequency; break; //case "ElectricalIlluminance": paraType = ParameterType.ElectricalIlluminance; break; //case "ElectricalLuminousFlux": paraType = ParameterType.ElectricalLuminousFlux; break; //case "ElectricalPower": paraType = ParameterType.ElectricalPower; break; //case "HVACRoughness": paraType = ParameterType.HVACRoughness; break; //case "ElectricalApparentPower": paraType = ParameterType.ElectricalApparentPower; break; //case "ElectricalPowerDensity": paraType = ParameterType.ElectricalPowerDensity; break; //case "PipingDensity": paraType = ParameterType.PipingDensity; break; //case "PipingFlow": paraType = ParameterType.PipingFlow; break; //case "PipingFriction": paraType = ParameterType.PipingFriction; break; //case "PipingPressure": paraType = ParameterType.PipingPressure; break; //case "PipingTemperature": paraType = ParameterType.PipingTemperature; break; //case "PipingVelocity": paraType = ParameterType.PipingVelocity; break; //case "PipingViscosity": paraType = ParameterType.PipingViscosity; break; //case "PipeSize": paraType = ParameterType.PipeSize; break; //case "PipingRoughness": paraType = ParameterType.PipingRoughness; break; //case "Stress": paraType = ParameterType.Stress; break; //case "UnitWeight": paraType = ParameterType.UnitWeight; break; //case "ThermalExpansion": paraType = ParameterType.ThermalExpansion; break; //case "LinearMoment": paraType = ParameterType.LinearMoment; break; //case "ForcePerLength": paraType = ParameterType.ForcePerLength; break; //case "ForceLengthPerAngle": paraType = ParameterType.ForceLengthPerAngle; break; //case "LinearForcePerLength": paraType = ParameterType.LinearForcePerLength; break; //case "LinearForceLengthPerAngle": paraType = ParameterType.LinearForceLengthPerAngle; break; //case "AreaForcePerLength": paraType = ParameterType.AreaForcePerLength; break; //case "PipingVolume": paraType = ParameterType.PipingVolume; break; //case "HVACViscosity": paraType = ParameterType.HVACViscosity; break; //case "HVACCoefficientOfHeatTransfer": paraType = ParameterType.HVACCoefficientOfHeatTransfer; break; //case "HVACAirflowDensity": paraType = ParameterType.HVACAirflowDensity; break; //case "Slope": paraType = ParameterType.Slope; break; //case "HVACCoolingLoad": paraType = ParameterType.HVACCoolingLoad; break; //case "HVACCoolingLoadDividedByArea": paraType = ParameterType.HVACCoolingLoadDividedByArea; break; //case "HVACCoolingLoadDividedByVolume": paraType = ParameterType.HVACCoolingLoadDividedByVolume; break; //case "HVACHeatingLoad": paraType = ParameterType.HVACHeatingLoad; break; //case "HVACHeatingLoadDividedByArea": paraType = ParameterType.HVACHeatingLoadDividedByArea; break; //case "Weight": paraType = ParameterType.Weight; break; } #endregion } if (xdt.Rows[i]["paratag"].ToString() == "是") { isInstance = true; } else if (xdt.Rows[i]["paratag"].ToString() == "否") { isInstance = false; } if (xdt.Rows[i]["paravalue"].ToString() == null) { paravalue = "NA"; } else { paravalue = xdt.Rows[i]["paravalue"].ToString(); } //bool checkDistinct = false; //foreach (FamilyParameter fp in familyMgr.Parameters) //{ // if (fp.Definition.Name == xdt.Rows[i]["paraname"].ToString()) // { // checkDistinct = true; // } //} //if (checkDistinct == true) //{ // continue; //} //else //{ try { FamilyParameter newParameter = familyMgr.AddParameter(paraname, paragroup, paraType, isInstance); } catch (Exception efec) { MessageBox.Show(efec.ToString()); continue; } //创建族参数(每个参数两秒) //familyMgr.Set(newParameter, paravalue); //} } try { for (int i = 0; i < xdt.Rows.Count; i++) { paraname = xdt.Rows[i]["paraname"].ToString(); foreach (FamilyParameter fp in familyMgr.Parameters) { StorageType fst = fp.StorageType; if (fp.Definition.Name == xdt.Rows[i]["paraname"].ToString()) { if (xdt.Rows[i]["paravalue"].ToString() == null && fst.ToString() == "String") { paravalue = "NA"; familyMgr.Set(fp, paravalue); } else { //paravalue = xdt.Rows[i]["paravalue"].ToString(); #region switch (fst.ToString()) { case "Integer": int paravint = Convert.ToInt32(xdt.Rows[i]["paravalue"].ToString()); familyMgr.Set(fp, paravint);; break; case "Double": double paravdouble = Convert.ToDouble(xdt.Rows[i]["paravalue"].ToString()); familyMgr.Set(fp, paravdouble); break; case "String": string paravstring = xdt.Rows[i]["paravalue"].ToString(); familyMgr.Set(fp, paravstring); break; case "ElementId": ElementId paravid = new ElementId(Convert.ToInt32(xdt.Rows[i]["paravalue"].ToString())); familyMgr.Set(fp, paravid); break; case "None": break; } #endregion } } } } } catch (Exception eeef) { /*MessageBox.Show(eeef.ToString());*/ } SaveOptions opt = new SaveOptions(); addParameter.Commit(); } return(familyDoc); }
/// <summary> /// Add Parameter /// </summary> /// <param name="name">Parameter Name</param> /// <param name="label">Parameter Label</param> /// <param name="maxLength">Maximum Length</param> /// <param name="required">Set if value in the parameter required when added/apdated</param> /// <param name="keyfield">Mark field as primary key, unique and required</param> /// <param name="parType">Parameter type (integer, string, boolean etc.)</param> public void AddParameter(string name, string label, int maxLength, bool required, bool keyfield, ParameterType parType) { if (_params == null) { _params = new List <ExtensionParameter>(); } ExtensionParameter par = new ExtensionParameter(name); par.Label = label; par.MaxLength = maxLength; par.Required = required; par.KeyField = keyfield; par.ParamType = parType; _params.Add(par); }
/// <summary> /// Initializes a new instance of the <see cref="Parameter"/> class. /// Constructor /// </summary> /// <param name="parameterName"> /// Name of parameter /// </param> /// <param name="parameterState"> /// State of parameter /// </param> /// <param name="parameterValue"> /// Value of parameter /// </param> /// <param name="parameterUnit"> /// Unit of parameter /// </param> /// <param name="parameterType"> /// Type of parameter /// </param> public Parameter(string parameterName, ParameterState parameterState, string parameterValue, string parameterUnit, ParameterType parameterType) { this.ParameterName = this.GetParameterName(parameterName); this.ParameterState = parameterState; this.ParameterValue = parameterValue; this.ParameterUnit = parameterUnit; this.ParameterType = parameterType; }
private int ShowVarGUI(List <GVar> vars, List <ActionParameter> parameters, ParameterType parameterType, int variableID, int parameterID, bool isNew) { // Create a string List of the field's names (for the PopUp box) List <string> labelList = new List <string>(); int i = 0; int variableNumber = -1; if (vars.Count > 0) { foreach (GVar _var in vars) { labelList.Add(_var.label); // If a GlobalVar variable has been removed, make sure selected variable is still valid if (_var.id == variableID) { variableNumber = i; } i++; } if (variableNumber == -1 && (parameters == null || parameters.Count == 0 || parameterID == -1)) { // Wasn't found (variable was deleted?), so revert to zero Debug.LogWarning("Previously chosen variable no longer exists!"); variableNumber = 0; variableID = 0; } string label = "'From' variable:"; if (isNew) { label = "'To' variable:"; } parameterID = Action.ChooseParameterGUI(label, parameters, parameterID, parameterType); if (parameterID >= 0) { //variableNumber = 0; variableNumber = Mathf.Min(variableNumber, vars.Count - 1); variableID = -1; } else { variableNumber = EditorGUILayout.Popup(label, variableNumber, labelList.ToArray()); variableID = vars [variableNumber].id; } } else { EditorGUILayout.HelpBox("No variables exist!", MessageType.Info); variableID = -1; variableNumber = -1; } if (isNew) { newParameterID = parameterID; if (variableNumber >= 0) { newVarType = vars[variableNumber].type; } } else { oldParameterID = parameterID; if (variableNumber >= 0) { oldVarType = vars[variableNumber].type; } } return(variableID); }
public ParameterDefinition(String name) { _parameterType = ParameterType.Single; _name = name; }
public ParameterParam(DB.Parameter p) : this() { ParameterName = p.Definition.Name; ParameterType = p.Definition.ParameterType; ParameterGroup = p.Definition.ParameterGroup; ParameterBinding = p.Element is DB.ElementType ? DBX.ParameterBinding.Type : DBX.ParameterBinding.Instance; if (p.IsShared) { ParameterClass = DBX.ParameterClass.Shared; ParameterSharedGUID = p.GUID; } else if (p.Id.TryGetBuiltInParameter(out var parameterBuiltInId)) { ParameterClass = DBX.ParameterClass.BuiltIn; ParameterBuiltInId = parameterBuiltInId; } else if (p.Element.Document.GetElement(p.Id) is DB.ParameterElement paramElement) { if (paramElement is DB.GlobalParameter) { ParameterClass = DBX.ParameterClass.Global; } else { switch (paramElement.get_Parameter(DB.BuiltInParameter.ELEM_DELETABLE_IN_FAMILY).AsInteger()) { case 0: ParameterClass = DBX.ParameterClass.Family; break; case 1: ParameterClass = DBX.ParameterClass.Project; break; } } } try { Name = $"{DB.LabelUtils.GetLabelFor(ParameterGroup)} : {ParameterName}"; } catch (Autodesk.Revit.Exceptions.InvalidOperationException) { Name = ParameterName; } NickName = Name; MutableNickName = false; try { Description = p.StorageType == DB.StorageType.ElementId ? "ElementId" : DB.LabelUtils.GetLabelFor(p.Definition.ParameterType); } catch (Autodesk.Revit.Exceptions.InvalidOperationException) { Description = p.Definition.UnitType == DB.UnitType.UT_Number ? "Enumerate" : DB.LabelUtils.GetLabelFor(p.Definition.UnitType); } if (string.IsNullOrEmpty(Description)) { Description = ParameterType.ToString(); } if (ParameterSharedGUID.HasValue) { Description = $"Shared parameter {ParameterSharedGUID.Value:B}\n{Description}"; } else if (ParameterBuiltInId != DB.BuiltInParameter.INVALID) { Description = $"BuiltIn parameter {ParameterBuiltInId.ToStringGeneric()}\n{Description}"; } else if (ParameterBinding != DBX.ParameterBinding.Unknown) { Description = $"{ParameterClass} parameter ({ParameterBinding})\n{Description}"; } else { Description = $"{ParameterClass} parameter\n{Description}"; } }
public void SelectByParameter(RhinoDoc doc, ParametersSelectorForm form) { Rhino.DocObjects.Tables.ObjectTable rhobjs = doc.Objects; string paramName = form.GetParamName(); if (paramName != "") { // List to store all the objects that match. List <Rhino.DocObjects.RhinoObject> matched = new List <Rhino.DocObjects.RhinoObject>(); string paramValue = form.GetParamValue(); // TODO Filter also by type of obj? // rhobjs = filter( lambda x: va.IsColumn(x.Id) , Rhino.RhinoDoc.ActiveDoc.Objects) if (paramValue != "") // Search by name and value. { // If the input param value can be converted to num then compare as num and as text. if (Double.TryParse(paramValue, out double numValue)) { int comparison = form.GetComparisonType(); if (comparison == 0) // Equality comparison. { foreach (Rhino.DocObjects.RhinoObject o in rhobjs) { Guid paramId = GetObjectParameterId(paramName, o.Id, true); if (paramId != Guid.Empty && GetParameterValue(paramId, o.Id) != null) { ParameterType t = GetParameterType(paramId); // First type number comparison. if (IsDirectNumericalType(t) && numValue == Convert.ToDouble(GetParameterValue(paramId, o.Id))) { matched.Add(o); } // Type angle comparison. else if (t == ParameterType.Angle && DegreeToRadian(numValue) == Convert.ToDouble(GetParameterValue(paramId, o.Id))) { matched.Add(o); } // Type percentage comparison. else if (t == ParameterType.Percentage && (numValue / 100.0) == Convert.ToDouble(GetParameterValue(paramId, o.Id))) { matched.Add(o); } // If it is a number but as a string. else if (GetParameterValue(paramId, o.Id) != null && paramValue == GetParameterValue(paramId, o.Id).ToString()) { matched.Add(o); } } } } else if (comparison == 1) // Less than comparison. { foreach (Rhino.DocObjects.RhinoObject o in rhobjs) { Guid paramId = GetObjectParameterId(paramName, o.Id, true); if (paramId != Guid.Empty && GetParameterValue(paramId, o.Id) != null) { ParameterType t = GetParameterType(paramId); // First type number comparison. if (IsDirectNumericalType(t) && numValue > Convert.ToDouble(GetParameterValue(paramId, o.Id))) { matched.Add(o); } // Type angle comparison. else if (t == ParameterType.Angle && DegreeToRadian(numValue) > Convert.ToDouble(GetParameterValue(paramId, o.Id))) { matched.Add(o); } // Type percentage comparison. else if (t == ParameterType.Percentage && (numValue / 100.0) > Convert.ToDouble(GetParameterValue(paramId, o.Id))) { matched.Add(o); } } } } else if (comparison == 2) // Greater than comparison. { foreach (Rhino.DocObjects.RhinoObject o in rhobjs) { Guid paramId = GetObjectParameterId(paramName, o.Id, true); if (paramId != Guid.Empty && GetParameterValue(paramId, o.Id) != null) { ParameterType t = GetParameterType(paramId); // First type number comparison. if (IsDirectNumericalType(t) && numValue < Convert.ToDouble(GetParameterValue(paramId, o.Id))) { matched.Add(o); } // Type angle comparison. else if (t == ParameterType.Angle && DegreeToRadian(numValue) < Convert.ToDouble(GetParameterValue(paramId, o.Id))) { matched.Add(o); } // Type percentage comparison. else if (t == ParameterType.Percentage && (numValue / 100.0) < Convert.ToDouble(GetParameterValue(paramId, o.Id))) { matched.Add(o); } } } } } else // If it cannot be converted to num then only compare as bool and text. { int comparison = form.GetComparisonType(); if (comparison == 0) // Equality comparison. { foreach (Rhino.DocObjects.RhinoObject o in rhobjs) { Guid paramId = GetObjectParameterId(paramName, o.Id, true); if (paramId != Guid.Empty && GetParameterValue(paramId, o.Id) != null) { ParameterType t = GetParameterType(paramId); if (t == ParameterType.Boolean) { if ((string.Equals(paramValue, "yes", StringComparison.OrdinalIgnoreCase) || string.Equals(paramValue, "true", StringComparison.OrdinalIgnoreCase)) && "True" == GetParameterValue(paramId, o.Id).ToString()) { matched.Add(o); } else if ((string.Equals(paramValue, "no", StringComparison.OrdinalIgnoreCase) || string.Equals(paramValue, "false", StringComparison.OrdinalIgnoreCase)) && "False" == GetParameterValue(paramId, o.Id).ToString()) { matched.Add(o); } } else if (paramValue == GetParameterValue(paramId, o.Id).ToString()) { matched.Add(o); } } } } } } else // Search only by parameter name. { foreach (Rhino.DocObjects.RhinoObject o in rhobjs) { Guid paramId = GetObjectParameterId(paramName, o.Id, true); if (paramId != Guid.Empty) { matched.Add(o); } } } if (form.GetAddToSelection() == null || form.GetAddToSelection() == false) { rhobjs.UnselectAll(); } // Select all the ones that matched. if (matched.Count > 0) { foreach (Rhino.DocObjects.RhinoObject o in matched) { o.Select(true); } if (matched.Count == 1) { RhinoApp.WriteLine("1 object was selected."); } else { RhinoApp.WriteLine("{0} objects were selected.", matched.Count); } } else { RhinoApp.WriteLine("No objects were found."); } } }
/// <summary> /// Parameterizes this <see cref="ShopifyOrderFilterOptions"/> class, with special handling for <see cref="Ids"/>. /// </summary> /// <param name="propName">The name of the property. Will match the property's <see cref="JsonPropertyAttribute"/> name — /// rather than the real property name — where applicable. Use <paramref name="property"/>.Name to get the real name.</param> /// <param name="value">The property's value.</param> /// <param name="property">The property itself.</param> /// <param name="type">The type of parameter to create.</param> /// <returns>The new parameter.</returns> public override Parameter ToSingleParameter(string propName, object value, PropertyInfo property, ParameterType type) { if (propName == "ids" || propName == "Ids") { //RestSharp does not automatically convert arrays into querystring params. var param = new Parameter() { Name = propName, Type = type, Value = string.Join(",", value as IEnumerable <long>) }; return(param); } return(base.ToSingleParameter(propName, value, property, type)); }
public ParameterDefinition(String name, String[] possibleValues) : this(name) { _parameterType = ParameterType.Enum; _possibleValues = possibleValues; }