/// <summary> /// Convert the specified object to the corresponding MobiusDataType /// </summary> /// <param name="o"></param> /// <returns></returns> public static StringMx ConvertTo( object o) { StringMx sx; if (o is StringMx) { return((StringMx)o); } else if (NullValue.IsNull(o)) { return(new StringMx()); } else if (o is MobiusDataType) { MobiusDataType mdt = o as MobiusDataType; sx = new StringMx(mdt.ToString()); mdt.MemberwiseCopy(sx); return(sx); } else { return(new StringMx(o.ToString())); } }
/// <summary> /// Get a pair of MobiusDataType objects of the specified type that can be used /// for comparison to the specified text value. This is useful for comparing /// decimal numbers for equality. /// </summary> /// <param name="type"></param> /// <param name="textValue"></param> /// <param name="mdtLow"></param> /// <param name="mdtHigh"></param> public static void GetFuzzyEqualityComparators( MetaColumnType type, string textValue, out MobiusDataType mdtLow, out MobiusDataType mdtHigh) { try { mdtLow = MobiusDataType.New(type, textValue); mdtHigh = MobiusDataType.New(type, textValue); if (MetaColumn.IsDecimalMetaColumnType(type)) { double e = GetEpsilon(textValue); mdtLow.NumericValue -= e; mdtHigh.NumericValue += e; } } catch (Exception ex) { mdtLow = MobiusDataType.New(type); mdtHigh = MobiusDataType.New(type); } return; }
/// <summary> /// Deserialize base of Mobius Data Type /// </summary> /// <param name="br"></param> /// <param name="mdt"></param> public static void DeserializeBinary(BinaryReader br, MobiusDataType mdt) { int nonExistant = br.PeekChar(); if (nonExistant == NonExistantValueFlag) { mdt.IsNonExistant = true; nonExistant = br.ReadByte(); } if (br.ReadBoolean()) { mdt.BackColor = Color.FromArgb(br.ReadInt32()); } if (br.ReadBoolean()) { mdt.ForeColor = Color.FromArgb(br.ReadInt32()); } if (br.ReadBoolean()) { mdt.DbLink = br.ReadString(); } if (br.ReadBoolean()) { mdt.Hyperlink = br.ReadString(); } }
/// <summary> /// Binary Deserialize /// </summary> /// <param name="br"></param> /// <returns></returns> public static NumberMx DeserializeBinary(BinaryReader br) { NumberMx nx = new NumberMx(); MobiusDataType.DeserializeBinary(br, nx); nx.Value = br.ReadDouble(); return(nx); }
/// <summary> /// Binary Deserialize /// </summary> /// <param name="br"></param> /// <returns></returns> public static StringMx DeserializeBinary(BinaryReader br) { StringMx sx = new StringMx(); MobiusDataType.DeserializeBinary(br, sx); sx.Value = br.ReadString(); return(sx); }
/// <summary> /// Binary Deserialize /// </summary> /// <param name="br"></param> /// <returns></returns> public static CompoundId DeserializeBinary(BinaryReader br) { CompoundId sx = new CompoundId(); MobiusDataType.DeserializeBinary(br, sx); sx.Value = br.ReadString(); return(sx); }
/// <summary> /// Binary Deserialize /// </summary> /// <param name="br"></param> /// <returns></returns> public static DateTimeMx DeserializeBinary(BinaryReader br) { DateTimeMx dtx = new DateTimeMx(); MobiusDataType.DeserializeBinary(br, dtx); long ticks = br.ReadInt64(); dtx.Value = new DateTime(ticks); return(dtx); }
/// <summary> /// Clone /// </summary> /// <returns></returns> public MobiusDataType Clone() { MobiusDataType mdt = (MobiusDataType)this.MemberwiseClone(); if (mdt.MdtExAttr != null) { mdt.MdtExAttr = MdtExAttr.Clone(); } return(mdt); }
/// <summary> /// Convert a MobiusDataType object to the associated primitive type /// </summary> /// <param name="vo"></param> /// <returns></returns> public static object ConvertToPrimitiveValue(object vo) { if (vo == null || vo is DBNull || // return as is if not MobiusDataType vo.GetType().IsPrimitive || vo is string || vo is DateTime || !vo.GetType().IsSubclassOf(typeof(MobiusDataType))) { return(vo); } else // return associated primitive type { MobiusDataType mdt = vo as MobiusDataType; return(mdt.ToPrimitiveType()); } }
/// <summary> /// Get epsilon value for fuzzy numeric comparisons = .5 * 10**(-decimals) /// </summary> /// <param name="s"></param> /// <returns></returns> public double GetNumericValueEpsilon() { if (MetaColumn == null || !MetaColumn.IsDecimal) { return(0); } int decimals = MetaColumn.Decimals; // default to metacolumn decimals if (Decimals >= 0) { decimals = Decimals; // use QC decimals if defined } double epsilon = MobiusDataType.GetEpsilon(decimals); return(epsilon); }
/// <summary> /// Try to convert object to a MobiusDataType /// </summary> /// <param name="type"></param> /// <param name="o"></param> /// <param name="mdt"></param> /// <returns></returns> public static bool TryConvertTo( MetaColumnType type, object o, out MobiusDataType mdt) { mdt = null; try { mdt = ConvertToMobiusDataType(type, o); return(true); } catch (Exception ex) { return(false); } }
/// <summary> /// Make a memberwise copy of this object onto another existing MobiusDataType /// </summary> /// <param name="dest"></param> public void MemberwiseCopy(MobiusDataType dest) { dest._flags = _flags; // copy all flags dest.DbLink = DbLink; dest.BackColor = BackColor; if (MdtExAttr == null) { dest.MdtExAttr = null; } else { dest.MdtExAttr = new MdtExtendedAttributes(); MdtExAttr.MemberwiseCopy(dest.MdtExAttr); } return; }
/// <summary> /// Binary serialize a single Mobius data type object /// </summary> /// <param name="mdtObject"></param> /// <returns></returns> public static MobiusDataType DeserializeBinarySingle( byte[] ba) { if (ba == null) { return(null); } MemoryStream ms = new MemoryStream(ba); BinaryReader br = new BinaryReader(ms); object obj = VoArray.ReadBinaryItem(br); MobiusDataType mdt = obj as MobiusDataType; br.Close(); return(mdt); }
/// <summary> /// Binary Deserialize /// </summary> /// <param name="br"></param> /// <returns></returns> public static ImageMx DeserializeBinary(BinaryReader br) { ImageMx ix = new ImageMx(); MobiusDataType.DeserializeBinary(br, ix); if (br.ReadBoolean()) { int len = br.ReadInt32(); byte[] bytes = br.ReadBytes(len); MemoryStream ms = new MemoryStream(bytes, 0, len); ix.Value = new Bitmap(ms); } ix.Caption = br.ReadString(); return(ix); }
/// <summary> /// Binary Deserialize /// </summary> /// <param name="br"></param> /// <returns></returns> public static QualifiedNumber DeserializeBinary(BinaryReader br) { QualifiedNumber qn = new QualifiedNumber(); MobiusDataType.DeserializeBinary(br, qn); if (br.ReadBoolean()) { qn.Qualifier = br.ReadString(); } if (br.ReadBoolean()) { qn.NumberValue = br.ReadDouble(); } if (br.ReadBoolean()) { qn.StandardDeviation = br.ReadDouble(); } if (br.ReadBoolean()) { qn.StandardError = br.ReadDouble(); } if (br.ReadBoolean()) { qn.NValue = br.ReadInt32(); } if (br.ReadBoolean()) { qn.NValueTested = br.ReadInt32(); } if (br.ReadBoolean()) { qn.TextValue = br.ReadString(); } return(qn); }
/// <summary> /// Initialize internal match values for a single rule /// </summary> /// <param name="columnType"></param> public void InitializeInternalMatchValues(MetaColumnType columnType) { OpCode = ConvertOpNameToCode(Op); bool calculateEpsilonFromCfValue = false; // if true use cf value (note: may not be same number of decimals as output format) Epsilon = 0; if (MetaColumn.IsNumericMetaColumnType(columnType) && !String.IsNullOrEmpty(Value)) { double.TryParse(Value, out ValueNumber); if (calculateEpsilonFromCfValue) { Epsilon = MobiusDataType.GetEpsilon(Value); } else { int decimals = 10; // use default epsilon value Epsilon = MobiusDataType.GetEpsilon(decimals); } } else if (columnType == MetaColumnType.Date && !String.IsNullOrEmpty(Value)) { ValueNormalized = DateTimeMx.Normalize(Value); } if (MetaColumn.IsNumericMetaColumnType(columnType) && !String.IsNullOrEmpty(Value2)) { double.TryParse(Value2, out Value2Number); double e2 = MobiusDataType.GetEpsilon(Value2); if (e2 < Epsilon) { Epsilon = e2; } } else if (columnType == MetaColumnType.Date && !String.IsNullOrEmpty(Value2)) { Value2Normalized = DateTimeMx.Normalize(Value2); } }
/// <summary> /// Binary serialize a single Mobius data type object /// </summary> /// <param name="mdtObject"></param> /// <returns></returns> public static byte[] SerializeBinarySingle( MobiusDataType mdtObject) { if (mdtObject == null) { return(new byte[0]); } MemoryStream ms = new MemoryStream(); BinaryWriter bw = new BinaryWriter(ms); VoArray.WriteBinaryItem(mdtObject, bw); bw.Flush(); byte[] ba = new byte[ms.Length]; ms.Seek(0, 0); ms.Read(ba, 0, (int)ms.Length); bw.Close(); return(ba); }
/// <summary> /// Try to create the specifed MobiusDataType from a text string /// </summary> /// <param name="type"></param> /// <param name="textValue"></param> /// <param name="mdt"></param> /// <returns></returns> public static bool TryParse( MetaColumnType type, string textValue, out MobiusDataType mdt) { try { mdt = New(type, textValue); if (mdt != null) { return(true); } else { return(false); } } catch (Exception ex) { mdt = null; return(false); } }
/// <summary> /// Custom compact Deserialization of MobiusDataType /// </summary> /// <returns></returns> public static MobiusDataType Deserialize(string[] sa) { int sai; MobiusDataType mdt = null; char type = sa[0][0]; sai = 5; // first array entry for specific subclass switch (type) { case 'M': // ChemicalStructure (Molecule) mdt = MoleculeMx.Deserialize(sa, sai); break; case 'C': // CompoundId mdt = CompoundId.Deserialize(sa, sai); break; case 'D': // DateTimeEx mdt = DateTimeMx.Deserialize(sa, sai); break; case 'I': // ImageEx mdt = ImageMx.Deserialize(sa, sai); break; case 'N': //NumberEx mdt = NumberMx.Deserialize(sa, sai); break; case 'Q': // QualifiedNumber mdt = QualifiedNumber.Deserialize(sa, sai); break; case 'S': // StringEx mdt = StringMx.Deserialize(sa, sai); break; default: throw new Exception("Unexpected MobiusDataType: " + type); } if (!Lex.IsNullOrEmpty(sa[1])) { mdt.BackColor = Color.FromArgb(int.Parse(sa[1])); } if (!Lex.IsNullOrEmpty(sa[2])) { mdt.ForeColor = Color.FromArgb(int.Parse(sa[2])); } if (!Lex.IsNullOrEmpty(sa[3])) { mdt.DbLink = sa[3]; } if (!Lex.IsNullOrEmpty(sa[4])) { mdt.Hyperlink = sa[4]; } return(mdt); }
/// <summary> /// Write out the values for a data row /// </summary> /// <param name="dr"></param> /// <param name="qtMap"></param> /// <param name="tw"></param> /// <param name="ep"></param> /// <param name="outputNValues"></param> /// <param name="nValueMetaColumns"></param> /// <param name="noDataForTable"></param> /// <param name="ti"></param> /// <param name="keyValueForRow"></param> void WriteRowValues( object[] dr, QueryTableVoMap qtMap, SpotfireDataFileTableWriter tw, ExportParms ep, bool outputNValues, HashSet <MetaColumn> nValueMetaColumns, bool noDataForTable = false, int ti = 0, string keyValueForRow = "") { QueryColumn qc; MetaColumn mc; SpotfireDataFileValueType sdfType; QualifiedNumber qn; object vo, vo2; double dVal; string txt; for (int fi = 0; fi < qtMap.SelectedColumns.Count; fi++) { qc = qtMap.SelectedColumns[fi]; mc = qc.MetaColumn; sdfType = (SpotfireDataFileValueType)qc.SpotfireExportType; if (noDataForTable && ti == 0 && qc.IsKey) // if this is the root table and no data then supply the row key value { vo = keyValueForRow; noDataForTable = false; // now have data } if (noDataForTable) { vo = null; } else { vo = dr[qc.VoPosition]; } bool isNull = NullValue.IsNull(vo); if (isNull && (mc.DataType != MetaColumnType.QualifiedNo)) // write null value (unless QN which may require multiple value writes) { WriteValue(tw, sdfType, null); } else if (mc.DataType == MetaColumnType.Structure) { if (vo is MoleculeMx) { string molString = GetMoleculeString(vo, ep.ExportStructureFormat); WriteValue(tw, sdfType, molString); } else { vo2 = MobiusDataType.ConvertToPrimitiveValue(vo, mc); WriteValue(tw, sdfType, vo2); } } else if (mc.DataType == MetaColumnType.QualifiedNo) // write 1-3 values for Qualified number { // Output a split QN if (QnSubcolumns.IsSplitFormat(ep.QualifiedNumberSplit)) { if (vo is QualifiedNumber && !isNull) // regular QN { qn = (QualifiedNumber)vo; WriteValue(tw, SpotfireDataFileValueType.String, qn.Qualifier); // qualifier WriteValue(tw, SpotfireDataFileValueType.Double, qn.NumberValue); if (outputNValues && nValueMetaColumns.Contains(mc)) { if (NullValue.IsNull(qn.NValueTested)) { WriteValue(tw, SpotfireDataFileValueType.Int, null); // number in calc } else { WriteValue(tw, SpotfireDataFileValueType.Int, qn.NValueTested); } } } else if (!isNull) // non-qn { WriteValue(tw, SpotfireDataFileValueType.String, null); // qualifier if (QualifiedNumber.TryConvertToDouble(vo, out dVal)) { WriteValue(tw, SpotfireDataFileValueType.Double, dVal); } else { WriteValue(tw, SpotfireDataFileValueType.Double, null); } if (outputNValues && nValueMetaColumns.Contains(mc)) { WriteValue(tw, SpotfireDataFileValueType.Int, null); // N value } } else // null value { WriteValue(tw, SpotfireDataFileValueType.String, null); // qualifier WriteValue(tw, SpotfireDataFileValueType.Double, null); // value if (outputNValues && nValueMetaColumns.Contains(mc)) { WriteValue(tw, SpotfireDataFileValueType.Int, null); // N value } } } // Output a non-split (combined) QN else // combined { if (isNull) { WriteValue(tw, SpotfireDataFileValueType.String, null); } else if (vo is QualifiedNumber && !isNull) // regular QN { qn = (QualifiedNumber)vo; txt = qn.Format(qc, false, mc.Format, mc.Decimals, ep.QualifiedNumberSplit, false); WriteValue(tw, SpotfireDataFileValueType.String, txt); } else if (!isNull) // non-qn { txt = vo.ToString(); WriteValue(tw, SpotfireDataFileValueType.String, txt); } else // null value { WriteValue(tw, SpotfireDataFileValueType.String, null); } } } else // write other types as primitive value for now { vo2 = MobiusDataType.ConvertToPrimitiveValue(vo, mc); WriteValue(tw, sdfType, vo2); } } // col loop return; }
/// <summary> /// Serialize a DataRow to a StringBuilder object /// </summary> /// <param name="row"></param> /// <returns></returns> public static StringBuilder SerializeToText( object[] oa, int startPos, int length) { StringBuilder sb = new StringBuilder(); ConvertMoleculesToChimeStrings(oa); for (int vi = startPos; vi < startPos + length; vi++) { object o = oa[vi]; if (NullValue.IsNull(o)) { sb.Append("<>"); } else if (o is MobiusDataType) { MobiusDataType mdt = o as MobiusDataType; sb.Append(mdt.Serialize()); } else { sb.Append("<"); if (o is string) { sb.Append('s'); o = MobiusDataType.NormalizeForSerialize(o.ToString()); } else if (o is int) { sb.Append('i'); } else if (o is float) { sb.Append('f'); } else if (o is double) { sb.Append('f'); } else if (o is decimal) { sb.Append('f'); } else if (o is DateTime) { // write datetime as number of ticks sb.Append('d'); o = ((DateTime)o).Ticks; } else { throw new Exception("Invalid type: " + o.GetType()); } sb.Append(','); sb.Append(o); sb.Append(">"); } } return(sb); }
} // WriteMergedSpotfireDataFileForCombinedQueryTables /// <summary> /// Write results to individual Spotfire text data files /// Handles writing of both STDF and SBDF files /// </summary> /// <param name="query"></param> /// <param name="Rows"></param> /// <param name="ep"></param> /// <returns></returns> public string WriteIndividualSpotfireDataFilesForEachQueryTable( Query query, VoArrayList Rows, ExportParms ep) { QueryTable qt; QueryColumn qc, qcKey; MetaTable mt; MetaColumn mc, mcKey; SpotfireDataFileValueType sdfType; object vo, vo2, voKey; string outputFile = "", colName = "", molString = ""; int gci = 0; int fileCount = 0; int rowCount = 0; Sff = SpotfireFileFormat.Text; if (ep.ExportFileFormat == ExportFileFormat.Sbdf) { Sff = SpotfireFileFormat.Binary; } string baseOutputFileName = ep.OutputFileName; bool outputNValues = QnSubcolumns.NValueIsSet(ep.QualifiedNumberSplit); HashSet <MetaColumn> nValueMetaColumns = new HashSet <MetaColumn>(); string extraColNameSuffix = ColumnMapParms.SpotfireExportExtraColNameSuffix; QueryResultsVoMap voMap = QueryResultsVoMap.BuildFromQuery(query, includeKeyColsForAllTables: true); string baseStub = ""; int i1 = baseOutputFileName.IndexOf('.'); if (i1 >= 0) { baseStub = baseOutputFileName.Substring(0, i1); } else { baseStub = baseOutputFileName; } // Process each table for (int ti = 0; ti < voMap.Tables.Count; ti++) { QueryTableVoMap qtMap = voMap.Tables[ti]; qt = qtMap.Table; mt = qt.MetaTable; mcKey = mt.KeyMetaColumn; qcKey = qt.KeyQueryColumn; outputFile = Lex.Replace(baseOutputFileName, baseStub, baseStub + "_" + mt.Name); // append meta table name to stub to get name of file to output //if (TextFormat) //{ // if (!Lex.EndsWith(outputFile, ".txt")) outputFile += ".txt"; // needed for IIS use //} //else if (!Lex.EndsWith(outputFile, ".bin")) outputFile += ".bin"; // needed for IIS use SpotfireDataFileMetadataBuilder mdb = new SpotfireDataFileMetadataBuilder(Sff); for (int fi = 0; fi < qtMap.SelectedColumns.Count; fi++) { qc = qtMap.SelectedColumns[fi]; mc = qc.MetaColumn; sdfType = GetSpotfireDataFileType(mc); qc.SpotfireExportType = sdfType; colName = mt.Name + "." + mc.Name; // use internal mt.mc name AddMetadataForColumn(qc, colName, extraColNameSuffix, mdb, ep, nValueMetaColumns); } SpotfireDataFileTableMetadata tableMetaData = mdb.Build(); // do build of metadata // Write out the data for the table FileUtil.DeleteFile(outputFile); SpotfireDataFileTableWriter tw = new SpotfireDataFileTableWriter(outputFile, tableMetaData); for (int dri = 0; dri < Rows.TotalRowCount; dri++) { object[] dr = Rows[dri]; int qcKeyValueVoPos = qcKey.VoPosition; voKey = dr[qcKeyValueVoPos]; // get key value for row for this QueryTable if (voKey == null) { continue; } voKey = MobiusDataType.ConvertToPrimitiveValue(voKey, mcKey); if (NullValue.IsNull(voKey)) { continue; // if key not defined then don't write anything for the row } WriteRowValues(dr, qtMap, tw, ep, outputNValues, nValueMetaColumns); rowCount++; WriteValue(tw, null, null); // write end of line as appropriate } // row loop tw.Close(); fileCount++; } // table loop string response; if (fileCount == 1) { response = "Data exported to file: " + outputFile + "\r\n"; } else { response = "Data exported to folder: " + baseOutputFileName + "\r\n" + "- DataTable files: " + fileCount + "\r\n"; } response += "- Data rows: " + rowCount; return(response); } // WriteIndividualSpotfireDataFilesForEachQueryTable
/// <summary> /// Deserialize a string format DataRow value object array /// </summary> /// <param name="content"></param> /// <returns></returns> public static object[] DeserializeText( string content) { string[] sa; string vos; int voi = 0, sai = 0; int cnt = Lex.CountCharacter(content, '>'); object[] oa = new object[cnt]; int ltbrk = 0, rtbrk = 0; try { for (voi = 0; voi < cnt; voi++) { for (rtbrk = ltbrk + 1; rtbrk < content.Length; rtbrk++) { if (content[rtbrk] == '>') { break; } } vos = content.Substring(ltbrk + 1, rtbrk - ltbrk - 1); ltbrk = rtbrk + 1; // move to next if (vos.Length == 0) { continue; // null } sa = vos.Split(','); for (sai = 0; sai < sa.Length; sai++) // convert back to original form { sa[sai] = MobiusDataType.DenormalizeForDeserialize(sa[sai]); } char type = sa[0][0]; switch (type) { case 's': // string oa[voi] = sa[1]; break; case 'i': // integer oa[voi] = int.Parse(sa[1]); break; case 'f': // double oa[voi] = double.Parse(sa[1]); break; case 'd': // date time - stored as tick count long ticks = long.Parse(sa[1]); oa[voi] = new DateTime(ticks); break; default: oa[voi] = MobiusDataType.Deserialize(sa); break; } } //if (oa[0] == "02507049") oa = oa; // debug } catch (Exception ex) { string msg = "Deserialization error at position: " + voi + ", " + sai + " for string:\n\n" + content + "\n\n" + DebugLog.FormatExceptionMessage(ex); //ServicesLog.Message(msg); throw new Exception(msg, ex); } return(oa); }