/// <summary> /// If <paramref name="type"/> has been registered with a <see cref="DataViewType"/>, this function returns <see langword="true"/>. /// Otherwise, this function returns <see langword="false"/>. /// </summary> internal static bool Knows(Type type, IEnumerable <Attribute> typeAttributes = null) { //Filter attributes as we only care about DataViewTypeAttribute DataViewTypeAttribute typeAttr = null; if (typeAttributes != null) { typeAttributes = typeAttributes.Where(attr => attr.GetType().IsSubclassOf(typeof(DataViewTypeAttribute))); if (typeAttributes.Count() > 1) { throw Contracts.ExceptParam(nameof(type), "Type {0} cannot be marked with multiple attributes, {1}, derived from {2}.", type.Name, typeAttributes, typeof(DataViewTypeAttribute)); } else if (typeAttributes.Count() == 1) { typeAttr = typeAttributes.First() as DataViewTypeAttribute; } } lock (_lock) { // Compute the ID of type with extra attributes. var rawType = new TypeWithAttributes(type, typeAttr); // Check if this ID has been associated with a DataViewType. // Note that the dictionary below contains (rawType, dataViewType) pairs (key type is TypeWithAttributes, and value type is DataViewType). if (_rawTypeToDataViewTypeMap.ContainsKey(rawType)) { return(true); } else { return(false); } } }
/// <summary> /// Returns the <see cref="DataViewType"/> registered for <paramref name="type"/> and its <paramref name="typeAttributes"/>. /// </summary> internal static DataViewType GetDataViewType(Type type, IEnumerable <Attribute> typeAttributes = null) { //Filter attributes as we only care about DataViewTypeAttribute DataViewTypeAttribute typeAttr = null; if (typeAttributes != null) { typeAttributes = typeAttributes.Where(attr => attr.GetType().IsSubclassOf(typeof(DataViewTypeAttribute))); if (typeAttributes.Count() > 1) { throw Contracts.ExceptParam(nameof(type), "Type {0} cannot be marked with multiple attributes, {1}, derived from {2}.", type.Name, typeAttributes, typeof(DataViewTypeAttribute)); } else if (typeAttributes.Count() == 1) { typeAttr = typeAttributes.First() as DataViewTypeAttribute; } } lock (_lock) { // Compute the ID of type with extra attributes. var rawType = new TypeWithAttributes(type, typeAttr); // Get the DataViewType's ID which typeID is mapped into. if (!_rawTypeToDataViewTypeMap.TryGetValue(rawType, out DataViewType dataViewType)) { throw Contracts.ExceptParam(nameof(type), $"The raw type {type} with attributes {typeAttributes} is not registered with a DataView type."); } // Retrieve the actual DataViewType identified by dataViewType. return(dataViewType); } }
public static void Register(DataViewType dataViewType, Type type, IEnumerable <Attribute> typeAttributes) { DataViewTypeAttribute typeAttr = null; if (typeAttributes != null) { if (typeAttributes.Count() > 1) { throw Contracts.ExceptParam(nameof(type), $"Type {type} has too many attributes."); } else if (typeAttributes.Count() == 1) { var attr = typeAttributes.First(); if (!attr.GetType().IsSubclassOf(typeof(DataViewTypeAttribute))) { throw Contracts.ExceptParam(nameof(type), $"Type {type} has an attribute that is not of DataViewTypeAttribute."); } else { typeAttr = attr as DataViewTypeAttribute; } } } Register(dataViewType, type, typeAttr); }
/// <summary> /// This function tells that <paramref name="dataViewType"/> should be representation of data in <paramref name="type"/> in /// ML.NET's type system. The registered <paramref name="type"/> must be a standard C# object's type. /// </summary> /// <param name="type">Native type in C#.</param> /// <param name="dataViewType">The corresponding type of <paramref name="type"/> in ML.NET's type system.</param> /// <param name="typeAttribute">The <see cref="DataViewTypeAttribute"/> attached to <paramref name="type"/>.</param> public static void Register(DataViewType dataViewType, Type type, DataViewTypeAttribute typeAttribute = null) { lock (_lock) { if (_bannedRawTypes.Contains(type)) { throw Contracts.ExceptParam(nameof(type), $"Type {type} has been registered as ML.NET's default supported type, " + $"so it can't not be registered again."); } var rawType = new TypeWithAttributes(type, typeAttribute); if (_rawTypeToDataViewTypeMap.ContainsKey(rawType) && _rawTypeToDataViewTypeMap[rawType].Equals(dataViewType) && _dataViewTypeToRawTypeMap.ContainsKey(dataViewType) && _dataViewTypeToRawTypeMap[dataViewType].Equals(rawType)) { // This type pair has been registered. Note that registering one data type pair multiple times is allowed. return; } if (_rawTypeToDataViewTypeMap.ContainsKey(rawType) && !_rawTypeToDataViewTypeMap[rawType].Equals(dataViewType)) { // There is a pair of (rawType, anotherDataViewType) in _typeToDataViewType so we cannot register // (rawType, dataViewType) again. The assumption here is that one rawType can only be associated // with one dataViewType. var associatedDataViewType = _rawTypeToDataViewTypeMap[rawType]; throw Contracts.ExceptParam(nameof(type), $"Repeated type register. The raw type {type} " + $"has been associated with {associatedDataViewType} so it cannot be associated with {dataViewType}."); } if (_dataViewTypeToRawTypeMap.ContainsKey(dataViewType) && !_dataViewTypeToRawTypeMap[dataViewType].Equals(rawType)) { // There is a pair of (dataViewType, anotherRawType) in _dataViewTypeToType so we cannot register // (dataViewType, rawType) again. The assumption here is that one dataViewType can only be associated // with one rawType. var associatedRawType = _dataViewTypeToRawTypeMap[dataViewType].TargetType; throw Contracts.ExceptParam(nameof(dataViewType), $"Repeated type register. The DataView type {dataViewType} " + $"has been associated with {associatedRawType} so it cannot be associated with {type}."); } _rawTypeToDataViewTypeMap.Add(rawType, dataViewType); _dataViewTypeToRawTypeMap.Add(dataViewType, rawType); } }
public TypeWithAttributes(Type type, DataViewTypeAttribute attribute) { TargetType = type; _associatedAttribute = attribute; }