/// <summary> /// Creates a new designer attribute for handling a string value. /// </summary> /// <param name="displayName">The name shown on the node and in the property editor for the property.</param> /// <param name="description">The description shown in the property editor for the property.</param> /// <param name="category">The category shown in the property editor for the property.</param> /// <param name="displayMode">Defines how the property is visualised in the editor.</param> /// <param name="displayOrder">Defines the order the properties will be sorted in when shown in the property grid. Lower come first.</param> /// <param name="flags">Defines the designer flags stored for the property.</param> public DesignerPropertyEnum(string displayName, string description, string category, DisplayMode displayMode, int displayOrder, DesignerFlags flags, AllowStyles styles, string dependedProperty, string dependingProperty, ValueTypes filterType = ValueTypes.All, double min = double.MinValue, double max = double.MaxValue) : base(displayName, description, category, displayMode, displayOrder, flags, typeof(DesignerPropertyEnumEditor), null, filterType) { _styles = styles; _dependedProperty = dependedProperty; _dependingProperty = dependingProperty; _minValue = min; _maxValue = max; }
/// <summary> /// Creates an instance of this class with the required category and sub category. /// </summary> /// <param name="category">Selected category</param> /// <param name="subCategory">Selected sub category</param> /// <history> /// [Curtis_Beard] 10/31/2014 ADD: exclusions update /// </history> public FilterType(Categories category, SubCategories subCategory) { cat = category; subcat = subCategory; switch (subcat) { case SubCategories.Name: case SubCategories.Path: valuetype = ValueTypes.String; supportedValueOptions = new List<ValueOptions>() { ValueOptions.Equals, ValueOptions.Contains, ValueOptions.StartsWith, ValueOptions.EndsWith }; supportsIgnoreCase = true; supportsMulitpleItems = true; break; case SubCategories.Hidden: case SubCategories.System: case SubCategories.ReadOnly: case SubCategories.Binary: valuetype = ValueTypes.Null; supportedValueOptions = new List<ValueOptions>() { ValueOptions.None }; supportsIgnoreCase = false; supportsMulitpleItems = false; break; case SubCategories.DateModified: case SubCategories.DateCreated: valuetype = ValueTypes.DateTime; supportedValueOptions = new List<ValueOptions>() { ValueOptions.Equals, ValueOptions.NotEquals, ValueOptions.GreaterThan, ValueOptions.GreaterThanEquals, ValueOptions.LessThan, ValueOptions.LessThanEquals }; supportsIgnoreCase = false; supportsMulitpleItems = true; break; case SubCategories.Extension: valuetype = ValueTypes.String; supportedValueOptions = new List<ValueOptions>() { ValueOptions.None }; supportsIgnoreCase = false; supportsMulitpleItems = true; break; case SubCategories.Size: valuetype = ValueTypes.Size; supportedValueOptions = new List<ValueOptions>() { ValueOptions.Equals, ValueOptions.NotEquals, ValueOptions.GreaterThan, ValueOptions.GreaterThanEquals, ValueOptions.LessThan, ValueOptions.LessThanEquals }; supportsIgnoreCase = false; supportsMulitpleItems = true; break; case SubCategories.MinimumHitCount: valuetype = ValueTypes.Long; supportedValueOptions = new List<ValueOptions>() { ValueOptions.None }; supportsIgnoreCase = false; supportsMulitpleItems = false; break; } }
/// <summary> /// Builds a <seealso cref="EventValueDescription"/> with a name and a type. /// <p/> /// If the type is <seealso cref="EventValueType#INT"/> or <seealso cref="EventValueType#LONG"/>, the /// <seealso cref="#mValueType"/> is set to <seealso cref="ValueType#BYTES"/> by default. It set to /// <seealso cref="ValueType#NOT_APPLICABLE"/> for all other <seealso cref="EventValueType"/> values. </summary> /// <param name="name"> </param> /// <param name="type"> </param> internal EventValueDescription(string name, EventContainer.EventValueTypes type) { mName = name; mEventValueType = type; if (mEventValueType == EventContainer.EventValueTypes.INT || mEventValueType == EventContainer.EventValueTypes.LONG) { mValueType = ValueTypes.BYTES; } else { mValueType = ValueTypes.NOT_APPLICABLE; } }
public static ValueType HighestValue(ValueTypes a, ValueTypes b) { throw new NotImplementedException(); switch (a) { case ValueTypes.ARRAY: return ValueTypes.NULL; case ValueTypes.BOOLEAN: return ValueTypes.NULL; case ValueTypes.BYTE: return ValueTypes.NULL; case ValueTypes.CODE_BLOCK: return ValueTypes.NULL; case ValueTypes.DATETIME: return ValueTypes.NULL; case ValueTypes.DECIMAL: return ValueTypes.NULL; case ValueTypes.DOUBLE: return ValueTypes.NULL; case ValueTypes.EMPTY: return ValueTypes.NULL; case ValueTypes.FLOAT: return ValueTypes.NULL; case ValueTypes.GUID: return ValueTypes.NULL; case ValueTypes.INT_16: return ValueTypes.NULL; case ValueTypes.INT_32: return ValueTypes.NULL; case ValueTypes.INT_64: return ValueTypes.NULL; case ValueTypes.NULL: return ValueTypes.NULL; case ValueTypes.REFERENCE: return ValueTypes.NULL; case ValueTypes.STRING: return ValueTypes.NULL; case ValueTypes.OBJECT: return ValueTypes.NULL; case ValueTypes.UINT_16: return ValueTypes.NULL; case ValueTypes.UINT_32: return ValueTypes.NULL; case ValueTypes.UINT_64: return ValueTypes.NULL; } }
public object GetValue(string fieldName, ValueTypes valueType = ValueTypes.Default) { object o = false; //int fieldDefinitionIndex = 0; foreach (Template.Field f in pageCollection.ActiveTemplate.Fields.Where(x => x.Name == fieldName)) { o = getValue(f /*, fieldDefinitionIndex*/, valueType); if (o != null) { return(o); } //fieldDefinitionIndex++; } if (o == null) { return(null); } throw new Exception("These is no field[name=" + fieldName + "]"); }
protected IPropertyType CreatePropertyTypeExtension(PropertyInfo pi, DBMeta dbmeta) { if (IsRelationProperty(pi, dbmeta)) { return(null); } String columnName = GetPropertyTypeColumnName(pi); IValueType valueType = ValueTypes.GetValueType(pi.PropertyType); IPropertyType pt = new PropertyTypeImpl(pi, valueType, columnName); if (dbmeta.HasPrimaryKey && dbmeta.HasColumn(pt.ColumnName)) { if (dbmeta.FindColumnInfo(pt.ColumnName).IsPrimary) { pt.IsPrimaryKey = true; } } pt.IsPersistent = IsPersistentProperty(pi, dbmeta); return(pt); }
private void GetValues(SqlCommand command) { using (var objReader = command.ExecuteReader()) { if (objReader != null) { if (objReader.HasRows) { while (objReader.Read()) { ValueTypes enumValueType = (ValueTypes)Enum.Parse(typeof(ValueTypes), objReader["TYPE"].ToString()); switch (enumValueType) { case ValueTypes.vtAangemeldOneDayToDate: ucDashboard1.InVandaag = float.Parse(objReader["AANTAL"].ToString()); break; case ValueTypes.vtAfgemeldOneDayToDate: ucDashboard1.UitVandaag = float.Parse(objReader["AANTAL"].ToString()); break; case ValueTypes.vtAangemeldOneWeekToDate: ucDashboard1.InWeek = float.Parse(objReader["AANTAL"].ToString()); break; case ValueTypes.vtAfgemeldOneWeekToDate: ucDashboard1.UitWeek = float.Parse(objReader["AANTAL"].ToString()); break; case ValueTypes.vtOpenstaandTotaal: ucDashboard1.Totaal = float.Parse(objReader["AANTAL"].ToString()); break; default: throw new ArgumentOutOfRangeException(); } } } } } }
void ParseProperties(XmlElement element, object obj) { XmlAttributeCollection attributes = element.Attributes; Type type = obj.GetType(); PropertyInfo[] properties = type.GetProperties(); // loop for each attribute defined in the given element and attempt to // set the value of a property whose name is equals to the element name. foreach (XmlAttribute att in attributes) { string property_name = att.Name; string property_value = att.Value; // If desired remove the "-" character from the attribute name. if (remove_hyphen_from_attribute_names_) { property_name = property_name.Replace("-", ""); } PropertyInfo property; if (TryGetProperty(properties, property_name, out property) && property.CanWrite) { Type property_type = property.PropertyType; if (property_type.Name == "String") { property.SetValue(obj, property_value, null); } else if (property_type.IsValueType) { // try to convert the attribute value to the type of the property System.ValueType value; if (ValueTypes.TryParse(property_type, property_value, out value)) { property.SetValue(obj, value, null); } } } } }
internal Parameter(string name, string[] aliases, ValueTypes valueType, string environmentPrefix, string environmentVarName, bool isRequired, object defaultValue) { this.Name = name.Trim(); this.Aliases = aliases; this.ValueType = valueType; _environmentPrefix = environmentPrefix; _environmentVarName = environmentVarName; this.IsRequired = isRequired; this.DefaultValue = defaultValue; if (this.Name == "*" && this.ValueType == ValueTypes.None) { throw new InvalidOperationException("Catch-all parameter '*' must specify a value type!"); } }
public FilterQuery(string fieldName, object fieldValue, FilterQueryTypes queryType) { FieldName = fieldName; FieldValue = fieldValue; QueryType = queryType; ValueType = ValueTypes.String; if (fieldValue.GetType() == typeof(bool)) { ValueType = ValueTypes.Bool; } if (IsNumeric(fieldValue.ToString())) { ValueType = ValueTypes.Numeric; } if (fieldValue.GetType() == typeof(DateTimeOffset)) { ValueType = ValueTypes.DateTimeOffset; } }
// =============================================================================== // Common Logic // ============ // ------------------------------------------------- // Args Handling // ------------- protected virtual void BindArgs(IDbCommand command, Object[] args, Type[] argTypes) { if (_loggingMessageSqlArgs == null) { _loggingMessageSqlArgs = args; } // Save arguments for logging. if (args == null) { return; } string[] argNames = _commandFactory.GetArgNames(command, args); for (int i = 0; i < args.Length; ++i) { IValueType valueType = ValueTypes.GetValueType(argTypes[i]); try { valueType.BindValue(command, argNames[i], args[i]); } catch (Exception e) { HandleDbException(e, command); } } }
public void SetupCastSettings(object obj) { if (obj != null && obj is Behaviac.Design.Nodes.Node) { Behaviac.Design.Nodes.Node assignNode = obj as Behaviac.Design.Nodes.Node; if (assignNode != null) { bool bCasting = assignNode.IsCasting; if (bCasting) { DesignerPropertyInfo leftPropInfo = DesignerProperty.GetDesignerProperty(assignNode.GetType(), "Opl"); VariableDef opl = (VariableDef)leftPropInfo.GetValue(assignNode); Type leftType = opl.ValueType; // if number if (Plugin.IsIntergerNumberType(leftType) || Plugin.IsFloatType(leftType)) { this.ValueType = ValueTypes.Int | ValueTypes.Float; this.FilterType = null; } else if (Plugin.IsRefType(leftType)) { //ref type/pointer type this.ValueType = ValueTypes.RefType; this.FilterType = leftType; } else { // } } } } }
/// <inheritdoc /> public override LabelConfiguration FromConfigurationEditor( IDictionary <string, object?>?editorValues, LabelConfiguration?configuration) { var newConfiguration = new LabelConfiguration(); // get the value type // not simply deserializing Json because we want to validate the valueType if (editorValues is not null && editorValues.TryGetValue( Constants.PropertyEditors.ConfigurationKeys.DataValueType, out var valueTypeObj) && valueTypeObj is string stringValue) { // validate if (!string.IsNullOrWhiteSpace(stringValue) && ValueTypes.IsValue(stringValue)) { newConfiguration.ValueType = stringValue; } } return(newConfiguration); }
private void SetToDefault() { SelectedValueType = ValueTypes.FirstOrDefault(); SelectedCashFlow = CashFlows.FirstOrDefault(); SelectedCashFlowGroup = CashFlowGroups.FirstOrDefault(); SelectedIncome = null; SelectedSaving = null; UserValue = null; UserText = string.Empty; SelectedEquation = null; SelectedOperatorType = CalculatorOperatorType.None; var lastItem = Model.Items.LastOrDefault(); bool isLastItemNotOperator = (lastItem != null) && (lastItem.ValueType != CalculatorValueType.Operator); IsLastElement = (Model.Items.Count > 2) && (isLastItemNotOperator); if (IsOperatorElementVisible) { IsAddOperatorSelected = true; } }
private void RefreshUI() { _suppressEvents = true; if (Model.CurrentItem == null) { Model.CreateDefaultCurrentItem(); SetToDefault(); } else if (!Model.Items.Contains(Model.CurrentItem)) { SetToDefault(); } else { var currentItem = Model.CurrentItem; bool isOperatorType = currentItem.ValueType == CalculatorValueType.Operator; bool isNoneOperatorType = currentItem.OperatorType == CalculatorOperatorType.None; IsLastElement = isOperatorType && isNoneOperatorType; SelectedOperatorType = currentItem.OperatorType; SelectedValueType = ValueTypes.FirstOrDefault(x => x.Value == currentItem.ValueType); SelectedCashFlow = CashFlows.FirstOrDefault(x => x.Id == currentItem.ForeignId); SelectedCashFlowGroup = CashFlowGroups.FirstOrDefault(x => x.Id == currentItem.ForeignId); SelectedIncome = Incomes.FirstOrDefault(x => x.Id == currentItem.ForeignId); SelectedSaving = Savings.FirstOrDefault(x => x.Id == currentItem.ForeignId); UserValue = currentItem.Value; UserText = currentItem.Text; SelectedEquation = Equations.FirstOrDefault(x => x.Id == currentItem.ForeignId); } NotifyOfPropertyChange(() => IsNoneOperatorSelected); NotifyOfPropertyChange(() => IsOperatorElementVisible); NotifyOfPropertyChange(() => IsAddOperatorSelected); NotifyOfPropertyChange(() => IsSubstractOperatorSelected); NotifyOfPropertyChange(() => IsMultiplyOperatorSelected); NotifyOfPropertyChange(() => IsDivideOperatorSelected); Title = string.Format("Składowe równania ({0}/{1})", Model.CurrentPageNumber, Model.TotalPagesNumber); _suppressEvents = false; }
/// <summary> /// A method used to format the database value to a value that can be used by the editor /// </summary> /// <param name="property"></param> /// <param name="dataTypeService"></param> /// <param name="culture"></param> /// <param name="segment"></param> /// <returns></returns> /// <remarks> /// The object returned will always be a string and if the database type is not a valid string type an exception is thrown /// </remarks> public override object ToEditor(Property property, IDataTypeService dataTypeService, string culture = null, string segment = null) { var val = property.GetValue(culture, segment); if (val == null) { return(string.Empty); } switch (ValueTypes.ToStorageType(ValueType)) { case ValueStorageType.Ntext: case ValueStorageType.Nvarchar: return(val.ToString()); case ValueStorageType.Integer: case ValueStorageType.Decimal: case ValueStorageType.Date: default: throw new InvalidOperationException("The " + typeof(TextOnlyValueEditor) + " can only be used with string based property editors"); } }
private bool IsSymbolValid(string mask, string str, ValueTypes typ) { switch (typ) { case ValueTypes.Text: return(true); case ValueTypes.Integer: if (str == NumberFormatInfo.CurrentInfo.NegativeSign) { return(true); } break; case ValueTypes.Double: if (str == NumberFormatInfo.CurrentInfo.NumberDecimalSeparator || str == NumberFormatInfo.CurrentInfo.NegativeSign) { return(true); } break; } if (typ.Equals(ValueTypes.Integer) || typ.Equals(ValueTypes.Double)) { foreach (char ch in str) { if (!Char.IsDigit(ch)) { return(false); } } return(true); } return(false); }
void SetValue(object value) { this.value = value; isArray = value is Array; if (value == null) { if (valueType != ValueTypes.Null || valueType != ValueTypes.Object) { value = GetDefaultValue(valueType, isArray); } } else { if (value is UnityEngine.Object[] || value is UnityEngine.Object) { valueType = ValueTypes.Object; } else { valueType = ToValueType(value.GetType()); } } }
public static void CopyAroundAndModifyField(ValueTypes.S s) { ValueTypes.S s2 = s; s2.Field += 10; s = s2; }
public static void Copy4(ref ValueTypes.S p, out ValueTypes.S o) { o = p; }
public static void Copy4b(ref ValueTypes.S p, out ValueTypes.S o) { // test passing through by-ref arguments ValueTypes.Copy4(ref p, out o); }
private bool Equals(CacheKey other) { return(ValueTypes.SequenceEqual(other.ValueTypes) && (IndexMap?.SequenceEqual(other.IndexMap) ?? true)); }
public virtual void SetAdapterLists(int BaseObjectIndex, string key, string property, ValueTypes type, string lable, int defaultLaoutID = Resource.Layout.CommonLabelTextViewer, Type defaultActivity = null) { string propertyList = BusinessObjects[BaseObjectIndex].parm.PropertyList; if (string.IsNullOrEmpty(propertyList)) { propertyList = "" + property; } else { propertyList += "," + property; } if (!string.IsNullOrEmpty(property)) { BusinessObjects[BaseObjectIndex].parm.PropertyList = propertyList; } AdapterListTemplate.Add(new AdapterList(key, property, "", lable, type, defaultLaoutID, defaultActivity) { ObjIndex = BaseObjectIndex }); }
public static ValueTypes.S InitObj1() { ValueTypes.S result = default(ValueTypes.S); ValueTypes.MakeArray(); return(result); }
public static ValueTypes.S Copy2(ref ValueTypes.S p) { return p; }
public static bool IsNumber(ValueTypes type) { var typeBits = (int)type & 0x03; return (typeBits == 0x01) || (typeBits == 0x02); }
public static bool IsFunction(ValueTypes type) { return type == ValueTypes.Function; }
public static bool IsString(ValueTypes type) { return type == ValueTypes.String; }
public static bool IsBoolean(ValueTypes type) { return type == ValueTypes.Boolean; }
public static bool IsNull(ValueTypes type) { return type == ValueTypes.Null; }
public static bool IsUndefined(ValueTypes type) { return type == ValueTypes.Undefined; }
/// <summary> /// Builds a <seealso cref="EventValueDescription"/> with a name and a type, and a <seealso cref="ValueType"/>. /// <p/> </summary> /// <param name="name"> </param> /// <param name="type"> </param> /// <param name="valueType"> </param> /// <exception cref="InvalidValueTypeException"> if type and valuetype are not compatible. /// </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: EventValueDescription(String name, com.android.ddmlib.log.EventContainer.EventValueType type, ValueType valueType) throws InvalidValueTypeException internal EventValueDescription(string name, EventContainer.EventValueTypes type, ValueTypes valueType) { mName = name; mEventValueType = type; mValueType = valueType; mValueType.checkType(mEventValueType); }
private static void Test(ValueTypes.S byVal) { }
public static void InitObj3(out ValueTypes.S p) { p = default(ValueTypes.S); }
public static bool IsObject(ValueTypes type) { var typeBits = (int)type & 0x03; return typeBits == 0x03; }
/// <summary> /// Creates a new designer attribute for handling a string value. /// </summary> /// <param name="displayName">The name shown on the node and in the property editor for the property.</param> /// <param name="description">The description shown in the property editor for the property.</param> /// <param name="category">The category shown in the property editor for the property.</param> /// <param name="displayMode">Defines how the property is visualised in the editor.</param> /// <param name="displayOrder">Defines the order the properties will be sorted in when shown in the property grid. Lower come first.</param> /// <param name="flags">Defines the designer flags stored for the property.</param> public DesignerMethodEnum(string displayName, string description, string category, DisplayMode displayMode, int displayOrder, DesignerFlags flags, MethodType methodType, ValueTypes methodReturnType = ValueTypes.All, string linkedToProperty = "") : base(displayName, description, category, displayMode, displayOrder, flags, typeof(DesignerMethodComboEnumEditor), linkedToProperty) { _methodType = methodType; _methodReturnType = methodReturnType; }
public static bool IsPrimitive(ValueTypes type) { var typeBits = (int)type & 0x03; return typeBits != 0x03; }
public static bool IsCompatibleType(ValueTypes valueType, Type filterType, Type typeToFilter, bool bArrayType) { Debug.Check(typeToFilter != null); if (filterType == null || (filterType.Name == "System_Object" && !Plugin.IsArrayType(typeToFilter))) return true; if (valueType != ValueTypes.All) { if ((valueType & ValueTypes.Int) == ValueTypes.Int && Plugin.IsIntergerType(typeToFilter) || (valueType & ValueTypes.Float) == ValueTypes.Float && Plugin.IsFloatType(typeToFilter)) return true; } bool bCompatible = false; if (bArrayType && Plugin.IsArrayType(typeToFilter)) { //list of the same type Type typeToFilterElement = typeToFilter.GetGenericArguments()[0]; if (Plugin.IsCompatibleType(valueType, typeToFilterElement, filterType, false)) { bCompatible = true; } } else if (filterType == typeToFilter) { bCompatible = true; } else { bCompatible = Plugin.IsAgentDerived(typeToFilter.Name, filterType.Name); } return bCompatible; }
public static bool IsDefined(ValueTypes type) { var typeBits = (int)type & 0x07; return typeBits != 0; }
/// <summary> /// /// </summary> /// <param name="type"></param> public Value(ValueTypes type) { this.mType = type; }
/// <summary> /// Creates a new designer attribute for handling a string value. /// </summary> /// <param name="displayName">The name shown on the node and in the property editor for the property.</param> /// <param name="description">The description shown in the property editor for the property.</param> /// <param name="category">The category shown in the property editor for the property.</param> /// <param name="displayMode">Defines how the property is visualised in the editor.</param> /// <param name="displayOrder">Defines the order the properties will be sorted in when shown in the property grid. Lower come first.</param> /// <param name="flags">Defines the designer flags stored for the property.</param> public DesignerRightValueEnum(string displayName, string description, string category, DisplayMode displayMode, int displayOrder, DesignerFlags flags, AllowStyles styles, MethodType methodType, string dependedProperty, string dependingProperty, ValueTypes filterType = ValueTypes.All) : base(displayName, description, category, displayMode, displayOrder, flags, styles, dependedProperty, dependingProperty, filterType) { _methodType = methodType; }
private void cmdBegin_Click(object sender, EventArgs e) { Enabled = false; lstOffsets.DataSource = null; uint baseAddress = ((ModuleInfo)cboModule.SelectedItem).BaseAddress; uint size = ((ModuleInfo)cboModule.SelectedItem).Size; ValueTypes type = (ValueTypes)cboType.SelectedItem; object searchValue = txtValue.Text; switch (type) { case ValueTypes.Byte: searchValue = Convert.ToByte((string)searchValue); break; case ValueTypes.Int16: searchValue = Convert.ToInt16((string)searchValue); break; case ValueTypes.Int32: searchValue = Convert.ToInt32((string)searchValue); break; case ValueTypes.Float: searchValue = Convert.ToSingle((string)searchValue); break; } const uint BlockSize = 512; uint blockCount = size / BlockSize; uint offset = 0; //for (int i = 0; i < blockCount; i++) { BinaryReader br = new BinaryReader(new MemoryStream(XBoxIO.XBox.GetMemory(baseAddress + offset, size))); //probar.Value = (int)((i * 100) / (blockCount * 100)); Application.DoEvents(); while (br.BaseStream.Position < br.BaseStream.Length)//offset < size) { probar.Value = (int)(((float)br.BaseStream.Position / (float)br.BaseStream.Length) * 100.0f); switch (type) { case ValueTypes.Byte: { byte data = br.ReadByte(); if (data == (byte)searchValue) { MemoryInfo.Add(new MemoryInfoItem(offset)); } offset += sizeof(byte); break; } case ValueTypes.Int16: { Int16 data = br.ReadInt16(); if (data == (Int16)searchValue) { MemoryInfo.Add(new MemoryInfoItem(offset)); } offset += sizeof(Int16); break; } case ValueTypes.Int32: { Int32 data = br.ReadInt32();; if (data == (Int32)searchValue) { MemoryInfo.Add(new MemoryInfoItem(offset)); } offset += sizeof(Int32); break; } case ValueTypes.Float: { float data = br.ReadSingle(); if (data == (float)searchValue) { MemoryInfo.Add(new MemoryInfoItem(offset)); } offset += sizeof(float); break; } } } br.Close(); //WaitForSeconds(10.0f); } lstOffsets.DataSource = MemoryInfo; probar.Value = 0; Enabled = true; }
public Declaration(ValueTypes type, string identifier) { _type = type; _identifier = identifier; }
public static void Copy3(ValueTypes.S p, out ValueTypes.S o) { o = p; }
public Macro(MacroType type, int value) : this(type) { m_ValueInteger = value; m_ValueType = ValueTypes.Integer; }
public Macro(MacroType type, string value) : this(type) { m_ValueString = value; m_ValueType = ValueTypes.String; }
public static ValueTypes.S OnlyChangeTheCopy(ValueTypes.S p) { ValueTypes.S s = p; s.SetField(); return p; }
/// <summary> /// Creates an instance of this class with the required category and sub category. /// </summary> /// <param name="category">Selected category</param> /// <param name="subCategory">Selected sub category</param> /// <history> /// [Curtis_Beard] 10/31/2014 ADD: exclusions update /// </history> public FilterType(Categories category, SubCategories subCategory) { cat = category; subcat = subCategory; switch (subcat) { case SubCategories.Name: case SubCategories.Path: valuetype = ValueTypes.String; supportedValueOptions = new List <ValueOptions>() { ValueOptions.Equals, ValueOptions.Contains, ValueOptions.StartsWith, ValueOptions.EndsWith }; supportsIgnoreCase = true; supportsMulitpleItems = true; break; case SubCategories.Hidden: case SubCategories.System: case SubCategories.ReadOnly: case SubCategories.Binary: valuetype = ValueTypes.Null; supportedValueOptions = new List <ValueOptions>() { ValueOptions.None }; supportsIgnoreCase = false; supportsMulitpleItems = false; break; case SubCategories.DateModified: case SubCategories.DateCreated: valuetype = ValueTypes.DateTime; supportedValueOptions = new List <ValueOptions>() { ValueOptions.Equals, ValueOptions.NotEquals, ValueOptions.GreaterThan, ValueOptions.GreaterThanEquals, ValueOptions.LessThan, ValueOptions.LessThanEquals }; supportsIgnoreCase = false; supportsMulitpleItems = true; break; case SubCategories.Extension: valuetype = ValueTypes.String; supportedValueOptions = new List <ValueOptions>() { ValueOptions.None }; supportsIgnoreCase = false; supportsMulitpleItems = true; break; case SubCategories.Size: valuetype = ValueTypes.Size; supportedValueOptions = new List <ValueOptions>() { ValueOptions.Equals, ValueOptions.NotEquals, ValueOptions.GreaterThan, ValueOptions.GreaterThanEquals, ValueOptions.LessThan, ValueOptions.LessThanEquals }; supportsIgnoreCase = false; supportsMulitpleItems = true; break; case SubCategories.MinimumHitCount: valuetype = ValueTypes.Long; supportedValueOptions = new List <ValueOptions>() { ValueOptions.None }; supportsIgnoreCase = false; supportsMulitpleItems = false; break; } }
private static void Test(ref ValueTypes.S byRef) { }
/// <summary> /// Creates a new designer attribute. /// </summary> /// <param name="displayName">The name shown on the node and in the property editor for the property.</param> /// <param name="description">The description shown in the property editor for the property.</param> /// <param name="category">The category shown in the property editor for the property.</param> /// <param name="displayMode">Defines how the property is visualised in the editor.</param> /// <param name="displayOrder">Defines the order the properties will be sorted in when shown in the property grid. Lower come first.</param> /// <param name="flags">Defines the designer flags stored for the property.</param> /// <param name="editorType">The type of the editor used in the property grid.</param> /// <param name="linkedToProperty">The restrictions of this property are defined by another property.</param> protected DesignerProperty(string displayName, string description, string category, DisplayMode displayMode, int displayOrder, DesignerFlags flags, Type editorType, string linkedToProperty, ValueTypes filterType = ValueTypes.All) { _displayName = displayName; _description = description; _category = category; _displayMode = displayMode; _displayOrder = displayOrder; _flags = flags; _editorType = editorType; _linkedToProperty = linkedToProperty; _valueType = filterType; _filterType = Plugin.GetTypeFromValue(filterType); }
public static ValueTypes.S Copy1(ValueTypes.S p) { return p; }
internal static void Write() { List <string> mappingsList = ValueTypes.Aggregate(new List <string>(), (list, next) => { list.Add(File.ReadAllText(string.Format(CultureInfo.InvariantCulture, "{0}\\InputMapperProfilesTemplate.txt", Directory.GetCurrentDirectory())) .Replace("#TYPE#", next)); return(list); }); mappingsList = ValueTypes.Aggregate(mappingsList, (list, next) => { list.Add(File.ReadAllText(string.Format(CultureInfo.InvariantCulture, "{0}\\InputMapperProfilesTemplate.txt", Directory.GetCurrentDirectory())) .Replace("#TYPE#", string.Concat(next, "?"))); return(list); }); mappingsList = OtherTypes.Aggregate(mappingsList, (list, next) => { list.Add(File.ReadAllText(string.Format(CultureInfo.InvariantCulture, "{0}\\InputMapperProfilesTemplate.txt", Directory.GetCurrentDirectory())) .Replace("#TYPE#", next)); return(list); }); string mappings = string.Join(string.Concat(Environment.NewLine, Environment.NewLine), mappingsList); string text = File.ReadAllText(string.Format(CultureInfo.InvariantCulture, "{0}\\InputVariablesMappingProfileFileTemplate.txt", Directory.GetCurrentDirectory())) .Replace("#Mappings#", mappings); List <string> includesViewToParametersList = ValueTypes.Aggregate(new List <string>(), (list, next) => { list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputView<{0}>, InputQuestionParameters<{0}>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputView<{0}?>, InputQuestionParameters<{0}?>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputView<IEnumerable<{0}>>, InputQuestionParameters<IEnumerable<{0}>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputView<IEnumerable<{0}?>>, InputQuestionParameters<IEnumerable<{0}?>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputView<ICollection<{0}>>, InputQuestionParameters<ICollection<{0}>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputView<ICollection<{0}?>>, InputQuestionParameters<ICollection<{0}?>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputView<IList<{0}>>, InputQuestionParameters<IList<{0}>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputView<IList<{0}?>>, InputQuestionParameters<IList<{0}?>>>()", next)); return(list); }); includesViewToParametersList = OtherTypes.Aggregate(includesViewToParametersList, (list, next) => { list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputView<{0}>, InputQuestionParameters<{0}>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputView<IEnumerable<{0}>>, InputQuestionParameters<IEnumerable<{0}>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputView<ICollection<{0}>>, InputQuestionParameters<ICollection<{0}>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputView<IList<{0}>>, InputQuestionParameters<IList<{0}>>>()", next)); return(list); }); List <string> includesParametersToViewList = ValueTypes.Aggregate(new List <string>(), (list, next) => { list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputQuestionParameters<{0}>, InputView<{0}>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputQuestionParameters<{0}?>, InputView<{0}?>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputQuestionParameters<IEnumerable<{0}>>, InputView<IEnumerable<{0}>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputQuestionParameters<IEnumerable<{0}?>>, InputView<IEnumerable<{0}?>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputQuestionParameters<ICollection<{0}>>, InputView<ICollection<{0}>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputQuestionParameters<ICollection<{0}?>>, InputView<ICollection<{0}?>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputQuestionParameters<IList<{0}>>, InputView<IList<{0}>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputQuestionParameters<IList<{0}?>>, InputView<IList<{0}?>>>()", next)); return(list); }); includesParametersToViewList = OtherTypes.Aggregate(includesParametersToViewList, (list, next) => { list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputQuestionParameters<{0}>, InputView<{0}>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputQuestionParameters<IEnumerable<{0}>>, InputView<IEnumerable<{0}>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputQuestionParameters<ICollection<{0}>>, InputView<ICollection<{0}>>>()", next)); list.Add(string.Format(CultureInfo.CurrentCulture, "\t\t\t\t.Include<InputQuestionParameters<IList<{0}>>, InputView<IList<{0}>>>()", next)); return(list); }); text = text.Replace("#ViewToParameterIncludes#", string.Join(Environment.NewLine, includesViewToParametersList)); text = text.Replace("#ParameterToViewIncludes#", string.Join(Environment.NewLine, includesParametersToViewList)); using (StreamWriter sr = new StreamWriter($@"{Constants.BASEPATH}\CheckMySymptoms.AutoMapperProfiles\InputVariablesMappingProfile.cs", false, Encoding.UTF8)) { sr.Write(text); } }
public override void Update(object sender, DesignerPropertyInfo property) { if (_obj != null) { DesignerPropertyEditor oplEditor = GetEditor(_obj, "Opl"); Debug.Check(oplEditor != null); if (oplEditor == sender) { VariableDef opl = (VariableDef)GetProperty(_obj, "Opl"); if (opl != null) { RightValueDef opr = (RightValueDef)GetProperty(_obj, "Opr"); if (opr != null) { if (opl.ValueType != opr.ValueType) { DesignerPropertyEditor oprEditor = GetEditor(_obj, "Opr"); Debug.Check(oprEditor != null); if (oprEditor != null) { oprEditor.Clear(); } } } } } else { DesignerPropertyEditor oplEditorCast = GetEditor(_obj, "CastRight"); Debug.Check(oplEditorCast != null); if (oplEditorCast == sender) { PluginBehaviac.Nodes.Assignment assignNode = _obj as PluginBehaviac.Nodes.Assignment; if (assignNode != null) { RightValueDef opr = (RightValueDef)GetProperty(_obj, "Opr"); if (opr != null) { DesignerPropertyEditor oprEditor = GetEditor(_obj, "Opr"); Debug.Check(oprEditor != null); // oprEditor.ValueType might be overwritten in SetupCastSettings if casting // so that here to backup it first so that it can be restored later if not casting if (assignNode.IsCasting) { _valueTypesBackup = oprEditor.ValueType; } else { oprEditor.ValueType = _valueTypesBackup; } oprEditor.Clear(); oprEditor.FilterType = null; } } } } } }
public static Type GetTypeFromValue(ValueTypes value) { switch (value) { case ValueTypes.Bool : return typeof(bool); case ValueTypes.Int : return typeof(int); case ValueTypes.Float : return typeof(float); } return null; }