public IEnumConfigurator WriteEnum(string name, EnumValueType valueType = EnumValueType.Number) { var enumInfo = new EnumInfo(name, valueType); var part = _options.EnumWriterFactory.Build(enumInfo); _parts.Add(part); return(enumInfo); }
CCodeExpression generate_enum_value_to_string(EnumValueType type, CCodeExpression expr) { var en = type.type_symbol as ValaEnum; var to_string_name = "%s_to_string".printf(get_ccode_lower_case_name(en, null)); var to_string_call = new CCodeFunctionCall(new CCodeIdentifier(to_string_name)); to_string_call.add_argument(expr); return(to_string_call); }
public double GetLast(EnumValueType valueType) { if (Count != 0) { return(valueDict[valueType.ToString()][Count - 1]); } else { return(JPR.NaN); } }
CCodeExpression generate_enum_value_from_string(EnumValueType type, CCodeExpression expr, CCodeExpression error_expr) { var en = type.type_symbol as ValaEnum; var from_string_name = "%s_from_string".printf(get_ccode_lower_case_name(en, null)); var from_string_call = new CCodeFunctionCall(new CCodeIdentifier(from_string_name)); from_string_call.add_argument(expr); from_string_call.add_argument(error_expr != null ? error_expr : new CCodeConstant("NULL")); return(from_string_call); }
public static Func <byte[], object> GetBytesToValueFromEnum(EnumValueType enumType) { switch (enumType) { case EnumValueType.Byte: return(ValueConverter.FromByteBytes); case EnumValueType.Short: return(ValueConverter.FromShortBytes); case EnumValueType.Int: return(ValueConverter.FromIntBytes); case EnumValueType.Long: return(ValueConverter.FromLongBytes); case EnumValueType.Bool: return(ValueConverter.FromBoolBytes); case EnumValueType.DateTime: return(ValueConverter.FromDateTimeBytes); case EnumValueType.Decimal: return(ValueConverter.FromDecimalBytes); case EnumValueType.Float: return(ValueConverter.FromFloatBytes); case EnumValueType.Double: return(ValueConverter.FromDoubleBytes); case EnumValueType.Guid: return(ValueConverter.FromGuidBytes); case EnumValueType.Bytes: return(ValueConverter.FromByteArrayBytes); case EnumValueType.String: return(ValueConverter.FromStringBytes); case EnumValueType.Object: return(ValueConverter.FromObjectBytes); default: return(null); } }
public static Type GetTypeFromEnumType(EnumValueType enumvalue) { switch (enumvalue) { case EnumValueType.Byte: return(typeof(byte)); case EnumValueType.Short: return(typeof(short)); case EnumValueType.Int: return(typeof(int)); case EnumValueType.Long: return(typeof(long)); case EnumValueType.Bool: return(typeof(bool)); case EnumValueType.DateTime: return(typeof(DateTime)); case EnumValueType.Decimal: return(typeof(decimal)); case EnumValueType.Float: return(typeof(float)); case EnumValueType.Double: return(typeof(double)); case EnumValueType.Guid: return(typeof(Guid)); case EnumValueType.Bytes: return(typeof(byte[])); case EnumValueType.String: return(typeof(string)); default: return(null); } }
public static List <TimeCode> SubList(EnumValueType type) { return(ListForCompany().Where(x => x.ValueType == type).ToList()); }
public override void ElementPropertyChanged(ElementPropertyChangedEventArgs e) { base.ElementPropertyChanged(e); ModelEnum element = (ModelEnum)e.ModelElement; if (element.IsDeleted) { return; } Store store = element.Store; Transaction currentTransaction = store.TransactionManager.CurrentTransaction; if (currentTransaction.IsSerializing) { return; } if (Equals(e.NewValue, e.OldValue)) { return; } string errorMessage = null; switch (e.DomainProperty.Name) { case "Name": if (currentTransaction.Name.ToLowerInvariant() == "paste") { return; } if (string.IsNullOrWhiteSpace(element.Name) || !CodeGenerator.IsValidLanguageIndependentIdentifier(element.Name)) { errorMessage = "Name must be a valid .NET identifier"; } else if (store.GetAll <ModelClass>().Any(x => x.FullName == element.FullName)) { errorMessage = "Enum name already in use by a class"; } else if (store.GetAll <ModelEnum>().Except(new[] { element }).Any(x => x.FullName == element.FullName)) { errorMessage = "Enum name already in use by another enum"; } else { // rename type names for ModelAttributes that reference this enum foreach (ModelAttribute modelAttribute in store.GetAll <ModelAttribute>().Where(a => a.Type == (string)e.OldValue)) { modelAttribute.Type = element.Name; if (!string.IsNullOrEmpty(modelAttribute.InitialValue)) { string[] parts = modelAttribute.InitialValue.Split('.'); parts[0] = (string)e.NewValue; modelAttribute.InitialValue = string.Join(".", parts); } } } break; case "Namespace": if (currentTransaction.Name.ToLowerInvariant() != "paste") { errorMessage = CommonRules.ValidateNamespace(element.Namespace, CodeGenerator.IsValidLanguageIndependentIdentifier); } break; case "IsFlags": element.SetFlagValues(); break; case "ValueType": EnumValueType newValueType = (EnumValueType)e.NewValue; List <ModelAttribute> modelAttributes = store.ElementDirectory .AllElements .OfType <ModelAttribute>() .Where(a => a.Type == element.Name && a.IsIdentity) .ToList(); if (modelAttributes.Any()) { string classList = string.Join(", ", modelAttributes.Select(a => a.ModelClass.Name + "." + a.Name)); errorMessage = $"Can't change {element.Name} value type to {newValueType}. It's not a valid identity type, and {element.Name} is used as an identity type in {classList}"; } break; } if (errorMessage != null) { currentTransaction.Rollback(); ErrorDisplay.Show(store, errorMessage); } }
public List <double> GetValues(EnumValueType valueType) { return(valueDict[valueType.ToString()]); }
/// <summary> /// Creates a new variable. /// </summary> private DataItemState CreateMultiStateValueDiscreteItemVariable(NodeState parent, string path, string name, params string[] enumNames) { MultiStateValueDiscreteState variable = new MultiStateValueDiscreteState(parent); variable.NodeId = new NodeId(path, NamespaceIndex); variable.BrowseName = new QualifiedName(path, NamespaceIndex); variable.DisplayName = new LocalizedText("en", name); variable.WriteMask = AttributeWriteMask.None; variable.UserWriteMask = AttributeWriteMask.None; variable.Create( SystemContext, null, variable.BrowseName, null, true); variable.SymbolicName = name; variable.ReferenceTypeId = ReferenceTypes.Organizes; variable.DataType = DataTypeIds.UInt32; variable.ValueRank = ValueRanks.Scalar; variable.AccessLevel = AccessLevels.CurrentReadOrWrite; variable.UserAccessLevel = AccessLevels.CurrentReadOrWrite; variable.Historizing = false; variable.Value = (uint)0; variable.StatusCode = StatusCodes.Good; variable.Timestamp = DateTime.UtcNow; // variable.OnWriteValue = OnWriteDiscrete; // there are two enumerations for this type: // EnumStrings = the string representations for enumerated values // EnumValues = the actual enumerated value // set the enumerated strings LocalizedText[] strings = new LocalizedText[enumNames.Length]; for (int ii = 0; ii < strings.Length; ii++) { strings[ii] = enumNames[ii]; } //variable.EnumStrings = new PropertyState<LocalizedText[]>( variable ); //variable.EnumStrings.Value = strings; //variable.EnumStrings.AccessLevel = AccessLevels.CurrentReadOrWrite; //variable.EnumStrings.UserAccessLevel = AccessLevels.CurrentReadOrWrite; // set the enumerated values EnumValueType[] values = new EnumValueType[enumNames.Length]; for (int ii = 0; ii < values.Length; ii++) { values[ii] = new EnumValueType(); values[ii].Value = ii; values[ii].Description = strings[ii]; values[ii].DisplayName = strings[ii]; } variable.EnumValues.Value = values; variable.EnumValues.AccessLevel = AccessLevels.CurrentReadOrWrite; variable.EnumValues.UserAccessLevel = AccessLevels.CurrentReadOrWrite; variable.ValueAsText.Value = strings[0]; if (parent != null) { parent.AddChild(variable); } return variable; }
private List <int> XMLOnce(XElement nowElement, int parentid) { List <DataType> DataTemp = new List <DataType>(); List <int> IDList = new List <int>(); List <int> childrenIDList = new List <int>(); var keys = from k in nowElement.Elements("key") select k; var values = from v in nowElement.Elements() where v.Name != "key" select v; var valList = values.ToList(); for (int i = 0; i < valList.Count; i++) { int id = ++count; EnumValueType valuetype = (EnumValueType)Enum.Parse(typeof(EnumValueType), valList[i].Name.LocalName.ToString().ToUpper(), true); string value = null; if (valuetype == EnumValueType.ARRAY) { XElement newElement = nowElement.Elements().Except(nowElement.Elements("key")).ElementAt(i); int num = newElement.Elements().Count(); for (int j = 0; j < num; j++) { newElement.AddFirst(new XElement("key", "item")); } childrenIDList = XMLOnce(newElement, id); } else if (valuetype == EnumValueType.DICT) { XElement newElement = nowElement.Elements().Except(nowElement.Elements("key")).ElementAt(i); childrenIDList = XMLOnce(newElement, id); } else if (valuetype == EnumValueType.TRUE) { value = "true"; } else if (valuetype == EnumValueType.FALSE) { value = "false"; } else { value = valList[i].Value.ToString(); } try { DataTemp.Add(new DataType() { DataName = keys.ToList()[i].Value.ToString(), ValueType = valuetype, ID = id, Value = value, parentID = parentid, childrenID = childrenIDList }); } catch (System.Exception ex) { DataTemp.Add(new DataType() { DataName = "itemContent", ValueType = valuetype, ID = id, Value = value, parentID = parentid, childrenID = childrenIDList }); } } foreach (var item in DataTemp) { IDList.Add(item.ID); } DataList.AddRange(DataTemp); return(IDList); }
public static DataType get_data_type_for_symbol(TypeSymbol sym) { DataType type = null; List <TypeParameter> type_parameters = null; if (sym is ObjectTypeSymbol) { type = new ObjectType((ObjectTypeSymbol)sym); type_parameters = ((ObjectTypeSymbol)sym).get_type_parameters(); } else if (sym is Struct) { var st = (Struct)sym; if (st.is_boolean_type()) { type = new BooleanType(st); } else if (st.is_integer_type()) { type = new IntegerType(st); } else if (st.is_floating_type()) { type = new FloatingType(st); } else { type = new StructValueType(st); } type_parameters = st.get_type_parameters(); } else if (sym is ValaEnum) { type = new EnumValueType((ValaEnum)sym); } else if (sym is ErrorDomain) { type = new ErrorType((ErrorDomain)sym, null); } else if (sym is ErrorCode) { type = new ErrorType((ErrorDomain)sym.parent_symbol, (ErrorCode)sym); } else { Report.error(null, "internal error: `%s' is not a supported type".printf(sym.get_full_name())); return(new InvalidType()); } if (type_parameters != null) { foreach (var type_param in type_parameters) { var type_arg = new GenericType(type_param); type_arg.value_owned = true; type.add_type_argument(type_arg); } } return(type); }
private DataType resolve_type(UnresolvedType unresolved_type) { DataType type = null; // still required for vapigen if (unresolved_type.unresolved_symbol.name == "void") { return(new VoidType()); } var sym = resolve_symbol(unresolved_type.unresolved_symbol); if (sym == null) { // don't report same error twice if (!unresolved_type.unresolved_symbol.error) { Report.error(unresolved_type.source_reference, "The type name `%s' could not be found".printf(unresolved_type.unresolved_symbol.ToString())); } return(new InvalidType()); } if (sym is TypeParameter) { type = new GenericType((TypeParameter)sym); } else if (sym is TypeSymbol) { if (sym is ValaDelegate) { type = new DelegateType((ValaDelegate)sym); } else if (sym is Class) { var cl = (Class)sym; if (cl.is_error_base) { type = new ErrorType(null, null, unresolved_type.source_reference); } else { type = new ObjectType(cl); } } else if (sym is Interface) { type = new ObjectType((Interface)sym); } else if (sym is Struct) { type = get_type_for_struct((Struct)sym, (Struct)sym); } else if (sym is ValaEnum) { type = new EnumValueType((ValaEnum)sym); } else if (sym is ErrorDomain) { type = new ErrorType((ErrorDomain)sym, null, unresolved_type.source_reference); } else if (sym is ErrorCode) { type = new ErrorType((ErrorDomain)sym.parent_symbol, (ErrorCode)sym, unresolved_type.source_reference); } else { Report.error(unresolved_type.source_reference, "internal error: `%s' is not a supported type".printf(sym.get_full_name())); return(new InvalidType()); } } else { Report.error(unresolved_type.source_reference, "`%s' is not a type".printf(sym.get_full_name())); return(new InvalidType()); } type.source_reference = unresolved_type.source_reference; type.value_owned = unresolved_type.value_owned; sym.used = true; if (type is GenericType) { // type parameters are always considered nullable // actual type argument may or may not be nullable type.nullable = true; } else { type.nullable = unresolved_type.nullable; } type.is_dynamic = unresolved_type.is_dynamic; foreach (DataType type_arg in unresolved_type.get_type_arguments()) { type.add_type_argument(type_arg); } return(type); }
/// <summary> /// Creates a new variable. /// </summary> private DataItemState CreateMultiStateValueDiscreteItemVariable(NodeState parent, string path, string name, NodeId nodeId, params string[] enumNames) { MultiStateValueDiscreteState variable = new MultiStateValueDiscreteState(parent); variable.NodeId = new NodeId(path, NamespaceIndex); variable.BrowseName = new QualifiedName(path, NamespaceIndex); variable.DisplayName = new LocalizedText("en", name); variable.WriteMask = AttributeWriteMask.None; variable.UserWriteMask = AttributeWriteMask.None; variable.Create( SystemContext, null, variable.BrowseName, null, true); variable.SymbolicName = name; variable.ReferenceTypeId = ReferenceTypes.Organizes; variable.DataType = (nodeId == null) ? DataTypeIds.UInt32 : nodeId; variable.ValueRank = ValueRanks.Scalar; variable.AccessLevel = AccessLevels.CurrentReadOrWrite; variable.UserAccessLevel = AccessLevels.CurrentReadOrWrite; variable.Historizing = false; variable.Value = (uint)0; variable.StatusCode = StatusCodes.Good; variable.Timestamp = DateTime.UtcNow; variable.OnWriteValue = OnWriteValueDiscrete; // there are two enumerations for this type: // EnumStrings = the string representations for enumerated values // ValueAsText = the actual enumerated value // set the enumerated strings LocalizedText[] strings = new LocalizedText[enumNames.Length]; for (int ii = 0; ii < strings.Length; ii++) { strings[ii] = enumNames[ii]; } // set the enumerated values EnumValueType[] values = new EnumValueType[enumNames.Length]; for (int ii = 0; ii < values.Length; ii++) { values[ii] = new EnumValueType(); values[ii].Value = ii; values[ii].Description = strings[ii]; values[ii].DisplayName = strings[ii]; } variable.EnumValues.Value = values; variable.EnumValues.AccessLevel = AccessLevels.CurrentReadOrWrite; variable.EnumValues.UserAccessLevel = AccessLevels.CurrentReadOrWrite; variable.ValueAsText.Value = variable.EnumValues.Value[0].DisplayName; if (parent != null) { parent.AddChild(variable); } return(variable); }
public override DataValue Compute(IAggregationContext context, TimeSlice bucket, AggregateState state) { int numGood = 0; int numBad = 0; int nTransitions = 0; long stateCode = -1; IEnumerator <DataValue> enumerator = bucket.Values.GetEnumerator(); bool bucketValueNotEmpty = enumerator.MoveNext(); if (bucketValueNotEmpty && enumerator.Current != null) { if (bucket.EarlyBound != null) { if (enumerator.Current.SourceTimestamp == bucket.EarlyBound.Timestamp && bucket.EarlyBound.PriorPoint != null) { stateCode = Convert.ToInt32(Convert.ToBoolean(bucket.EarlyBound.PriorPoint.Value)); } else if (bucket.EarlyBound.Value != null) { stateCode = Convert.ToInt32(Convert.ToBoolean(bucket.EarlyBound.Value.Value)); } } } // viz. UA MultiStateNodeState & TwoStateNodeState, // assume DataValue.Value is either an EnumValueType or a bool if (bucketValueNotEmpty) { do { DataValue dv = enumerator.Current; if (state.RawValueIsGood(dv)) { EnumValueType ev = dv.Value as EnumValueType; if (ev == null) { bool b; if (bool.TryParse(dv.Value.ToString(), out b)) { if (stateCode < 0) { stateCode = b ? 1 : 0; } else if (b.CompareTo(Convert.ToBoolean(stateCode)) != 0) { nTransitions++; stateCode = b ? 1 : 0; } } else { continue; } } else { long s = ev.Value; if (stateCode < 0) { stateCode = s; } else if (!s.Equals(stateCode)) { nTransitions++; stateCode = s; } } numGood++; } else { numBad++; } } while (enumerator.MoveNext()); } StatusCode code = ComputeStatus(context, numGood, numBad, bucket).Code; DataValue retval = new DataValue { SourceTimestamp = bucket.From, Value = nTransitions }; code.AggregateBits = AggregateBits.Calculated; if (bucket.Incomplete) { code.AggregateBits |= AggregateBits.Partial; } retval.StatusCode = code; return(retval); }
public EnumInfo(string name, EnumValueType valueType) { Name = name; ValueType = valueType; }
public ModelEnumValueAttribute(string key, EnumValueType type = EnumValueType.ReadWrite) { Key = key; Type = type; }