public override object Parse(string toParse, Type typeToParse, ITypeParserContainer parserContainer) { object _returnVal; if (!_parseEnumAsArray && typeToParse.GetCustomAttribute <FlagsAttribute>() != null) { _parseEnumAsArray = true; Type _enumArrayType = typeToParse.MakeArrayType(); ITypeParser _arrayParser = parserContainer.GetParser(_enumArrayType); Array _enumArray = _arrayParser.Parse(toParse, _enumArrayType, parserContainer) as Array; int _totalVal = 0; int _iter = 0; foreach (object enVal in _enumArray) { if (_iter == 0) { _totalVal = (int)enVal; } else { _totalVal = _totalVal | (int)enVal; } _iter++; } _returnVal = _totalVal; _parseEnumAsArray = false; } else { _returnVal = Enum.Parse(typeToParse, toParse, true); } return(_returnVal); }
private void MapImpl(Type targetWorkItemType, IWorkItem sourceWorkItem, TypeAccessor accessor, object targetWorkItem) { #if DEBUG Trace.TraceInformation("{0}: Mapping {1}", GetType().Name, sourceWorkItem.Id); #endif foreach (var property in PropertiesOnWorkItemCache(_inspector, sourceWorkItem, targetWorkItemType, typeof(FieldDefinitionAttribute))) { var a = PropertyInfoFieldCache(_inspector, property); if (a == null) { continue; } var fieldName = a.FieldName; var convert = a.RequireConversion; try { if (convert) { var value = _typeParser.Parse(property.PropertyType, sourceWorkItem[fieldName]); accessor[targetWorkItem, property.Name] = value; } else { accessor[targetWorkItem, property.Name] = sourceWorkItem[fieldName]; } } catch (Exception e) { try { Trace.TraceWarning( "Could not convert value of field '{0}' ({1}) to type {2}", fieldName, sourceWorkItem[fieldName].GetType().Name, property.PropertyType.Name); } catch (Exception) { } try { Trace.TraceWarning( "Could not map field '{0}' from type '{1}' to type '{2}'. {3}", fieldName, sourceWorkItem.Type.Name, targetWorkItemType.Name, e.Message); } catch (Exception) { } } } }
public async Task <Result> InvokeAsync(TInput context, CancellationToken cancellationToken) { if (parser.Parse(context).TryGetValue(out var value)) { return(await command.InvokeAsync(value, cancellationToken).ConfigureAwait(false)); } return(Result.None); }
public void CreateDocumentation(string outputDirectory, List <Type> typesInNamespaces, XDocument assemblyDocumentation = null) { List <ContractDescription> contractDescriptions = m_typePaser.Parse(typesInNamespaces, assemblyDocumentation); foreach (ContractDescription contractDescription in contractDescriptions) { m_documentationWriter.WriteDocumenation(contractDescription, outputDirectory); } }
private object ParseElement(string toParse, Type type, ITypeParserContainer parserContainer) { ITypeParser _parser = parserContainer.GetParser(type); if (_parser == null) { throw new Exception($"Parsing type '{type.Name}' not handled"); } return(_parser.Parse(toParse, type, parserContainer)); }
public void CreateDocumentation(string outputDirectory, List <Type> typesInNamespaces, XDocument assemblyDocumentation = null) { List <ServiceDescription> contractDescriptions = m_TypeParser.Parse(typesInNamespaces, assemblyDocumentation); foreach (ServiceDescription contractDescription in contractDescriptions) { m_DocumentationWriter.WriteDocumenation(contractDescription, outputDirectory); m_ContractDocumentationProcesor.CreateDocumentation(outputDirectory, contractDescription.TypesServiceDependsOn, assemblyDocumentation); } }
private bool TryConvert(Type from, string value, out object parsed) { parsed = null; ITypeParser parser = Parser.GetParserForType(from); if (parser == null) { return(false); } parsed = parser.Parse(value); return(parsed != null); }
public async Task <Result> InvokeAsync(TInput context, CancellationToken cancellationToken) { if (parser.Parse(context).TryGetValue(out var option)) { if (option.TryGetValue(out var value)) { return(await command.InvokeAsync(value, cancellationToken)); } return(Result.None); } return(Result.Aborted); }
/// <summary> /// Generates the data table row collection. /// </summary> /// <param name="table">The data table.</param> /// <param name="className">Name of the class.</param> /// <param name="rowInfos">The list of DataTableRow.</param> /// <returns>The data collection of data table row.</returns> private static List <DataTableRow> GenerateDataTableRowCollection(DataTable table, string namespaceString, string className, List <DataTableRowInfo> rowInfos) { List <DataTableRow> dataCollection = new List <DataTableRow>(); string classFullName = className; if (!string.IsNullOrEmpty(namespaceString)) { classFullName = string.Format("{0}.{1}", namespaceString, classFullName); } DataTablePreferences preferencesData = DataTablePreferencesWindow.LoadPreferencesData(); if (preferencesData) { int rowCount = table.Rows.Count; for (int i = preferencesData.DataRowsStartRow - 1; i < rowCount; ++i) { DataTableRow rowData = (DataTableRow)UnityReflectionUtil.CreateInstance(classFullName); for (int j = 0, propertiesCount = rowInfos.Count; j < propertiesCount; ++j) { string cellValue = table.Rows[i][j].ToString().Trim(); if (!string.IsNullOrEmpty(cellValue)) { DataTableRowInfo rowInfo = rowInfos[j]; ITypeParser typeParser = GetTypeParser(rowInfo.Type); if (typeParser != null) { object value = typeParser.Parse(cellValue); ReflectionUtil.SetObjectPropertyValue(rowData, rowInfo.PropertyName, value); } else { Debug.LogWarningFormat("Type '{0}' is not supported!", rowInfo.Type); } } } dataCollection.Add(rowData); } } return(dataCollection); }
private void SetPropertyValues() { foreach (SwitchParameterEntity _switch in _inputSwitches) { if (_switch.MatchException != null) { continue; } try { object _propVal = _typeParser.Parse(_switch.InputValue, _switch.SwitchProperty.PropertyType); _switch.SwitchProperty.SetValue(_paramsObject, _propVal, new object[0]); } catch (Exception ex) { _switch.PropertySetException = ex; } } }
private CSharpLanguageProvider() { _identifierComparer = new CodeIdentifierComparer(StringComparer.Ordinal); _typeEqualityComparerWithoutNRT = new TypeEqualityComparer(_identifierComparer, _identifierComparer, true, false); _typeEqualityComparerWithoutNullability = new TypeEqualityComparer(_identifierComparer, _identifierComparer, true, true); _typeEqualityComparerWithNRT = new TypeEqualityComparer(_identifierComparer, _identifierComparer, false, false); _typeParser = new TypeParser(this); _builder = new CodeBuilder(this); var aliasedTypes = new Dictionary <IType, string>(_typeEqualityComparerWithoutNullability); _aliasedTypes = aliasedTypes; // don't use WellKnownTypes here to avoid circular dependency aliasedTypes.Add(_typeParser.Parse <byte>(), "byte"); aliasedTypes.Add(_typeParser.Parse <sbyte>(), "sbyte"); aliasedTypes.Add(_typeParser.Parse <short>(), "short"); aliasedTypes.Add(_typeParser.Parse <ushort>(), "ushort"); aliasedTypes.Add(_typeParser.Parse <int>(), "int"); aliasedTypes.Add(_typeParser.Parse <uint>(), "uint"); aliasedTypes.Add(_typeParser.Parse <long>(), "long"); aliasedTypes.Add(_typeParser.Parse <ulong>(), "ulong"); aliasedTypes.Add(_typeParser.Parse <decimal>(), "decimal"); aliasedTypes.Add(_typeParser.Parse <float>(), "float"); aliasedTypes.Add(_typeParser.Parse <double>(), "double"); aliasedTypes.Add(_typeParser.Parse <object>(), "object"); aliasedTypes.Add(_typeParser.Parse <bool>(), "bool"); aliasedTypes.Add(_typeParser.Parse <char>(), "char"); aliasedTypes.Add(_typeParser.Parse <string>(), "string"); aliasedTypes.Add(_typeParser.Parse <nint>(), "nint"); aliasedTypes.Add(_typeParser.Parse <nuint>(), "nuint"); aliasedTypes.Add(_typeParser.Parse(typeof(void)), "void"); }
public Option <object> Parse(TInput input) { return(typeParser.Parse(input)); }
protected internal virtual void AssignFieldValue( [NotNull] Type targetWorkItemType, [NotNull] IWorkItem sourceWorkItem, [NotNull] object targetWorkItem, [NotNull] PropertyInfo property, [NotNull] string fieldName, bool convert, [CanBeNull] object nullSub, [CanBeNull] object fieldValue) { // Coalesce fieldValue and nullSub if (fieldValue == null && nullSub != null) { fieldValue = nullSub; } else { if (fieldValue is string value && string.IsNullOrWhiteSpace(value)) { fieldValue = nullSub; } } var destType = property.PropertyType; if (fieldValue == null && destType.IsValueType) { // Value types do not accept null; don't do any work return; } if (fieldValue == null && destType.CanAcceptNull()) { // Destination is a nullable or can take null; don't do any work return; } if (convert) { try { fieldValue = _typeParser.Parse(destType, fieldValue); } catch (Exception e) { var tm = new TypePair(sourceWorkItem, targetWorkItemType); var pm = new PropertyMap(property, fieldName); var message = $"Unable to convert field value on {sourceWorkItem.Id}."; throw new AttributeMapException(message, e, tm, pm); } } var accessor = TypeAccessor.Create(targetWorkItemType, true); try { accessor[targetWorkItem, property.Name] = fieldValue; } catch (Exception e) { var tm = new TypePair(sourceWorkItem, targetWorkItemType); var pm = new PropertyMap(property, fieldName); var message = $"Unable to set field value on {sourceWorkItem.Id}."; throw new AttributeMapException(message, e, tm, pm); } }
private ITypeInfo GetTypeInfoFromTypeFullName([NotNull] IConfigurationFileElement requestingConfigurationFileElement, [NotNull] string typeFullName, [NotNull][ItemNotNull] IEnumerable <ITypeInfo> genericTypeParameters, [CanBeNull] string typeAttributeName, [CanBeNull] string assemblyAttributeName) { ITypeData typeData = null; try { typeData = _typeParser.Parse(typeFullName); } catch (ParseTypeException e) { var errorMessage = new StringBuilder(); errorMessage.AppendLine($"Failed to parse the value of '{typeFullName}' into a valid type name."); string errorLocationText; if (typeAttributeName != null) { errorLocationText = $"Error location: {typeAttributeName}=\""; errorMessage.AppendLine($"{errorLocationText}{typeFullName}\""); } else { errorLocationText = "Error location: "; errorMessage.AppendLine($"{errorLocationText}{typeFullName}"); } errorMessage.Append(new string('_', errorLocationText.Length + e.ErrorIndex)); // 2191=up arrow. See https://www.key-shortcut.com/en/writing-systems/35-symbols/arrows/ errorMessage.AppendLine($"{'\u2191'}"); errorMessage.AppendLine(e.Message); throw new ConfigurationParseException(requestingConfigurationFileElement, errorMessage.ToString()); } List <ITypeInfo> genericTypeParametersList; ITypeInfo typeInfo; if (typeData.GenericTypeParameters.Count == 0) { genericTypeParametersList = new List <ITypeInfo>(genericTypeParameters ?? Enumerable.Empty <ITypeInfo>()); typeInfo = GetTypeInfo2(requestingConfigurationFileElement, typeData, assemblyAttributeName, genericTypeParametersList); } else { if (genericTypeParameters != null && genericTypeParameters.Any()) { throw new ConfigurationParseException(requestingConfigurationFileElement, "Child elements with type parameters are not allowed if the type full name already uses generic type parameters."); } typeInfo = GetTypeInfoRecursivelly(requestingConfigurationFileElement, typeData, assemblyAttributeName); } if (typeInfo == null) { throw new ConfigurationParseException(requestingConfigurationFileElement, "Failed to load the type. We should never get here, since an exception should have been thrown before we get here."); } _pluginAssemblyTypeUsageValidator.Validate(requestingConfigurationFileElement, typeInfo); return(typeInfo); }
Option <TOutput> ITypeParser <TInput, TOutput> .Parse(TInput input) { return(typeParser.Parse(func.Invoke(input))); }