/// <summary> Parses the value string into a recognized type. If
/// the type specified is not supported, the data will
/// be held and returned as a string.
/// *
/// </summary>
/// <param name="key">the context key for the data
/// </param>
/// <param name="type">the data type
/// </param>
/// <param name="value">the data
///
/// </param>
public DataInfo(System.String key, System.String type, System.String value_Renamed) {
this.key = key;
if (type.ToUpper().Equals(TYPE_BOOLEAN.ToUpper())) {
this.data = System.Boolean.Parse(value_Renamed);
} else if (type.ToUpper().Equals(TYPE_NUMBER.ToUpper())) {
if (value_Renamed.IndexOf((System.Char) '.') >= 0) {
//UPGRADE_TODO: Format of parameters of constructor 'java.lang.Double.Double' are different in the equivalent in .NET. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1092"'
this.data = System.Double.Parse(value_Renamed);
} else {
this.data = System.Int32.Parse(value_Renamed);
}
} else {
this.data = value_Renamed;
}
}
private static System.Drawing.Bitmap CreateBarcode(System.String data)
{
data = data.ToUpper();
Bitmap barCode = new Bitmap(1, 1);
Font threeOfNine = new Font("Free 3 of 9", 60, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point);
Font timesNR = new Font("Times New Roman", 20, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point);
Graphics graphics = Graphics.FromImage(barCode);
SizeF dataSize = new SizeF();
SizeF dataSize_bar = graphics.MeasureString(data, threeOfNine);
SizeF dataSize_text = graphics.MeasureString(data, timesNR);
if (dataSize_bar.Width > dataSize_text.Width)
{
dataSize.Width = dataSize_bar.Width;
}
else
{
dataSize.Width = dataSize_text.Width;
}
dataSize.Height = (dataSize_bar.Height + dataSize_text.Height);
barCode = new Bitmap(barCode, dataSize.ToSize());
graphics = Graphics.FromImage(barCode);
graphics.Clear(Color.White);
graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.SingleBitPerPixel;
graphics.DrawString(data, threeOfNine, new SolidBrush(Color.Black), ((dataSize.Width / 2f) - (dataSize_bar.Width / 2f)), 0);
graphics.DrawString(data, timesNR, new SolidBrush(Color.Black), ((dataSize.Width / 2f) - (dataSize_text.Width / 2f)), dataSize_bar.Height);
graphics.Flush();
threeOfNine.Dispose();
graphics.Dispose();
return barCode;
}
/// <summary> Changes the analysis level of the KAIST morpheme tag.</summary>
/// <param name="tag">- morpheme tag
/// </param>
/// <param name="level">- the analysis level
/// </param>
/// <returns> the morpheme tag on the analysis level
/// </returns>
public static System.String getKaistTagOnLevel(System.String tag, int level)
{
if (tag == null || level > 4 || level < 1)
{
return null;
}
int tagLen = tag.Length;
if (tagLen > level)
{
return tag.Substring(0, (level) - (0)).ToUpper();
}
else
{
return tag.ToUpper();
}
}
/// <summary> Queries the normative database for a list of segments comprising
/// the message structure. The returned list may also contain strings
/// that denote repetition and optionality. Choice indicators (i.e. begin choice,
/// next choice, end choice) for alternative segments are ignored, so that the class
/// structure allows all choices. The matter of enforcing that only a single choice is
/// populated can't be handled by the class structure, and should be handled elsewhere.
/// </summary>
private static NuGenSegmentDef[] getSegments(System.String message, System.String version)
{
/*String sql = "select HL7Segments.seg_code, repetitional, optional, description " +
"from (HL7MsgStructIDSegments inner join HL7Segments on HL7MsgStructIDSegments.seg_code = HL7Segments.seg_code " +
"and HL7MsgStructIDSegments.version_id = HL7Segments.version_id) " +
"where HL7Segments.version_id = 6 and message_structure = '" + message + "' order by seq_no";*/
System.String sql = getSegmentListQuery(message, version);
//System.out.println(sql.toString());
NuGenSegmentDef[] segments = new NuGenSegmentDef[200]; //presumably there won't be more than 200
System.Data.OleDb.OleDbConnection conn = NuGenNormativeDatabase.Instance.Connection;
System.Data.OleDb.OleDbCommand stmt = SupportClass.TransactionManager.manager.CreateStatement(conn);
System.Data.OleDb.OleDbCommand temp_OleDbCommand;
temp_OleDbCommand = stmt;
temp_OleDbCommand.CommandText = sql;
System.Data.OleDb.OleDbDataReader rs = temp_OleDbCommand.ExecuteReader();
int c = - 1;
while (rs.Read())
{
System.String name = NuGenSegmentGenerator.altSegName(System.Convert.ToString(rs[1 - 1]));
bool repeating = rs.GetBoolean(2 - 1);
bool optional = rs.GetBoolean(3 - 1);
System.String desc = System.Convert.ToString(rs[4 - 1]);
System.String groupName = version.ToUpper().Equals("2.3.1".ToUpper())?null:System.Convert.ToString(rs[6 - 1]); //group names are defined in DB for 2.3.1 but not used in the schema
//ignore the "choice" directives ... the message class structure has to include all choices ...
// if this is enforced (i.e. exception thrown if >1 choice populated) this will have to be done separately.
if (!(name.Equals("<") || name.Equals("|") || name.Equals(">")))
{
c++;
segments[c] = new NuGenSegmentDef(name, groupName, !optional, repeating, desc);
}
}
NuGenSegmentDef[] ret = new NuGenSegmentDef[c + 1];
Array.Copy(segments, 0, ret, 0, c + 1);
return ret;
}
/// <summary> Creates a new instance of HasAttributeFilter that accepts tags
/// with the given attribute and value.
/// </summary>
/// <param name="attribute">The attribute to search for.
/// </param>
/// <param name="value">The value that must be matched,
/// or null if any value will match.
/// </param>
public HasAttributeFilter(System.String attribute, System.String value_Renamed)
{
mAttribute = attribute.ToUpper(new System.Globalization.CultureInfo("en"));
mValue = value_Renamed;
}
/// <summary> Creates a TagNameFilter that accepts tags with the given name.</summary>
/// <param name="name">The tag name to match.
/// </param>
public TagNameFilter(System.String name)
{
mName = name.ToUpper(new System.Globalization.CultureInfo("en"));
}
/// <summary> Returns a property of a connection object.
///
/// </summary>
/// <param name="name"> Name of the property to be returned.
///
/// The following read-only properties are available
/// for any given connection:
/// <ul>
/// <li>Ldap_PROPERTY_SDK returns the version of this SDK,
/// as a Float data type.</li>
///
/// <li>Ldap_PROPERTY_PROTOCOL returns the highest supported version of
/// the Ldap protocol, as a Float data type.</li>
///
/// <li>Ldap_PROPERTY_SECURITY returns a comma-separated list of the
/// types of authentication supported, as a
/// string.</li>
/// </ul>
///
/// A deep copy of the property is provided where applicable; a
/// client does not need to clone the object received.
///
/// </param>
/// <returns> The object associated with the requested property,
/// or null if the property is not defined.
///
/// </returns>
/// <seealso cref="LdapConstraints.getProperty">
/// </seealso>
/// <seealso cref="Object">
/// </seealso>
public virtual System.Object getProperty(System.String name)
{
if (name.ToUpper().Equals(Ldap_PROPERTY_SDK.ToUpper()))
return Connection.sdk;
else if (name.ToUpper().Equals(Ldap_PROPERTY_PROTOCOL.ToUpper()))
return Connection.protocol;
else if (name.ToUpper().Equals(Ldap_PROPERTY_SECURITY.ToUpper()))
return Connection.security;
else
{
return null;
}
}
/// <summary> Returns the attribute matching the specified attrName.
///
/// For example:
/// <ul>
/// <li><code>getAttribute("cn")</code> returns only the "cn" attribute</li>
/// <li><code>getAttribute("cn;lang-en")</code> returns only the "cn;lang-en"
/// attribute.</li>
/// </ul>
/// In both cases, <code>null</code> is returned if there is no exact match to
/// the specified attrName.
///
/// Note: Novell eDirectory does not currently support language subtypes.
/// It does support the "binary" subtype.
///
/// </summary>
/// <param name="attrName"> The name of an attribute to retrieve, with or without
/// subtype specifications. For example, "cn", "cn;phonetic", and
/// "cn;binary" are valid attribute names.
///
/// </param>
/// <returns> The attribute matching the specified attrName, or <code>null</code>
/// if there is no exact match.
/// </returns>
public virtual LdapAttribute getAttribute(System.String attrName)
{
return (LdapAttribute) map[attrName.ToUpper()];
}
/// <summary> Gets a frame by name.
/// Names are checked without case sensitivity and conversion to uppercase
/// is performed with the locale provided.
/// </summary>
/// <param name="name">The name of the frame to retrieve.
/// </param>
/// <param name="locale">The locale to use when converting to uppercase.
/// </param>
/// <returns> The specified frame or <code>null</code> if it wasn't found.
/// </returns>
public virtual FrameTag GetFrame(System.String name, System.Globalization.CultureInfo locale)
{
INode node;
FrameTag ret;
ret = null;
name = name.ToUpper(locale);
for (ISimpleNodeIterator e = Frames.Elements(); e.HasMoreNodes() && (null == ret); )
{
node = e.NextNode();
if (node is FrameTag)
{
ret = (FrameTag) node;
if (!ret.FrameName.ToUpper(locale).Equals(name))
ret = null;
}
}
return (ret);
}
public virtual bool matchesLocale(System.String locale)
{
return (((this.locale == null) && (locale == null)) || locale.ToUpper().Equals(this.locale.ToUpper()));
}
/// <summary> Checks cardinality and creates an appropriate exception if out
/// of bounds. The usage code is needed because if min cardinality
/// is > 0, the min # of reps is only required if the usage code
/// is 'R' (see HL7 v2.5 section 2.12.6.4).
/// </summary>
/// <param name="reps">the number of reps
/// </param>
/// <param name="min">the minimum number of reps
/// </param>
/// <param name="max">the maximum number of reps (-1 means *)
/// </param>
/// <param name="usage">the usage code
/// </param>
/// <param name="name">the name of the repeating structure (used in exception msg)
/// </param>
/// <returns> null if cardinality OK, exception otherwise
/// </returns>
protected internal virtual NuGenHL7Exception testCardinality(int reps, int min, int max, System.String usage, System.String name)
{
NuGenHL7Exception e = null;
if (reps < min && usage.ToUpper().Equals("R".ToUpper()))
{
e = new NuGenProfileNotFollowedException(name + " must have at least " + min + " repetitions (has " + reps + ")");
}
else if (max > 0 && reps > max)
{
e = new NuGenProfileNotFollowedException(name + " must have no more than " + max + " repetitions (has " + reps + ")");
}
return e;
}
/// <summary>
///
/// </summary>
/// <param name="linkTextToFind"></param>
/// <param name="locale"></param>
public LinkFindingVisitor(System.String linkTextToFind, System.Globalization.CultureInfo locale)
{
count = 0;
this.locale = (null == locale)?new System.Globalization.CultureInfo("en"):locale;
this.linkTextToFind = linkTextToFind.ToUpper(this.locale);
}
/// <summary> Get the <code>PARAM<code> tag with the given name.</summary>
/// <param name="key">The object parameter name to get.
/// </param>
/// <returns> The value of the parameter or <code>null</code> if there is no parameter of that name.
/// </returns>
public virtual System.String GetParameter(System.String key)
{
return ((System.String) (ObjectParams[key.ToUpper()]));
}
/// <summary> Creates source code for a single data type in the HL7 normative
/// database.
/// </summary>
/// <param name="targetDirectory">the directory into which the file will be written
/// </param>
/// <param name="datatype">the name (e.g. ST, ID, etc.) of the data type to be created
/// </param>
/// <param name="version">the HL7 version of the intended data type
/// </param>
public static void make(System.IO.FileInfo targetDirectory, System.String dataType, System.String version)
{
Console.WriteLine(" Writing " + targetDirectory.FullName + dataType);
//make sure that targetDirectory is a directory ...
if (!System.IO.Directory.Exists(targetDirectory.FullName))
throw new System.IO.IOException("Can't create file in " + targetDirectory.ToString() + " - it is not a directory.");
//get any components for this data type
//UPGRADE_NOTE: There are other database providers or managers under System.Data namespace which can be used optionally to better fit the application requirements. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1208'"
System.Data.OleDb.OleDbConnection conn = NormativeDatabase.Instance.Connection;
//UPGRADE_TODO: Method 'java.sql.Connection.createStatement' was converted to 'SupportClass.TransactionManager.manager.CreateStatement' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javasqlConnectioncreateStatement'"
System.Data.OleDb.OleDbCommand stmt = SupportClass.TransactionManager.manager.CreateStatement(conn);
System.Text.StringBuilder sql = new System.Text.StringBuilder();
//this query is adapted from the XML SIG informative document
sql.Append("SELECT HL7DataStructures.data_structure, HL7DataStructureComponents.seq_no, HL7DataStructures.description, HL7DataStructureComponents.table_id, ");
sql.Append("HL7Components.description, HL7Components.table_id, HL7Components.data_type_code, HL7Components.data_structure ");
sql.Append("FROM HL7Versions LEFT JOIN (HL7DataStructures LEFT JOIN (HL7DataStructureComponents LEFT JOIN HL7Components ");
sql.Append("ON HL7DataStructureComponents.comp_no = HL7Components.comp_no AND ");
sql.Append("HL7DataStructureComponents.version_id = HL7Components.version_id) ");
sql.Append("ON HL7DataStructures.version_id = HL7DataStructureComponents.version_id ");
sql.Append("AND HL7DataStructures.data_structure = HL7DataStructureComponents.data_structure) ");
sql.Append("ON HL7DataStructures.version_id = HL7Versions.version_id ");
sql.Append("WHERE HL7DataStructures.data_structure = '");
sql.Append(dataType);
sql.Append("' AND HL7Versions.hl7_version = '");
sql.Append(version);
sql.Append("' ORDER BY HL7DataStructureComponents.seq_no");
//System.out.println(sql.toString()); //for debugging
//UPGRADE_TODO: Interface 'java.sql.ResultSet' was converted to 'System.Data.OleDb.OleDbDataReader' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javasqlResultSet'"
System.Data.OleDb.OleDbCommand temp_OleDbCommand;
temp_OleDbCommand = stmt;
temp_OleDbCommand.CommandText = sql.ToString();
System.Data.OleDb.OleDbDataReader rs = temp_OleDbCommand.ExecuteReader();
System.Collections.ArrayList dataTypes = new System.Collections.ArrayList(20);
System.Collections.ArrayList descriptions = new System.Collections.ArrayList(20);
System.Collections.ArrayList tables = new System.Collections.ArrayList(20);
System.String description = null;
while (rs.Read())
{
if (description == null)
description = System.Convert.ToString(rs[3 - 1]);
System.String de = System.Convert.ToString(rs[5 - 1]);
System.String dt = System.Convert.ToString(rs[8 - 1]);
int ta=-1;
if(!rs.IsDBNull(4-1))
ta = rs.GetInt32(4 - 1);
//trim all CE_x to CE
if (dt != null)
if (dt.StartsWith("CE"))
dt = "CE";
//System.out.println("Component: " + de + " Data Type: " + dt); //for debugging
dataTypes.Add(dt);
descriptions.Add(de);
tables.Add((System.Int32) ta);
}
if(dataType.ToUpper().Equals("TS") && version!="2.5")
{
dataTypes[0] = "TSComponentOne";
}
rs.Close();
//UPGRADE_ISSUE: Method 'java.sql.Statement.close' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javasqlStatementclose'"
stmt.Dispose();
NormativeDatabase.Instance.returnConnection(conn);
//if there is only one component make a Primitive, otherwise make a Composite
System.String source = null;
if (dataTypes.Count == 1)
{
if (dataType.Equals("FT") || dataType.Equals("ST") || dataType.Equals("TX") || dataType.Equals("NM") || dataType.Equals("SI") || dataType.Equals("TN") || dataType.Equals("GTS"))
{
source = makePrimitive(dataType, description, version);
}
else
{
source = null; //note: IS, ID, DT, DTM, and TM are coded manually
}
}
else if (dataTypes.Count > 1)
{
int numComponents = dataTypes.Count;
//copy data into arrays ...
System.String[] type = new System.String[numComponents];
System.String[] desc = new System.String[numComponents];
int[] table = new int[numComponents];
for (int i = 0; i < numComponents; i++)
{
type[i] = ((System.String) dataTypes[i]);
desc[i] = ((System.String) descriptions[i]);
table[i] = ((System.Int32) tables[i]);
}
source = makeComposite(dataType, description, type, desc, table, version);
}
else
{
//no components?
//throw new DataTypeException("The data type " + dataType + " could not be found");
Console.WriteLine("No components for " + dataType);
}
//System.out.println(source);
//write to file ...
if (source != null)
{
System.String targetFile = targetDirectory.ToString() + "/" + dataType + ".cs";
//UPGRADE_WARNING: At least one expression was used more than once in the target code. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1181'"
//UPGRADE_TODO: Constructor 'java.io.FileWriter.FileWriter' was converted to 'System.IO.StreamWriter' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javaioFileWriterFileWriter_javalangString_boolean'"
//UPGRADE_TODO: Class 'java.io.FileWriter' was converted to 'System.IO.StreamWriter' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javaioFileWriter'"
using(System.IO.StreamWriter writer = new System.IO.StreamWriter(targetFile))
{
writer.Write(source);
writer.Write("}");//End namespace
}
}
else
Console.WriteLine("No Source for " + dataType);
}
private void processAnnotation(System.String field, System.String value_Renamed, Reaction reaction)
{
//logger.debug("Annote: ", field, "=", value_Renamed);
if (field.Equals("RxnAtts") || field.Equals("RxnType"))
{
// reaction attributes
System.String dictionary = "macie";
if (value_Renamed.Equals("Acid") || value_Renamed.Equals("Base"))
{
dictionary = "chemical";
}
addDictRefedAnnotation(reaction, "Attributes", value_Renamed);
}
else if (field.Equals("ResiduesPresent") || field.Equals("GroupTransferred") || field.Equals("BondFormed") || field.Equals("ReactiveCentres") || field.Equals("BondCleaved") || field.Equals("BondFormed") || field.Equals("Products") || field.Equals("ResiduesPresent"))
{
reaction.setProperty(new DictRef("macie:" + field, value_Renamed), value_Renamed);
}
else if (field.Equals("Reversible"))
{
if (value_Renamed.ToUpper().Equals("yes".ToUpper()))
{
reaction.Direction = IReaction_Fields.BIDIRECTIONAL;
addDictRefedAnnotation(reaction, "ReactionType", "ReversibleReaction");
}
}
else if (field.Equals("OverallReactionType"))
{
SupportClass.Tokenizer tokenizer = new SupportClass.Tokenizer(value_Renamed, ",");
int i = 0;
while (tokenizer.HasMoreTokens())
{
System.String token = tokenizer.NextToken();
i++;
reaction.setProperty(DictionaryDatabase.DICTREFPROPERTYNAME + ":field:overallReactionType:" + i, "macie:" + token.ToLower());
}
}
else
{
Match residueLocatorMatcher = residueLocator.Match(field);
if (residueLocatorMatcher.Success)
{
//logger.debug("Found residueLocator: ", field);
IAtom[] atoms = ReactionManipulator.getAllInOneContainer(reaction).Atoms;
bool found = false;
//logger.debug("Searching for given residueLocator through #atom: ", atoms.Length);
//logger.debug("Taken from reaction ", reaction.ID);
for (int i = 0; (i < atoms.Length && !found); i++)
{
if (atoms[i] is PseudoAtom)
{
// that is what we are looking for
PseudoAtom atom = (PseudoAtom)atoms[i];
if (atom.Label.Equals(field))
{
// we have a hit, now mark Atom with dict refs
addDictRefedAnnotation(atom, "ResidueRole", value_Renamed);
found = true;
}
}
}
if (!found)
{
//logger.error("MACiE annotation mentions a residue that does not exist: " + field);
}
}
else
{
//logger.error("Did not parse annotation: ", field);
}
}
}
/// <summary> Returns the value of an attribute.</summary>
/// <param name="name">Name of attribute, case insensitive.
/// </param>
/// <returns> The value associated with the attribute or null if it does
/// not exist, or is a stand-alone or
/// </returns>
public virtual System.String GetAttribute(System.String name)
{
TagAttribute attribute;
System.String ret;
ret = null;
if (name.ToUpper().Equals(SpecialHashtable.TAGNAME.ToUpper()))
ret = ((TagAttribute) AttributesEx[0]).GetName();
else
{
attribute = GetAttributeEx(name);
if (null != attribute)
ret = attribute.GetValue();
}
return (ret);
}
/// <summary> Returns the attribute with the given name.</summary>
/// <param name="name">Name of attribute, case insensitive.
/// </param>
/// <returns> The attribute or null if it does
/// not exist.
/// </returns>
public virtual TagAttribute GetAttributeEx(System.String name)
{
System.Collections.ArrayList attributes;
int size;
TagAttribute attribute;
System.String string_Renamed;
TagAttribute ret;
ret = null;
attributes = AttributesEx;
if (null != attributes)
{
size = attributes.Count;
for (int i = 0; i < size; i++)
{
attribute = (TagAttribute) attributes[i];
string_Renamed = attribute.GetName();
if ((null != string_Renamed) && name.ToUpper().Equals(string_Renamed.ToUpper()))
{
ret = attribute;
i = size; // exit fast
}
}
}
return (ret);
}
/// <summary> Tests an element against the corresponding usage code. The element
/// is required in its encoded form.
/// </summary>
/// <param name="encoded">the pipe-encoded message element
/// </param>
/// <param name="usage">the usage code (e.g. "CE")
/// </param>
/// <param name="name">the name of the element (for use in exception messages)
/// </param>
/// <returns>s null if there is no problem, an HL7Exception otherwise
/// </returns>
private NuGenHL7Exception testUsage(System.String encoded, System.String usage, System.String name)
{
NuGenHL7Exception e = null;
if (usage.ToUpper().Equals("R".ToUpper()))
{
if (encoded.Length == 0)
e = new NuGenProfileNotFollowedException("Required element " + name + " is missing");
}
else if (usage.ToUpper().Equals("RE".ToUpper()))
{
//can't test anything
}
else if (usage.ToUpper().Equals("O".ToUpper()))
{
//can't test anything
}
else if (usage.ToUpper().Equals("C".ToUpper()))
{
//can't test anything yet -- wait for condition syntax in v2.6
}
else if (usage.ToUpper().Equals("CE".ToUpper()))
{
//can't test anything
}
else if (usage.ToUpper().Equals("X".ToUpper()))
{
if (encoded.Length > 0)
e = new NuGenXElementPresentException("Element " + name + " is present but specified as not used (X)");
}
else if (usage.ToUpper().Equals("B".ToUpper()))
{
//can't test anything
}
return e;
}
/// <summary> Reports if the attribute name contains the specified subtype.
///
/// For example, if you check for the subtype lang-en and the
/// attribute name is cn;lang-en, this method returns true.
///
/// </summary>
/// <param name="subtype"> The single subtype to check for.
///
/// </param>
/// <returns> True, if the attribute has the specified subtype;
/// false, if it doesn't.
///
/// @throws IllegalArgumentException if subtype is null
/// </returns>
public virtual bool hasSubtype(System.String subtype)
{
if ((System.Object) subtype == null)
{
throw new System.ArgumentException("subtype cannot be null");
}
if (null != this.subTypes)
{
for (int i = 0; i < subTypes.Length; i++)
{
if (subTypes[i].ToUpper().Equals(subtype.ToUpper()))
return true;
}
}
return false;
}
/// <summary> Bracketed text in a field description should be included in the accessor
/// name unless it corresponds to a data type name. Given the text that appears in
/// brackets in a field description, this method returns an empty string if it
/// corresponds to a data type name, or returns original text if not. It isn't
/// convenient to actually check (e.g. with DataTypeGenerator) whether the given
/// text actually corresponds to a data type name, so we are going to conclude that
/// it is a data type if and only if it is all caps and has 2 or 3 characters.
/// </summary>
private static System.String filterBracketedText(System.String text)
{
System.String filtered = "";
bool isDataType = true;
if (!text.Equals(text.ToUpper()))
isDataType = false;
if (text.Length < 2 || text.Length > 3)
isDataType = false;
if (!isDataType)
filtered = text;
return filtered;
}
// #######################################################################
// The following methods retrieve a SchemaElement given a Key name:
// #######################################################################
/// <summary> This function abstracts retrieving LdapSchemaElements from the local
/// copy of schema in this LdapSchema class. This is used by
/// <code>getXXX(String name)</code> functions.
///
/// Note that the nameTable has all keys cast to Upper-case. This is so
/// we can have a case-insensitive HashMap. The getXXX (String key)
/// methods will also cast to uppercase.
///
/// The first character of a NAME string can only be an alpha character
/// (see section 4.1 of rfc2252) Thus if the first character is a digit we
/// can conclude it is an OID. Note that this digit is ASCII only.
///
/// </summary>
/// <param name="schemaType">Specifies which list is to be used in schema
/// lookup.
/// </param>
/// <param name="key"> The key can be either an OID or a name string.
/// </param>
private LdapSchemaElement getSchemaElement(int schemaType, System.String key)
{
if ((System.Object) key == null || key.ToUpper().Equals("".ToUpper()))
return null;
char c = key[0];
if (c >= '0' && c <= '9')
{
//oid lookup
return (LdapSchemaElement) idTable[schemaType][key];
}
else
{
//name lookup
return (LdapSchemaElement) nameTable[schemaType][key.ToUpper()];
}
}
/// <summary> Creates a new instance of HasAttributeFilter that accepts tags
/// with the given attribute and value.
/// </summary>
/// <param name="attribute">The attribute to search for.
/// </param>
/// <param name="value">The value that must be matched,
/// or null if any value will match.
/// </param>
public AttributeRegexFilter(System.String attribute, System.String valuePattern, Boolean caseSensitive)
{
m_strAttribute = attribute.ToUpper(new System.Globalization.CultureInfo("en"));
m_strValuePattern = valuePattern;
m_bCaseSensitive = caseSensitive;
}
/// <summary> Parse filters from the given word
///
/// </summary>
/// <param name="word">String to parse
///
/// </param>
/// <returns> Analysis wavelet filter (first dimension: by direction,
/// second dimension: by decomposition levels)
/// </returns>
private AnWTFilter[][] parseFilters(System.String word)
{
AnWTFilter[][] filt = new AnWTFilter[2][];
for (int i = 0; i < 2; i++)
{
filt[i] = new AnWTFilter[1];
}
if (word.ToUpper().Equals("w5x3".ToUpper()))
{
filt[0][0] = new AnWTFilterIntLift5x3();
filt[1][0] = new AnWTFilterIntLift5x3();
return filt;
}
else if (word.ToUpper().Equals("w9x7".ToUpper()))
{
filt[0][0] = new AnWTFilterFloatLift9x7();
filt[1][0] = new AnWTFilterFloatLift9x7();
return filt;
}
else
{
throw new System.ArgumentException("Non JPEG 2000 part I filter: " + word);
}
}
/// <summary> Creates a new instance of HasAttributeFilter that accepts tags
/// with the given attribute and value.
/// </summary>
/// <param name="attribute">The attribute to search for.
/// </param>
/// <param name="value">The value that must be matched,
/// or null if any value will match.
/// </param>
public AttributeRegexFilter(System.String attribute, System.String valuePattern)
{
m_strAttribute = attribute.ToUpper(new System.Globalization.CultureInfo("en"));
m_strValuePattern = valuePattern;
}
/// <summary> Internal function used by equal to compare Attribute types. Because
/// attribute types could either be an OID or a name. There needs to be a
/// Translation mechanism. This function will absract this functionality.
///
/// Currently if types differ (Oid and number) then UnsupportedOperation is
/// thrown, either one or the other must used. In the future an OID to name
/// translation can be used.
///
///
/// </summary>
private bool equalAttrType(System.String attr1, System.String attr2)
{
if (System.Char.IsDigit(attr1[0]) ^ System.Char.IsDigit(attr2[0]))
//isDigit tests if it is an OID
throw new System.ArgumentException("OID numbers are not " + "currently compared to attribute names");
return attr1.ToUpper().Equals(attr2.ToUpper());
}
// PrintRights() parses and prints the effective rights
public static void PrintRights(System.String aName, int rights)
{
System.Text.StringBuilder rString = new System.Text.StringBuilder();
if (aName.ToUpper().Equals("[Entry Rights]".ToUpper()))
{
// decode object rights
rString.Append((rights & LdapDSConstants.LDAP_DS_ENTRY_BROWSE) != 0?"BrowseEntry: true; ":"BrowseEntry: false; ");
rString.Append((rights & LdapDSConstants.LDAP_DS_ENTRY_ADD) != 0?"AddEntry: true; ":"AddEntry: false; ");
rString.Append((rights & LdapDSConstants.LDAP_DS_ENTRY_DELETE) != 0?"DeleteEntry: true; ":"DeleteEntry: false; ");
rString.Append((rights & LdapDSConstants.LDAP_DS_ENTRY_RENAME) != 0?"RenameEntry: true; ":"RenameEntry: false; ");
rString.Append((rights & LdapDSConstants.LDAP_DS_ENTRY_SUPERVISOR) != 0?"Supervisor: true; ":"Supervisor: false; ");
rString.Append((rights & LdapDSConstants.LDAP_DS_ENTRY_INHERIT_CTL) != 0?"Inherit_ctl: true.":"Inherit_ctl: false.");
}
else
{
// decode attribute rights no matter it's for
// all attributes or a single attribute
rString.Append((rights & LdapDSConstants.LDAP_DS_ATTR_COMPARE) != 0?"CompareAttributes: true; ":"CompareAttributes: false; ");
rString.Append((rights & LdapDSConstants.LDAP_DS_ATTR_READ) != 0?"ReadAttributes: true; ":"ReadAttributes: false; ");
rString.Append((rights & LdapDSConstants.LDAP_DS_ATTR_WRITE) != 0?"Write/Add/DeleteAttributes: true; ":"Write/Add/DeleteAttributes: false; ");
rString.Append((rights & LdapDSConstants.LDAP_DS_ATTR_SELF) != 0?"Add/DeleteSelf: true; ":"Add/DeleteSelf: false; ");
rString.Append((rights & LdapDSConstants.LDAP_DS_ATTR_SUPERVISOR) != 0?"Supervisor: true.":"Supervisor: false.");
}
// System.Console.Out.WriteLine(rString);
}
/// <summary> Try to convert a string into a number, boolean, or null. If the string
/// can't be converted, return the string.
/// </summary>
/// <param name="s">A String.
/// </param>
/// <returns> A simple JSON value.
/// </returns>
public static System.Object stringToValue(System.String s)
{
if (s.Equals(""))
{
return s;
}
if (s.ToUpper().Equals("true".ToUpper()))
{
return true;
}
if (s.ToUpper().Equals("false".ToUpper()))
{
return false;
}
if (s.ToUpper().Equals("null".ToUpper()))
{
return JSONObject.NULL;
}
/*
* If it might be a number, try converting it.
* We support the non-standard 0x- convention.
* If a number cannot be produced, then the value will just
* be a string. Note that the 0x-, plus, and implied string
* conventions are non-standard. A JSON parser may accept
* non-JSON forms as long as it accepts all correct JSON forms.
*/
char b = s[0];
if ((b >= '0' && b <= '9') || b == '.' || b == '-' || b == '+')
{
if (b == '0' && s.Length > 2 && (s[1] == 'x' || s[1] == 'X'))
{
try
{
//UPGRADE_TODO: Method 'java.lang.Integer.parseInt' was converted to 'System.Convert.ToInt32' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073'"
return (System.Int32)System.Convert.ToInt32(s.Substring(2), 16);
}
catch (System.Exception ignore)
{
}
}
try
{
if (s.IndexOf('.') > -1 || s.IndexOf('e') > -1 || s.IndexOf('E') > -1)
{
return System.Double.Parse(s);
}
else
{
System.Int64 myLong = System.Int64.Parse(s);
if ((long)myLong == (int)myLong)
{
return (System.Int32)myLong;
}
else
{
return myLong;
}
}
}
catch (System.Exception ignore)
{
}
}
return s;
}
/// <summary> Attempts to retrieve the value of a leaf tag without using DOM or SAX.
/// This method searches the given message string for the given tag name, and returns
/// everything after the given tag and before the start of the next tag. Whitespace
/// is stripped. This is intended only for lead nodes, as the value is considered to
/// end at the start of the next tag, regardless of whether it is the matching end
/// tag or some other nested tag.
/// </summary>
/// <param name="message">a string message in XML form
/// </param>
/// <param name="tagName">the name of the XML tag, e.g. "MSA.2"
/// </param>
/// <param name="startAt">the character location at which to start searching
/// </param>
/// <throws> HL7Exception if the tag can not be found </throws>
protected internal virtual System.String parseLeaf(System.String message, System.String tagName, int startAt)
{
System.String value_Renamed = null;
//UPGRADE_WARNING: Method 'java.lang.String.indexOf' was converted to 'System.String.IndexOf' which may throw an exception. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1101'"
int tagStart = message.IndexOf("<" + tagName, startAt);
if (tagStart < 0)
{
//UPGRADE_WARNING: Method 'java.lang.String.indexOf' was converted to 'System.String.IndexOf' which may throw an exception. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1101'"
tagStart = message.IndexOf("<" + tagName.ToUpper(), startAt);
}
//UPGRADE_WARNING: Method 'java.lang.String.indexOf' was converted to 'System.String.IndexOf' which may throw an exception. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1101'"
int valStart = message.IndexOf(">", tagStart) + 1;
//UPGRADE_WARNING: Method 'java.lang.String.indexOf' was converted to 'System.String.IndexOf' which may throw an exception. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1101'"
int valEnd = message.IndexOf("<", valStart);
if (tagStart >= 0 && valEnd >= valStart)
{
value_Renamed = message.Substring(valStart, (valEnd) - (valStart));
}
else
{
throw new HL7Exception("Couldn't find " + tagName + " in message beginning: " + message.Substring(0, (System.Math.Min(150, message.Length)) - (0)), HL7Exception.REQUIRED_FIELD_MISSING);
}
return value_Renamed;
}
/// <summary> Creates source code for a single data type in the HL7 normative
/// database.
/// </summary>
/// <param name="targetDirectory">the directory into which the file will be written
/// </param>
/// <param name="datatype">the name (e.g. ST, ID, etc.) of the data type to be created
/// </param>
/// <param name="version">the HL7 version of the intended data type
/// </param>
public static void make(System.IO.FileInfo targetDirectory, System.String dataType, System.String version)
{
Console.WriteLine(" Writing " + targetDirectory.FullName + dataType);
//make sure that targetDirectory is a directory ...
if (!System.IO.Directory.Exists(targetDirectory.FullName))
throw new System.IO.IOException("Can't create file in " + targetDirectory.ToString() + " - it is not a directory.");
//get any components for this data type
System.Data.OleDb.OleDbConnection conn = NormativeDatabase.Instance.Connection;
System.Data.OleDb.OleDbCommand stmt = SupportClass.TransactionManager.manager.CreateStatement(conn);
System.Text.StringBuilder sql = new System.Text.StringBuilder();
//this query is adapted from the XML SIG informative document
sql.Append("SELECT HL7DataStructures.data_structure, HL7DataStructureComponents.seq_no, HL7DataStructures.description, HL7DataStructureComponents.table_id, ");
sql.Append("HL7Components.description, HL7Components.table_id, HL7Components.data_type_code, HL7Components.data_structure ");
sql.Append("FROM HL7Versions LEFT JOIN (HL7DataStructures LEFT JOIN (HL7DataStructureComponents LEFT JOIN HL7Components ");
sql.Append("ON HL7DataStructureComponents.comp_no = HL7Components.comp_no AND ");
sql.Append("HL7DataStructureComponents.version_id = HL7Components.version_id) ");
sql.Append("ON HL7DataStructures.version_id = HL7DataStructureComponents.version_id ");
sql.Append("AND HL7DataStructures.data_structure = HL7DataStructureComponents.data_structure) ");
sql.Append("ON HL7DataStructures.version_id = HL7Versions.version_id ");
sql.Append("WHERE HL7DataStructures.data_structure = '");
sql.Append(dataType);
sql.Append("' AND HL7Versions.hl7_version = '");
sql.Append(version);
sql.Append("' ORDER BY HL7DataStructureComponents.seq_no");
System.Data.OleDb.OleDbCommand temp_OleDbCommand;
temp_OleDbCommand = stmt;
temp_OleDbCommand.CommandText = sql.ToString();
System.Data.OleDb.OleDbDataReader rs = temp_OleDbCommand.ExecuteReader();
System.Collections.ArrayList dataTypes = new System.Collections.ArrayList(20);
System.Collections.ArrayList descriptions = new System.Collections.ArrayList(20);
System.Collections.ArrayList tables = new System.Collections.ArrayList(20);
System.String description = null;
while (rs.Read())
{
if (description == null)
description = System.Convert.ToString(rs[3 - 1]);
System.String de = System.Convert.ToString(rs[5 - 1]);
System.String dt = System.Convert.ToString(rs[8 - 1]);
int ta = -1;
if (!rs.IsDBNull(4 - 1))
ta = rs.GetInt32(4 - 1);
//trim all CE_x to CE
if (dt != null)
if (dt.StartsWith("CE"))
dt = "CE";
//System.out.println("Component: " + de + " Data Type: " + dt); //for debugging
dataTypes.Add(dt);
descriptions.Add(de);
tables.Add((System.Int32)ta);
}
if (dataType.ToUpper().Equals("TS"))
{
dataTypes[0] = "TSComponentOne";
}
rs.Close();
stmt.Dispose();
NormativeDatabase.Instance.returnConnection(conn);
//if there is only one component make a Primitive, otherwise make a Composite
System.String source = null;
if (dataTypes.Count == 1)
{
if (dataType.Equals("FT") || dataType.Equals("ST") || dataType.Equals("TX") || dataType.Equals("NM") || dataType.Equals("SI") || dataType.Equals("TN") || dataType.Equals("GTS"))
{
source = makePrimitive(dataType, description, version);
}
else
{
source = null; //note: IS, ID, DT, DTM, and TM are coded manually
}
}
else if (dataTypes.Count > 1)
{
int numComponents = dataTypes.Count;
//copy data into arrays ...
System.String[] type = new System.String[numComponents];
System.String[] desc = new System.String[numComponents];
int[] table = new int[numComponents];
for (int i = 0; i < numComponents; i++)
{
type[i] = ((System.String)dataTypes[i]);
desc[i] = ((System.String)descriptions[i]);
table[i] = ((System.Int32)tables[i]);
}
source = makeComposite(dataType, description, type, desc, table, version);
}
else
{
//no components?
//throw new DataTypeException("The data type " + dataType + " could not be found");
Console.WriteLine("No components for " + dataType);
}
//System.out.println(source);
//write to file ...
if (source != null)
{
System.String targetFile = targetDirectory.ToString() + "/" + dataType + ".cs";
using (System.IO.StreamWriter writer = new System.IO.StreamWriter(targetFile))
{
writer.Write(source);
writer.Write("}");//End namespace
}
}
else
Console.WriteLine("No Source for " + dataType);
}
/// <summary>
/// Checks whether the submitted IBAN (International Bank Account Number) is valid.
///
/// The IBAN is an ISO standard (ISO 13616) designed to ensure that account details are given in a
/// standard format (bank plus account). IBAN was introduced to provide an international standard
/// for payee account details and to make details more easy to check. IBAN is a standardised
/// international format for entering account details which consists of the country code (bank which
/// maintains the account), the local bank code (eg. in the UK this is the sortcode), the (payee)
/// account number and a two check digits. Please note that IBANs do not start with "IBAN " and do not
/// contain spaces when stored in computer systems.
/// Here is an example of an IBAN: DE89370400440532013000
/// DE = ISO 3166-1 country code
/// (NOTE: The country code used in an IBAN can deviate from the country code used in a BIC!
/// 89 = two check digits
/// 37040044 = sortcode
/// 0532013000 = account number.
/// IBANs are only issued by the bank where the account it is issued for is held.
///
/// </summary>
/// <param name="AIban">String that should be checked</param>
/// <param name="AResult"></param>
/// <returns>True if AIban is a valid Iban or an empty String or nil, False if it is
/// not valid.
/// </returns>
public static bool CheckIBAN(System.String AIban, out TVerificationResult AResult)
{
AResult = null;
int IbanLength;
string IbanCountryCode;
int IbanCheckDigits;
int Index = -1;
bool ReturnValue = true;
// this list was up-to-date as of Jan 2014 (http://www.swift.com/dsp/resources/documents/IBAN_Registry.pdf)
string[, ] COUNTRY_DATA =
{
{ "AD", "Andorra", "24" },
{ "AE", "United Arab Emirates", "23" },
{ "AL", "Albania", "28" },
{ "AT", "Austria", "20" },
{ "AZ", "Azerbaijan", "28" },
{ "BA", "Bosnia and Herzegovina", "20" },
{ "BE", "Belgium", "16" },
{ "BG", "Bulgaria", "22" },
{ "BH", "Bahrain", "22" },
{ "BR", "Brazil", "29" },
{ "CH", "Switzerland", "21" },
{ "CR", "Costa Rica", "21" },
{ "CY", "Cyprus", "28" },
{ "CZ", "Czech Republic", "24" },
{ "DE", "Germany", "22" },
{ "DK", "Denmark", "18" },
{ "DO", "Dominican Republic", "28" },
{ "EE", "Estonia", "20" },
{ "ES", "Spain", "24" },
{ "FI", "Finland", "18" },
{ "FO", "Faroe Islands", "18" },
{ "FR", "France", "27" },
{ "GE", "Georgia", "22" },
{ "GI", "Gibraltar", "23" },
{ "GB", "United Kingdom", "22" },
{ "GL", "Greenland", "18" },
{ "GR", "Greece", "27" },
{ "GT", "Guatemala", "28" },
{ "HR", "Croatia", "21" },
{ "HU", "Hungary", "28" },
{ "IE", "Republic of Ireland", "22" },
{ "IL", "Israel", "23" },
{ "IS", "Iceland", "26" },
{ "IT", "Italy", "27" },
{ "JO", "Jordan", "30" },
{ "KU", "Kuwait", "30" },
{ "KZ", "Kazakhstan", "20" },
{ "LB", "Lebanon", "28" },
{ "LI", "Lichtenstein", "21" },
{ "LU", "Luxembourg", "20" },
{ "LV", "Latvia", "21" },
{ "LT", "Lithuania", "20" },
{ "MC", "Monaco", "27" },
{ "MD", "Moldova", "24" },
{ "ME", "Montenegro", "22" },
{ "MK", "Macedonia", "19" },
{ "MR", "Mauritania", "27" },
{ "MT", "Malta", "31" },
{ "MU", "Mauritius", "30" },
{ "NL", "The Netherlands", "18" },
{ "NO", "Norway", "15" },
{ "PK", "Pakistan", "24" },
{ "PL", "Poland", "28" },
{ "PS", "Palestine", "29" },
{ "PT", "Portugal", "25" },
{ "QA", "Qatar", "29" },
{ "RO", "Romania", "24" },
{ "RS", "Serbia", "22" },
{ "SA", "Saudi Arabia", "24" },
{ "SE", "Sweden", "24" },
{ "SI", "Slovenia", "19" },
{ "SK", "Slovak Republic", "24" },
{ "SM", "San Marino", "27" },
{ "TN", "Tunisia", "24" },
{ "TR", "Turkey", "26" },
{ "VG", "Virgin Islands", "24" }
};
// remove all spaces
AIban = AIban.Replace(" ", "");
// make string uppercase for ease
AIban = AIban.ToUpper();
// get length
IbanLength = AIban.Length;
// check length (must be less or equal to 34 characters)
if (IbanLength > 34)
{
AResult = new TVerificationResult(
"CommonRoutines.CheckIBAN",
ErrorCodes.GetErrorInfo(PetraErrorCodes.ERR_IBAN_TOO_LONG));
return false;
}
// check first and second character to be A-Z
if ((IbanLength < 2) || !Regex.IsMatch(AIban.Substring(0, 2), @"^[A-Z]+$"))
{
AResult = new TVerificationResult(
"CommonRoutines.CheckIBAN",
ErrorCodes.GetErrorInfo(PetraErrorCodes.ERR_IBAN_NOTBEGINWITHTWOLETTERS));
return false;
}
else
{
IbanCountryCode = AIban.Substring(0, 2);
}
// check third and fourth character to form a number
if ((IbanLength < 4) || !Regex.IsMatch(AIban.Substring(2, 2), @"^[0-9]+$"))
{
AResult = new TVerificationResult(
"CommonRoutines.CheckIBAN",
ErrorCodes.GetErrorInfo(PetraErrorCodes.ERR_IBAN_THIRDANDFORTHNOTDIGITS));
return false;
}
else
{
IbanCheckDigits = Convert.ToInt32(AIban.Substring(2, 2));
}
// verify check digits (must be within range 02-98)
if ((IbanCheckDigits < 2) || (IbanCheckDigits == 99))
{
AResult = new TVerificationResult(
"CommonRoutines.CheckIBAN",
ErrorCodes.GetErrorInfo(PetraErrorCodes.ERR_IBAN_CHECKDIGITSAREWRONG));
return false;
}
// find the index of the country code (if it exists)
for (int i = 0; i < COUNTRY_DATA.GetLength(0); i++)
{
if (COUNTRY_DATA[i, 0] == IbanCountryCode)
{
Index = i;
break;
}
}
if (Index == -1)
{
AResult = new TVerificationResult(
"CommonRoutines.CheckIBAN",
ErrorCodes.GetErrorInfo(PetraErrorCodes.ERR_IBAN_COUNTRYNOTDEFINIED, IbanCountryCode));
ReturnValue = false;
}
// check the length of the IBAN for defined countries
if ((Index != -1) && (Convert.ToInt32(COUNTRY_DATA[Index, 2]) != IbanLength))
{
AResult = new TVerificationResult(
"CommonRoutines.CheckIBAN",
ErrorCodes.GetErrorInfo(PetraErrorCodes.ERR_IBAN_WRONGLENGTH, new string[4]
{
COUNTRY_DATA[Index, 1], COUNTRY_DATA[Index, 0], COUNTRY_DATA[Index, 2].ToString(), IbanLength.ToString()
}));
return false;
}
/* calculate and check the checksum */
// put country and check digits to the end
AIban = AIban.Substring(4) + AIban.Substring(0, 4);
//replace each letter by numerical equivalent
AIban = Regex.Replace(AIban, @"\D", x => ((int)x.Value[0] - 55).ToString());
int Remainder = 0;
// Interpret the IBAN as a decimal integer and compute the remainder of that number on division by 97
while (AIban.Length >= 7)
{
Remainder = Convert.ToInt32(AIban.Substring(0, 7)) % 97;
AIban = Remainder.ToString() + AIban.Substring(7);
}
if (AIban.Length > 0)
{
Remainder = Convert.ToInt32(AIban) % 97;
}
// checksum only valid if Remainder = 1
if (Remainder != 1)
{
AResult = new TVerificationResult(
"CommonRoutines.CheckIBAN",
ErrorCodes.GetErrorInfo(PetraErrorCodes.ERR_IBAN_CHECKSUMMISMATCH));
ReturnValue = false;
}
return ReturnValue;
}
