public virtual string DetermineActualDataTypeFromXsiType(string modelType, string newTypeFromXsiType, bool isCda, bool isR1 , ErrorLogger errorLogger) { StandardDataType newTypeEnum = EnumPattern.ValueOf <StandardDataType>(newTypeFromXsiType); return(DetermineActualDataType(modelType, newTypeEnum, isCda, isR1, errorLogger)); }
/// <summary>Get the annotation Type</summary> /// <returns>annotation Type</returns> public virtual Ca.Infoway.Messagebuilder.Xml.AnnotationType GetAnnotationTypeAsEnum() { if (this.annotationType != null) { return(EnumPattern.ValueOf <Ca.Infoway.Messagebuilder.Xml.AnnotationType>(this.annotationType)); } return(null); }
private void CheckPartTypeForOn(NamePartType type, FormatContext context) { // valid types are null, delimiter, prefix, suffix if (type != null) { string typeValue = type.Value == null ? null : type.Value.ToUpper(); //.NET conversion OrganizationNamePartType onType = EnumPattern.ValueOf <OrganizationNamePartType>(typeValue); if (onType == null) { RecordError(context, System.String.Format("Name parts of type {0} are not valid for ON data types. Only delimiter, prefix, suffix, and free-format text are allowed." , type.Value)); } } }
/// <summary> /// Wrapper for Convert.ChangeType, to get around the issue of the said method not supporting /// Nullable types. This method simple extracts the unerlying type if it's Nullable based and /// then pass through to Convert.ChangeType. /// </summary> /// <param name="value">Value to be converted</param> /// <param name="conversionType">Type to convert to</param> /// <returns></returns> public static object ChangeType(object o, Type conversionType) { if (conversionType == null) { throw new ArgumentNullException("conversionType"); } if (o == null) { return(null); } else if (conversionType.IsEnum) { string s = (string)o; return(System.Enum.Parse(conversionType, s)); } else if (conversionType.Equals(typeof(Cardinality))) { string s = (string)o; return(Cardinality.Create(s)); } else if (conversionType.IsSubclassOf(typeof(EnumPattern))) { return(EnumPattern.ValueOf <EnumPattern>(conversionType, (string)o)); } else // // If it's not a nullable type, just pass through the parameters to Convert.ChangeType. // if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable <>))) { if (o == null) { return(null); } conversionType = Nullable.GetUnderlyingType(conversionType); } return(Convert.ChangeType(o, conversionType)); }
private void HandleRepresentation(EncapsulatedData ed, XmlElement element, ParseContext context, XmlToModelResult result) { if (element.HasAttribute("representation")) { string representationString = element.GetAttribute("representation"); try { EdRepresentation representation = EnumPattern.ValueOf <EdRepresentation>(representationString); if (!StringUtils.IsBlank(representationString) && representation == null) { //Invalid enum value throw new ArgumentException(); } ed.Representation = representation; } catch (Exception) { RecordError("Unknown value for representation: " + representationString, element, result); } } }
private void HandleIntegrityCheckAlgorithm(EncapsulatedData ed, XmlElement element, ParseContext context, XmlToModelResult result) { if (element.HasAttribute("integrityCheckAlgorithm")) { string icaString = element.GetAttribute("integrityCheckAlgorithm"); try { IntegrityCheckAlgorithm ica = EnumPattern.ValueOf <IntegrityCheckAlgorithm>(icaString); if (!StringUtils.IsBlank(icaString) && ica == null) { //Invalid enum value throw new ArgumentException(); } ed.IntegrityCheckAlgorithm = ica; } catch (Exception) { RecordError("Unknown value for integrityCheckAlgorithm: " + icaString, element, result); } } }