using System;
using System.Diagnostics;
using System.Runtime.Serialization;

namespace Deltares.MStab.IO.Classic
{
    [Serializable]
    public class ClassicMStabException : Exception
    {
        //
        // For guidelines regarding the creation of new exception types, see
        //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
        // and
        //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
        //

        public ClassicMStabException() {}

        public ClassicMStabException(string message) : base(message) {}

        public ClassicMStabException(string message, Exception inner) : base(message, inner) {}

        protected ClassicMStabException(
            SerializationInfo info,
            StreamingContext context)
            : base(info, context) {}
    }

    /// <summary>
    /// Access parameters from Classic Input files with help of DGSSerializer.dll
    /// </summary>
    public static class GetClassicMStab
    {
        public static void GetClassicIdentificationTitles(int handle, ref ClassicMStabFunctionDefinitions.MStabIdentificationTitles aIdentificationTitles)
        {
            var lBuffer = new char[1024];
            try
            {
                if (aIdentificationTitles == null)
                {
                    aIdentificationTitles = new ClassicMStabFunctionDefinitions.MStabIdentificationTitles();
                }

                aIdentificationTitles.projectTitle1 = new string(lBuffer);
                aIdentificationTitles.projectTitle2 = new string(lBuffer);
                aIdentificationTitles.projectTitle3 = new string(lBuffer);
                if (!ClassicMStabFunctionDefinitions.ClassicGetIdentificationTitles(handle, ref aIdentificationTitles))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicConsolidationDegree(int handle, ref ClassicMStabFunctionDefinitions.MStabConsolidationDegree aConsolidationDegree)
        {
            var lBuffer = new char[1024];
            try
            {
                if (aConsolidationDegree == null)
                {
                    aConsolidationDegree = new ClassicMStabFunctionDefinitions.MStabConsolidationDegree();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetConsolidationDegree(handle, ref aConsolidationDegree))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicModelFactor(int handle, ref ClassicMStabFunctionDefinitions.MStabModelFactor aModelfactor)
        {
            try
            {
                if (aModelfactor == null)
                {
                    aModelfactor = new ClassicMStabFunctionDefinitions.MStabModelFactor();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetModelFactor(handle, ref aModelfactor))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicProbabilisticDefaults(int handle, ref ClassicMStabFunctionDefinitions.MStabProbabilisticDefaults probabilisticDefaults)
        {
            try
            {
                if (probabilisticDefaults == null)
                {
                    probabilisticDefaults = new ClassicMStabFunctionDefinitions.MStabProbabilisticDefaults();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetProbabilisticDefaults(handle, ref probabilisticDefaults))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicEarthQuakeDegree(int handle, ref ClassicMStabFunctionDefinitions.MStabEarthQuakeDegree aEarthQuakeDegree)
        {
            try
            {
                if (aEarthQuakeDegree == null)
                {
                    aEarthQuakeDegree = new ClassicMStabFunctionDefinitions.MStabEarthQuakeDegree();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetEarthQuakeDegree(handle, ref aEarthQuakeDegree))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicLineLoads(int handle, ref ClassicMStabFunctionDefinitions.MStabLineLoads aLineLoads)
        {
            try
            {
                var buffer = new char[1024];
                if (aLineLoads == null)
                {
                    aLineLoads = new ClassicMStabFunctionDefinitions.MStabLineLoads();
                    aLineLoads.lineLoad = new ClassicMStabFunctionDefinitions.LineLoad[ClassicMStabFunctionDefinitions.MStabConstants.maxLoads];
                    for (int i = 0; i < ClassicMStabFunctionDefinitions.MStabConstants.maxLoads; i++)
                    {
                        aLineLoads.lineLoad[i].itemName = new string(buffer);
                    }
                }
                if (!ClassicMStabFunctionDefinitions.ClassicGetLineLoads(handle, ref aLineLoads))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicDefaultNail(int handle, ref ClassicMStabFunctionDefinitions.MStabDefaultNail defaultNail)
        {
            try
            {
                if (defaultNail == null)
                {
                    defaultNail = new ClassicMStabFunctionDefinitions.MStabDefaultNail();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetDefaultNail(handle, ref defaultNail))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicNail(int handle, ref ClassicMStabFunctionDefinitions.MStabNails aNails)
        {
            try
            {
                var buffer = new char[1024];
                if (aNails == null)
                {
                    aNails = new ClassicMStabFunctionDefinitions.MStabNails();
                    aNails.nail = new ClassicMStabFunctionDefinitions.Nail[ClassicMStabFunctionDefinitions.MStabConstants.maxNails];
                    for (int i = 0; i < ClassicMStabFunctionDefinitions.MStabConstants.maxLoads; i++)
                    {
                        aNails.nail[i].itemName = new string(buffer);
                    }
                }
                if (!ClassicMStabFunctionDefinitions.ClassicGetNails(handle, ref aNails))
                {
                    //throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicUniformLoads(int handle, ref ClassicMStabFunctionDefinitions.MStabUniformLoads aUniformLoads)
        {
            try
            {
                var buffer = new char[1024];
                if (aUniformLoads == null)
                {
                    aUniformLoads = new ClassicMStabFunctionDefinitions.MStabUniformLoads();
                    aUniformLoads.uniformLoad = new ClassicMStabFunctionDefinitions.UniformLoad[ClassicMStabFunctionDefinitions.MStabConstants.maxLoads];
                    for (int i = 0; i < ClassicMStabFunctionDefinitions.MStabConstants.maxLoads; i++)
                    {
                        aUniformLoads.uniformLoad[i].itemName = new string(buffer);
                    }
                }
                if (!ClassicMStabFunctionDefinitions.ClassicGetUniformLoads(handle, ref aUniformLoads))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicTemporallyLoadsDegree(int handle, ref ClassicMStabFunctionDefinitions.MStabTemporaryLoadsDegree aTemporallyLoads)
        {
            try
            {
                if (aTemporallyLoads == null)
                {
                    aTemporallyLoads = new ClassicMStabFunctionDefinitions.MStabTemporaryLoadsDegree();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetTemporaryLoadsDegree(handle, ref aTemporallyLoads))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicEarthQuake(int handle, ref ClassicMStabFunctionDefinitions.MStabEarthQuake aEarthquake)
        {
            try
            {
                if (aEarthquake == null)
                {
                    aEarthquake = new ClassicMStabFunctionDefinitions.MStabEarthQuake();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetEarthQuake(handle, ref aEarthquake))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicTreeOnSlope(int handle, ref ClassicMStabFunctionDefinitions.MStabTreeOnSlope aTreeOnSlope)
        {
            try
            {
                if (aTreeOnSlope == null)
                {
                    aTreeOnSlope = new ClassicMStabFunctionDefinitions.MStabTreeOnSlope();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetTreeOnSlope(handle, ref aTreeOnSlope))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicGeoTextiles(int handle, ref ClassicMStabFunctionDefinitions.MStabGeoTextiles aGeoTextiles)
        {
            try
            {
                var buffer = new char[1024];
                if (aGeoTextiles == null)
                {
                    aGeoTextiles = new ClassicMStabFunctionDefinitions.MStabGeoTextiles();
                    aGeoTextiles.geoTextiles = new ClassicMStabFunctionDefinitions.GeoTextile[ClassicMStabFunctionDefinitions.MStabConstants.maxGeotextiles];
                    for (int i = 0; i < ClassicMStabFunctionDefinitions.MStabConstants.maxGeotextiles; i++)
                    {
                        aGeoTextiles.geoTextiles[i].geoTextileName = new string(buffer);
                    }
                }
                if (!ClassicMStabFunctionDefinitions.ClassicGetGeoTextiles(handle, ref aGeoTextiles))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicCircles(int handle, ref ClassicMStabFunctionDefinitions.MStabCircles aCircles)
        {
            try
            {
                if (aCircles == null)
                {
                    aCircles = new ClassicMStabFunctionDefinitions.MStabCircles();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetCircles(handle, ref aCircles))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicForbiddenLines(int handle, ref ClassicMStabFunctionDefinitions.MStabForbiddenLines aForbiddenLines)
        {
            try
            {
                var Buffer = new char[1024];
                if (aForbiddenLines == null)
                {
                    aForbiddenLines = new ClassicMStabFunctionDefinitions.MStabForbiddenLines();
                    aForbiddenLines.lines = new ClassicMStabFunctionDefinitions.ForbiddenLine[ClassicMStabFunctionDefinitions.MStabConstants.maxForbiddenLines];
                    for (int i = 0; i < ClassicMStabFunctionDefinitions.MStabConstants.maxForbiddenLines; i++)
                    {
                        aForbiddenLines.lines[i].itemName = new string(Buffer);
                    }
                }
                if (!ClassicMStabFunctionDefinitions.ClassicGetForbiddenLines(handle, ref aForbiddenLines))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicReferenceCu(int handle, ref ClassicMStabFunctionDefinitions.MStabReferenceLevelCU aReferenceCu)
        {
            try
            {
                if (aReferenceCu == null)
                {
                    aReferenceCu = new ClassicMStabFunctionDefinitions.MStabReferenceLevelCU();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetReferenceLevelCu(handle, ref aReferenceCu))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicHorizontalBalance(int handle, ref ClassicMStabFunctionDefinitions.MStabHorizontalBalance aHorizontalBalance)
        {
            try
            {
                if (aHorizontalBalance == null)
                {
                    aHorizontalBalance = new ClassicMStabFunctionDefinitions.MStabHorizontalBalance();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetHorizontalBalance(handle, ref aHorizontalBalance))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicSpencer1(int handle, ref ClassicMStabFunctionDefinitions.MStabSlipSpencer aSlipSpencer)
        {
            try
            {
                if (aSlipSpencer == null)
                {
                    aSlipSpencer = new ClassicMStabFunctionDefinitions.MStabSlipSpencer();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetSlipSpencer1(handle, ref aSlipSpencer))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicSpencer2(int handle, ref ClassicMStabFunctionDefinitions.MStabSlipSpencer aSlipSpencer)
        {
            try
            {
                if (aSlipSpencer == null)
                {
                    aSlipSpencer = new ClassicMStabFunctionDefinitions.MStabSlipSpencer();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetSlipSpencer2(handle, ref aSlipSpencer))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicSlipInterval(int handle, ref ClassicMStabFunctionDefinitions.MStabSlipInterval slipInterval)
        {
            try
            {
                if (slipInterval == null)
                {
                    slipInterval = new ClassicMStabFunctionDefinitions.MStabSlipInterval();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetSlipInterval(handle, ref slipInterval))
                {
                    throw new ClassicMStabException("Could not get slip interval from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicSlipLiftData(int handle, ref ClassicMStabFunctionDefinitions.MStabLiftSlipData aLiftSlipData)
        {
            try
            {
                if (aLiftSlipData == null)
                {
                    aLiftSlipData = new ClassicMStabFunctionDefinitions.MStabLiftSlipData();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetLiftSlipData(handle, ref aLiftSlipData))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicRequestedCircleSlices(int handle, ref ClassicMStabFunctionDefinitions.MStabRequestedCircleSlices aRequestedCircleSlices)
        {
            try
            {
                if (aRequestedCircleSlices == null)
                {
                    aRequestedCircleSlices = new ClassicMStabFunctionDefinitions.MStabRequestedCircleSlices();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetRequestedCircleSlices(handle, ref aRequestedCircleSlices))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicRequestedLiftSlices(int handle, ref ClassicMStabFunctionDefinitions.MStabRequestedLiftSlices aRequestedLiftSlices)
        {
            try
            {
                if (aRequestedLiftSlices == null)
                {
                    aRequestedLiftSlices = new ClassicMStabFunctionDefinitions.MStabRequestedLiftSlices();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetRequestedLiftSlices(handle, ref aRequestedLiftSlices))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicRequestedSpencerSlices(int handle, ref ClassicMStabFunctionDefinitions.MStabRequestedSpencerSlices aRequestedSpencerSlices)
        {
            try
            {
                if (aRequestedSpencerSlices == null)
                {
                    aRequestedSpencerSlices = new ClassicMStabFunctionDefinitions.MStabRequestedSpencerSlices();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetRequestedSpencerSlices(handle, ref aRequestedSpencerSlices))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicMinimumRequiredCircleDepth(int handle, ref ClassicMStabFunctionDefinitions.MStabMinimalRequiredCircleDepth aMinimumRequiredCircleDepth)
        {
            try
            {
                if (aMinimumRequiredCircleDepth == null)
                {
                    aMinimumRequiredCircleDepth = new ClassicMStabFunctionDefinitions.MStabMinimalRequiredCircleDepth();
                }
                if (!ClassicMStabFunctionDefinitions.ClassicGetMinimumRequiredCircleDepth(handle, ref aMinimumRequiredCircleDepth))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicStartSafetyFactor(int handle, ref ClassicMStabFunctionDefinitions.MStabStartValueSafetyFactor aStartValueSafetyFactor)
        {
            try
            {
                if (aStartValueSafetyFactor == null)
                {
                    aStartValueSafetyFactor = new ClassicMStabFunctionDefinitions.MStabStartValueSafetyFactor();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetStartValueSafetyFactor(handle, ref aStartValueSafetyFactor))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicPlotData(int handle, ref ClassicMStabFunctionDefinitions.MStabNewZonePlotData aNewZonePlotData)
        {
            try
            {
                if (aNewZonePlotData == null)
                {
                    aNewZonePlotData = new ClassicMStabFunctionDefinitions.MStabNewZonePlotData();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetNewZonePlotData(handle, ref aNewZonePlotData))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicUnitWeightWater(int handle, ref ClassicMStabFunctionDefinitions.MStabUnitWeightWater aUnitWeightWater)
        {
            try
            {
                if (aUnitWeightWater == null)
                {
                    aUnitWeightWater = new ClassicMStabFunctionDefinitions.MStabUnitWeightWater();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetUnitWeightWater(handle, ref aUnitWeightWater))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicMSeepNet(int handle, ref ClassicMStabFunctionDefinitions.MStabMSeepNet aMSeepNet)
        {
            try
            {
                if (aMSeepNet == null)
                {
                    aMSeepNet = new ClassicMStabFunctionDefinitions.MStabMSeepNet();
                    var Buffer = new char[1024];
                    aMSeepNet.mSeepFileName = new string(Buffer);
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetMSeepNet(handle, ref aMSeepNet))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicExternalWaterLevels(int handle, ref ClassicMStabFunctionDefinitions.MStabExternalWaterLevels aExternalWaterLevels)
        {
            try
            {
                var buffer = new char[1024];
                if (aExternalWaterLevels == null)
                {
                    aExternalWaterLevels = new ClassicMStabFunctionDefinitions.MStabExternalWaterLevels();
                    aExternalWaterLevels.waterProperties = new ClassicMStabFunctionDefinitions.WaterData[ClassicMStabFunctionDefinitions.MStabConstants.pLMaxLength];
                    for (int i = 0; i < ClassicMStabFunctionDefinitions.MStabConstants.pLMaxLength; i++)
                    {
                        aExternalWaterLevels.waterProperties[i].name = new string(buffer);
                    }
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetWaterLevels(handle, ref aExternalWaterLevels))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicModel(int handle, ref ClassicMStabFunctionDefinitions.MStabModel aModel)
        {
            try
            {
                if (aModel == null)
                {
                    aModel = new ClassicMStabFunctionDefinitions.MStabModel();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetModel(handle, ref aModel))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicCalculationOptions(int handle, ref ClassicMStabFunctionDefinitions.MStabCalculationOptions aCalcOptions)
        {
            try
            {
                if (aCalcOptions == null)
                {
                    aCalcOptions = new ClassicMStabFunctionDefinitions.MStabCalculationOptions();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetCalculationOptions(handle, ref aCalcOptions))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicGeneticAlgorithmOptions(int handle, ref ClassicMStabFunctionDefinitions.MStabGeneticAlgorithmOptions aCalcOptions)
        {
            try
            {
                if (aCalcOptions == null)
                {
                    aCalcOptions = new ClassicMStabFunctionDefinitions.MStabGeneticAlgorithmOptions();
                }

                if (!ClassicMStabFunctionDefinitions.ClassicGetGeneticAlgorithmOptions(handle, ref aCalcOptions))
                {
                    throw new ClassicMStabException("Could not get object from ClassicMStab");
                }
            }
            catch (ClassicMStabException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }
    }
}