internal LineData(object value, string formattedValue, CellColorSettings colors, CellFontSettings fonts)
 {
     Value          = value;
     FormattedValue = formattedValue;
     Colors         = colors;
     Fonts          = fonts;
 }
        internal override void RetrieveLine2(Dictionary <Level, HashSet <Member> > src, Line ALine)
        {
            DebugLogging.WriteLine("MdEngine.RetrieveLine2(line={0})", ALine.ToString());

            var line = ALine as MdLine;
            //ICubeAddress Restriction = new ICubeAddress(ALine.MetaLine.Grid, restriction);

            var sources = new List <Hierarchy>();

            foreach (var l1 in ALine.Levels)
            {
                if (!src.ContainsKey(l1))
                {
                    sources.Add(l1.Hierarchy);
                }
            }

            var cube = (MOlapCube)FGrid.Cube;

            cube.EnsureConnected();

            var           QUERY   = new StringBuilder();
            var           WITH    = new StringBuilder();
            var           WHERE   = new StringBuilder("WHERE (");
            StringBuilder SUBCUBE = null;
            StringBuilder SELECT;
            var           intelligenceh = ALine.fMode.LinkedIntelligence == null ? null : ALine.fMode.LinkedIntelligence.fParent;
            var           MeasureName   = ALine.fMode.LinkedIntelligence == null
                ? ALine.Measure.UniqueName
                : cube.MakeIntelligenceMember(ALine, WITH);

            if (ALine.fMode.Mode == MeasureShowModeType.smNormal && ALine.Measure.Filter != null)
            {
                cube.MakeMeasureFilter(ALine.Measure, WITH, out MeasureName);
            }

            if (ALine.Measure.AggregateFunction == OlapFunction.stCalculated &&
                !string.IsNullOrEmpty(ALine.Measure.Expression))
            {
                cube.MakeCalculatedMeasure(ALine.Measure, WITH);
            }

            if (cube.MDXCellsetThreshold > 0 && !cube.Is2000)
            {
                SELECT = new StringBuilder("SELECT {HEAD(NONEMPTY({");
            }
            else
            {
                SELECT = new StringBuilder("SELECT NON EMPTY {");
            }
            // GetLineIDX info
            var  idxlevels = new List <Level>(src.Count + sources.Count);
            var  idxmul    = new List <long>(src.Count + sources.Count);
            long idx       = 0;

            //if (!cube.Is2000) //MSAS 2000
            //{
            //    #region MSAS 2000
            //    WITH = RetrieveLine2_MSAS2000(
            //        src, ALine, intelligenceh, WHERE, idxmul, idxlevels,
            //        cube, WITH, sources, MeasureName, ref SELECT, ref idx);

            //    #endregion
            //}
            //else //MSAS 2005
            //{
            //    #region MSAS 2005

            //    RetrieveLine2_MSAS2005(
            //        src, ALine, cube, ref WITH, WHERE, ref SUBCUBE, ref SELECT,
            //        intelligenceh, MeasureName, idxlevels, idxmul);
            //    #endregion
            //}

            RetrieveLine2_MSAS(src, ALine, intelligenceh, WHERE, idxmul, idxlevels, cube, ref WITH, sources,
                               MeasureName, ref SELECT, ref idx, ref SUBCUBE);

            QUERY.Append(WITH);
            QUERY.Append(SELECT);
            QUERY.Append(WHERE);
            QUERY.Append(cube.ApplyCellProperties());

            var css = cube.ExecuteMDXCellset(QUERY.ToString(), true);

            if (css.Cells.Count == cube.MDXCellsetThreshold && cube.MDXCellsetThreshold > 0)
            {
                cube.MDXCellsetThresholdReached = true;
            }

            if (css.Cells.Count == 0)
            {
                return;
            }

            if (css.Axes.Count == 0)
            {
                var c = new WrappedCell(css.Cells[0]);
                CellColorSettings mcs = null;
                CellFontSettings  mfs = null;

                if (c == null || c.Value == null)
                {
                    return;
                }

                ALine.StartMergeSeries(1);

                line.AddData(idx, new LineData(c.Value, c.FormattedValue, mcs, mfs));

                ALine.EndMergeSeries();
                return;
            }
            var cc = css.Cells;
            var tc = css.Axes[0].Set.Tuples;

            ALine.StartMergeSeries(cc.Count);
            for (var i = 0; i < cc.Count; i++)
            {
                var c = new WrappedCell(css.Cells[i]);
                if (c == null || c.Value == null)
                {
                    continue;
                }

                var mc  = tc[i].Members;
                var Idx = idx;
                for (var j = 0; j < mc.Count; j++)
                {
                    var        L = idxlevels[j].CubeLevel;
                    var        m = idxlevels[j].FindMember(mc[j].UniqueName);
                    CubeMember M = null;
                    if (m == null)
                    {
                        var m_ = mc[j];
                        //                        if ((m_.Type == MemberTypeEnum.All) || (m_.UniqueName.EndsWith(".UNKNOWNMEMBER")))
                        if (m_.Type == MemberTypeEnum.All)
                        {
                            Idx = -1;
                            break;
                        }
                        if (m_.LevelName != L.UniqueName && L.Hierarchy.Origin == HierarchyOrigin.hoUserDefined)
                        {
                            L = L.Hierarchy.Levels.Find(m_.LevelName);
                            M = L.FindMemberByUniqueName(m_.UniqueName);
                        }
                        if (M == null)
                        {
                            M = new CubeMember(L.Hierarchy, L, m_.Caption, m_.Description, m_.UniqueName, m_.Name,
                                               false, m_.LevelName);
                            var parent = m_.Parent == null
                                ? null
                                : L.Hierarchy.FindMemberByUniqueName(m_.Parent.UniqueName);
                            if (m_.Type == MemberTypeEnum.Formula)
                            {
                                M.IsMDXCalculated = true;
                            }
                            //if ((parent == null) && (idxlevels[j].Index > 0))
                            //{
                            //    object pname = m_.Properties["PARENT_MEMBER_TYPE"].Value;
                            //    if (pname != null)
                            //        parent = L.Hierarchy.FindMemberByUniqueName(pname.ToString());
                            //}
                            if (parent == null)
                            {
                                L.Members.Add(M);
                            }
                            else
                            {
                                if (L == parent.ParentLevel)
                                {
                                    cube.SetCubeMemberParent(M, parent);
                                }
                                else
                                {
                                    var H = L.Hierarchy;
                                    cube.SetCubeMemberParent(L.Hierarchy, H.Levels.IndexOf(M.ParentLevel),
                                                             H.Levels.IndexOf(parent.ParentLevel), M.UniqueName, parent.UniqueName);
                                    L.Members.Add(M);
                                }
                            }
                        }
                    }
                    if (m != null)
                    {
                        Idx += m.ID * idxmul[j];
                    }
                    else
                    {
                        Idx += M.ID * idxmul[j];
                    }
                }
                CellColorSettings mcs = null;
                CellFontSettings  mfs = null;
                if (Idx >= 0)
                {
                    line.AddData(Idx, new LineData(c.Value, c.FormattedValue, mcs, mfs));
                }
                for (var k = 0; k < ALine.Levels.Count; k++)
                {
                    ALine.Levels[k].CreateNewMembersLight(false);
                }
            }
            for (var k = 0; k < ALine.Levels.Count; k++)
            {
                ALine.Levels[k].CreateNewMembersLight(true);
            }
            ALine.EndMergeSeries();
        }