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;
