Example #1
0
        public static bool TryConvertToInt(
            object vo,
            out int iVal)
        {
            double dVal;

            iVal = NullValue.NullNumber;

            if (vo == null || vo is DBNull)
            {
                return(false);
            }

            if (vo is int)
            {
                iVal = (int)vo;
                return(true);
            }

            if (!QualifiedNumber.TryConvertToDouble(vo, out dVal))
            {
                return(false);
            }
            if (dVal > int.MaxValue || dVal < int.MinValue)
            {
                return(false);
            }

            iVal = Convert.ToInt32(dVal);
            return(true);
        }
Example #2
0
        /// <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;
        }