internal static void WriteBottomPatternAndBytes(EnumPattern pattern, byte[] bytes) { var counter = bytes[0] != 0 ? 3 : bytes[1] != 0 ? 2 : bytes[2] != 0 ? 1 : 0; _buffer.WriteByte((byte)((int)pattern | counter)); _buffer.Write(bytes, bytes.Length - counter - 1, counter + 1); }
/// <summary>Gets the resolver.</summary> /// <remarks>Gets the resolver.</remarks> /// <TBD></TBD> /// <param name="type">the type</param> /// <returns>the resolver</returns> public virtual CodeResolver GetResolver <T>(Type type) where T : Code { if (this.resolvers.ContainsKey(type)) { return(this.resolvers.SafeGet(type)); } else { if (EnumPattern.IsEnum(type)) // or EnumPattern { // not sure that this is the ideal behaviour here; do we want to return a resolver for something not registered? // (though this *is* what happens when this.instance is not null) return(new EnumBasedCodeResolver((Type)type)); } else { if (this.instance == null) { throw new InvalidOperationException("No code resolver established for " + type.FullName + "."); } else { return(this.instance); } } } }
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); }
internal static void WriteTagWithLength(int length, EnumPattern topPattern, EnumPattern bottomPattern) { if (length > 63 || length < 0) { var bytes = LittleEndianToNetworkOrderBitConverter.GetBytes(length); WriteBottomPatternAndBytes(bottomPattern, bytes); } else { _buffer.WriteByte((byte)((int)topPattern | length)); } }
/// <exception cref="Ca.Infoway.Messagebuilder.Marshalling.HL7.XmlToModelTransformationException"></exception> protected virtual S GetNamePartType <S>(string value) where S : NamePartType { System.Type type = typeof(S); foreach (S partType in EnumPattern.Values <S>(type)) { if (partType.Value.Equals(value)) { return(partType); } } throw new XmlToModelTransformationException("Unexpected part of type: " + value); }
public virtual void TestAllHl7ErrorCodesAreInErrorCode() { IList <Hl7ErrorCode> oldErrorCode = EnumPattern.Values <Hl7ErrorCode>(); for (int i = 0; i < oldErrorCode.Count; i++) { ErrorCode newErrorCode = TransformError.TransformCode(oldErrorCode[i]); if (newErrorCode == null) { Assert.Fail("ErrorCode is missing Hl7ErrorCode: " + oldErrorCode[i].Name); } } }
public static SetOperator FindMatchingOperator(String operatorString) { SetOperator result = null; foreach (SetOperator setOperator in EnumPattern.Values <SetOperator>(typeof(SetOperator))) { if (setOperator.CodeValue.Equals(operatorString)) { result = setOperator; break; } } return(result); }
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)); } } }
public static ErrorCode TransformCode(Hl7ErrorCode hl7ErrorCode) { if (hl7ErrorCode == null) { return(null); } IList <ErrorCode> values = EnumPattern.Values <ErrorCode>(); string name = hl7ErrorCode.Name; for (int i = 0; i < values.Count; i++) { if (StringUtils.Equals(values[i].Name, name)) { return(values[i]); } } return(null); }
/// <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); } } }
private CalendarCycle ObtainAlignment(ParseContext context, XmlElement element, XmlToModelResult xmlToModelResult) { CalendarCycle alignment = null; if (element.HasAttribute("alignment")) { string alignmentString = element.GetAttribute("alignment"); foreach (CalendarCycle calendarCycle in EnumPattern.Values <CalendarCycle>()) { if (StringUtils.Equals(calendarCycle.CalendarCycleCode, alignmentString)) { alignment = calendarCycle; break; } } if (alignment == null) { xmlToModelResult.AddHl7Error(new Hl7Error(Hl7ErrorCode.DATA_TYPE_ERROR, "Alignment attribute is not a valid CalendarCycle value. Value found: \"" + alignmentString + "\"", element)); } } return(alignment); }
internal static void WriteLongPattern(EnumPattern shortPattern, EnumPattern longPattern, byte[] bytes) { var counter = 0; for (var nc = 0; nc != 7; nc++) { if (bytes[nc] != 0) { counter = 7 - nc; break; } } if (counter > 3) { _buffer.WriteByte((byte)((byte)longPattern | counter - 4)); } else { _buffer.WriteByte((byte)((byte)shortPattern | counter)); } _buffer.Write(bytes, bytes.Length - counter - 1, counter + 1); }
/// <summary> /// 自定义正则验证 /// </summary> /// <param name="checkText">需要验证的文本</param> /// <param name="pattern">正则表达式</param> /// <returns></returns> public static bool Check(string checkText, EnumPattern pattern) { return(new Regex(regArray[(int)pattern]).IsMatch(checkText)); }
/// <summary>Obtains the media type registered for the supplied mime type.</summary> /// <remarks> /// Obtains the media type registered for the supplied mime type. /// Returns null if no media type could be found. /// </remarks> /// <param name="mimeType">the mimetype to match</param> /// <returns>the applicable X_DocumentMediaType</returns> public static Ca.Infoway.Messagebuilder.Domainvalue.Basic.X_DocumentMediaType Get(string mimeType) { Ca.Infoway.Messagebuilder.Domainvalue.Basic.X_DocumentMediaType result = null; foreach (Ca.Infoway.Messagebuilder.Domainvalue.Basic.X_DocumentMediaType X_DocumentMediaType in EnumPattern.Values <Ca.Infoway.Messagebuilder.Domainvalue.Basic.X_DocumentMediaType >()) { if (X_DocumentMediaType.MimeType.Equals(mimeType)) { result = X_DocumentMediaType; break; } } return(result); }
internal static void Write(EnumPattern pattern) => Write((byte)pattern);
internal void DeserializeValue(byte value) { switch (State) { case EnumState.INIT: Pattern = value.RetrieveFlagPattern(); switch (Pattern) { case EnumPattern.STRING_SHORT_PATTERN: _partLength = value.RetrievePartLength(Pattern); if (_partLength > 0) { State = EnumState.DATA; } else { OnDeserializedValue(""); } break; case EnumPattern.STRING_PATTERN: _partLength = value.RetrievePartLength(Pattern) + 1; State = EnumState.HEADER; break; case EnumPattern.BYTE_ARRAY_SHORT_PATTERN: _partLength = value.RetrievePartLength(Pattern); if (_partLength > 0) { State = EnumState.DATA; } else { OnDeserializedValue(new byte[] { }); } break; case EnumPattern.BYTE_ARRAY_PATTERN: _partLength = value.RetrievePartLength(Pattern) + 1; State = EnumState.HEADER; break; case EnumPattern.UNSIGNED_INT_SHORT_PATTERN: OnDeserializedValue(value.RetrievePartLength(Pattern)); break; case EnumPattern.UNSIGNED_INT_PATTERN: _partLength = value.RetrievePartLength(Pattern) + 1; State = EnumState.DATA; break; case EnumPattern.INT_PATTERN: _partLength = value.RetrievePartLength(Pattern) + 1; State = EnumState.DATA; break; case EnumPattern.UNSIGNED_LONG_SHORT_PATTERN: _partLength = 1; State = EnumState.DATA; break; case EnumPattern.UNSIGNED_LONG_PATTERN: _partLength = 6; State = EnumState.DATA; break; case EnumPattern.LONG_SHORT_PATTERN: _partLength = 1; State = EnumState.DATA; break; case EnumPattern.LONG_PATTERN: _partLength = 6; State = EnumState.DATA; break; case EnumPattern.DOUBLE_PATTERN: _partLength = 8; State = EnumState.DATA; break; case EnumPattern.FLOAT_PATTERN: _partLength = 4; State = EnumState.DATA; break; case EnumPattern.BOOLEAN_TRUE_PATTERN: OnDeserializedValue(true); break; case EnumPattern.BOOLEAN_FALSE_PATTERN: OnDeserializedValue(false); break; } break; case EnumState.HEADER: _buffer.WriteByte(value); if (_buffer.Position == _partLength) { var buffer = _buffer.ToArray().Reverse().ToArray(); var length = new List <byte>(4) { 0, 0, 0, 0 }.Select((b, index) => index <= _partLength - 1 ? buffer[index] : (byte)0); _partLength = BitConverter.ToInt32(length.ToArray(), 0); State = EnumState.DATA; _buffer.Position = 0; } break; case EnumState.DATA: _buffer.WriteByte(value); if (_buffer.Position == _partLength) { var buffer = _buffer.ToArray(); var length = new List <byte>(8) { 0, 0, 0, 0, 0, 0, 0, 0 }.Select((v, index) => index <= _partLength - 1 ? buffer[index] : (byte)0); Array.Reverse(buffer, 0, _partLength); switch (Pattern) { case EnumPattern.STRING_SHORT_PATTERN: case EnumPattern.STRING_PATTERN: OnDeserializedValue(Encoding.UTF8.GetString(_buffer.ToArray())); break; case EnumPattern.UNSIGNED_INT_PATTERN: OnDeserializedValue(BitConverter.ToUInt32(length.ToArray(), 0)); break; case EnumPattern.INT_PATTERN: OnDeserializedValue(BitConverter.ToInt32(length.ToArray(), 0)); break; case EnumPattern.UNSIGNED_LONG_SHORT_PATTERN: case EnumPattern.UNSIGNED_LONG_PATTERN: OnDeserializedValue(BitConverter.ToUInt64(length.ToArray(), 0)); break; case EnumPattern.LONG_SHORT_PATTERN: case EnumPattern.LONG_PATTERN: OnDeserializedValue(BitConverter.ToInt64(length.ToArray(), 0)); break; case EnumPattern.DOUBLE_PATTERN: OnDeserializedValue(BitConverter.ToDouble(length.ToArray(), 0)); break; case EnumPattern.FLOAT_PATTERN: OnDeserializedValue(BitConverter.ToSingle(length.ToArray(), 0)); break; case EnumPattern.BYTE_ARRAY_SHORT_PATTERN: case EnumPattern.BYTE_ARRAY_PATTERN: OnDeserializedValue(_buffer.ToArray()); break; } _buffer = new MemoryStream(); } break; } }
internal static int RetrievePartLength(this byte input, EnumPattern pattern) => input & ~(byte)pattern;