Пример #1
0
        public void RefreshFrom(ICanRefreshFrom rhs,
                                bool SkipNullsForObjects,
                                bool SkipNullsForNullables)
        {
            CResult rhsResult = rhs as CResult;

            if (rhsResult == null)
            {
                return;
            }

            ResultColumnNumber = rhsResult.ResultColumnNumber;

            if (!SkipNullsForNullables || rhsResult.ResultInDB != null)
            {
                ResultInDB = rhsResult.ResultInDB;
            }

            if (!SkipNullsForNullables || rhsResult.Time.HasValue)
            {
                Time = rhsResult.Time;
            }

            if (!SkipNullsForNullables || rhsResult.CondFormating.HasValue)
            {
                CondFormating = rhsResult.CondFormating;
            }

            if (!SkipNullsForNullables || rhsResult.AdditionalEventTypes.HasValue)
            {
                AdditionalEventTypes = rhsResult.AdditionalEventTypes;
            }

            ResultPossible = rhsResult.ResultPossible;
        }
Пример #2
0
        public override void RefreshFrom(ICanRefreshFrom rhs,
                                         bool SkipNullsForObjects,
                                         bool SkipNullsForNullables)
        {
            base.RefreshFrom(rhs, SkipNullsForObjects, SkipNullsForNullables);

            CMembersPair rhsMembersPair = rhs as CMembersPair;

            if (rhsMembersPair == null)
            {
                return;
            }

            if (First == null)
            {
                First = rhsMembersPair.First;
            }
            else if (rhsMembersPair.First == null)
            {
                if (!SkipNullsForObjects)
                {
                    First = null;
                }
            }
            else
            {
                First.RefreshFrom(rhsMembersPair.First, SkipNullsForObjects, SkipNullsForNullables);
            }

            if (Second == null)
            {
                Second = rhsMembersPair.Second;
            }
            else if (rhsMembersPair.Second == null)
            {
                if (!SkipNullsForObjects)
                {
                    Second = null;
                }
            }
            else
            {
                Second.RefreshFrom(rhsMembersPair.Second, SkipNullsForObjects, SkipNullsForNullables);
            }


            PairNumber = rhsMembersPair.PairNumber;

            if (!SkipNullsForObjects || rhsMembersPair.BackgroundForShow != null)
            {
                BackgroundForShow = rhsMembersPair.BackgroundForShow;
            }

            if (!SkipNullsForObjects || rhsMembersPair.ForegroundForShow != null)
            {
                ForegroundForShow = rhsMembersPair.ForegroundForShow;
            }
        }
Пример #3
0
        public override void RefreshFrom(ICanRefreshFrom rhs,
                                         bool SkipNullsForObjects,
                                         bool SkipNullsForNullables)
        {
            base.RefreshFrom(rhs, SkipNullsForObjects, SkipNullsForNullables);

            CRoundAndDate rhsRoundAndDate = rhs as CRoundAndDate;

            if (rhsRoundAndDate == null)
            {
                return;
            }

            Date = rhsRoundAndDate.Date;
            Name = rhsRoundAndDate.Name;
        }
Пример #4
0
        public virtual void RefreshFrom(ICanRefreshFrom rhs,
                                        bool SkipNullsForObjects,
                                        bool SkipNullsForNullables)
        {
            CDBAdditionalClassBase rhsDBAdditionalClassBase = rhs as CDBAdditionalClassBase;

            if (rhsDBAdditionalClassBase == null)
            {
                return;
            }

            if (!SkipNullsForNullables || rhsDBAdditionalClassBase.Place.HasValue)
            {
                Place = rhsDBAdditionalClassBase.Place;
            }

            if (!SkipNullsForNullables || rhsDBAdditionalClassBase.PlaceInFilter.HasValue)
            {
                PlaceInFilter = rhsDBAdditionalClassBase.PlaceInFilter;
            }
        }
Пример #5
0
        public override void RefreshFrom(ICanRefreshFrom rhs,
                                         bool SkipNullsForObjects,
                                         bool SkipNullsForNullables)
        {
            base.RefreshFrom(rhs, SkipNullsForObjects, SkipNullsForNullables);

            CFullMemberInfo rhsFullMemberInfo = rhs as CFullMemberInfo;

            if (rhsFullMemberInfo == null)
            {
                return;
            }

            IDMember = rhsFullMemberInfo.IDMember;
            Name     = rhsFullMemberInfo.Name;
            Surname  = rhsFullMemberInfo.Surname;

            if (!SkipNullsForNullables || rhsFullMemberInfo.YearOfBirth.HasValue)
            {
                YearOfBirth = rhsFullMemberInfo.YearOfBirth;
            }

            if (!SkipNullsForNullables || rhsFullMemberInfo.Coach.HasValue)
            {
                Coach = rhsFullMemberInfo.Coach;
            }

            if (!SkipNullsForNullables || rhsFullMemberInfo.Team.HasValue)
            {
                Team = rhsFullMemberInfo.Team;
            }

            if (!SkipNullsForNullables || rhsFullMemberInfo.InitGrade.HasValue)
            {
                InitGrade = rhsFullMemberInfo.InitGrade;
            }

            SecondCol = rhsFullMemberInfo.SecondCol;
        }
Пример #6
0
        public override void RefreshFrom(ICanRefreshFrom rhs,
                                         bool SkipNullsForObjects,
                                         bool SkipNullsForNullables)
        {
            base.RefreshFrom(rhs, SkipNullsForObjects, SkipNullsForNullables);

            CMemberAndPart rhsMemberAndPart = rhs as CMemberAndPart;

            if (rhsMemberAndPart == null)
            {
                return;
            }

            if (!SkipNullsForObjects || rhsMemberAndPart.Member != null)
            {
                Member = rhsMemberAndPart.Member;
            }

            if (!SkipNullsForObjects || rhsMemberAndPart.Participation != null)
            {
                Participation = rhsMemberAndPart.Participation;
            }
        }
Пример #7
0
        public override void RefreshFrom(ICanRefreshFrom rhs,
                                         bool SkipNullsForObjects,
                                         bool SkipNullsForNullables)
        {
            base.RefreshFrom(rhs, SkipNullsForObjects, SkipNullsForNullables);

            CMemberAndResults rhsMemberAndResults = rhs as CMemberAndResults;

            if (rhsMemberAndResults == null)
            {
                return;
            }

            if (MemberInfo == null)
            {
                MemberInfo = rhsMemberAndResults.MemberInfo;
            }
            else if (rhsMemberAndResults.MemberInfo == null)
            {
                if (!SkipNullsForObjects)
                {
                    MemberInfo = null;
                }
            }
            else
            {
                MemberInfo.RefreshFrom(rhsMemberAndResults.MemberInfo, SkipNullsForObjects, SkipNullsForNullables);
            }

            if (Results == null)
            {
                Results = rhsMemberAndResults.Results;
            }
            else if (rhsMemberAndResults.Results == null)
            {
                if (!SkipNullsForObjects)
                {
                    Results = null;
                }
            }
            else
            {
                Results.RefreshFrom(rhsMemberAndResults.Results, SkipNullsForObjects, SkipNullsForNullables);
            }

            if (!SkipNullsForNullables || rhsMemberAndResults.StartNumber.HasValue)
            {
                StartNumber = rhsMemberAndResults.StartNumber;
            }
            if (!SkipNullsForNullables || rhsMemberAndResults.PrevNumber.HasValue)
            {
                PrevNumber = rhsMemberAndResults.PrevNumber;
            }

            VisibilityInMainTable = rhsMemberAndResults.VisibilityInMainTable;
            HasFalsestart         = rhsMemberAndResults.HasFalsestart;

            if (!SkipNullsForObjects || rhsMemberAndResults.BackgroundForShow != null)
            {
                BackgroundForShow = rhsMemberAndResults.BackgroundForShow;
            }

            if (!SkipNullsForObjects || rhsMemberAndResults.ForegroundForShow != null)
            {
                ForegroundForShow = rhsMemberAndResults.ForegroundForShow;
            }

            FontWeightForShow = rhsMemberAndResults.FontWeightForShow;
            FontStyleForShow  = rhsMemberAndResults.FontStyleForShow;
        }
Пример #8
0
        public override void RefreshFrom(ICanRefreshFrom rhs,
                                         bool SkipNullsForObjects,
                                         bool SkipNullsForNullables)
        {
            base.RefreshFrom(rhs, SkipNullsForObjects, SkipNullsForNullables);

            COneRoundResults rhsOneRoundResults = rhs as COneRoundResults;

            if (rhsOneRoundResults == null)
            {
                return;
            }

            if (Route1 == null)
            {
                Route1 = rhsOneRoundResults.Route1;
            }
            else if (rhsOneRoundResults.Route1 == null)
            {
                if (!SkipNullsForObjects)
                {
                    Route1 = null;
                }
            }
            else
            {
                Route1.RefreshFrom(rhsOneRoundResults.Route1, SkipNullsForObjects, SkipNullsForNullables);
            }

            if (Route2 == null)
            {
                Route2 = rhsOneRoundResults.Route2;
            }
            else if (rhsOneRoundResults.Route2 == null)
            {
                if (!SkipNullsForObjects)
                {
                    Route2 = null;
                }
            }
            else
            {
                Route2.RefreshFrom(rhsOneRoundResults.Route2, SkipNullsForObjects, SkipNullsForNullables);
            }

            if (Sum == null)
            {
                Sum = rhsOneRoundResults.Sum;
            }
            else if (rhsOneRoundResults.Sum == null)
            {
                if (!SkipNullsForObjects)
                {
                    Sum = null;
                }
            }
            else
            {
                Sum.RefreshFrom(rhsOneRoundResults.Sum, SkipNullsForObjects, SkipNullsForNullables);
            }

            m_Round      = rhsOneRoundResults.m_Round;
            IsLastMember = rhsOneRoundResults.IsLastMember;
            IsLooser     = rhsOneRoundResults.IsLooser;
        }
Пример #9
0
        public override void RefreshFrom(ICanRefreshFrom rhs,
                                         bool SkipNullsForObjects,
                                         bool SkipNullsForNullables)
        {
            base.RefreshFrom(rhs, SkipNullsForObjects, SkipNullsForNullables);

            CMemberInTotal rhsMemberInTotal = rhs as CMemberInTotal;

            if (rhsMemberInTotal == null)
            {
                return;
            }

            if (MemberInfo == null)
            {
                MemberInfo = rhsMemberInTotal.MemberInfo;
            }
            else if (rhsMemberInTotal.MemberInfo == null)
            {
                if (!SkipNullsForObjects)
                {
                    MemberInfo = null;
                }
            }
            else
            {
                MemberInfo.RefreshFrom(rhsMemberInTotal.MemberInfo, SkipNullsForObjects, SkipNullsForNullables);
            }

            if (QualifResults == null)
            {
                QualifResults = rhsMemberInTotal.QualifResults;
            }
            else if (rhsMemberInTotal.QualifResults == null)
            {
                if (!SkipNullsForObjects)
                {
                    QualifResults = null;
                }
            }
            else
            {
                QualifResults.RefreshFrom(rhsMemberInTotal.QualifResults, SkipNullsForObjects, SkipNullsForNullables);
            }

            if (Qualif2Results == null)
            {
                Qualif2Results = rhsMemberInTotal.Qualif2Results;
            }
            else if (rhsMemberInTotal.Qualif2Results == null)
            {
                if (!SkipNullsForObjects)
                {
                    Qualif2Results = null;
                }
            }
            else
            {
                Qualif2Results.RefreshFrom(rhsMemberInTotal.Qualif2Results, SkipNullsForObjects, SkipNullsForNullables);
            }

            if (OneEighthFinalResults == null)
            {
                OneEighthFinalResults = rhsMemberInTotal.OneEighthFinalResults;
            }
            else if (rhsMemberInTotal.OneEighthFinalResults == null)
            {
                if (!SkipNullsForObjects)
                {
                    OneEighthFinalResults = null;
                }
            }
            else
            {
                OneEighthFinalResults.RefreshFrom(rhsMemberInTotal.OneEighthFinalResults, SkipNullsForObjects, SkipNullsForNullables);
            }

            if (QuaterFinalResults == null)
            {
                QuaterFinalResults = rhsMemberInTotal.QuaterFinalResults;
            }
            else if (rhsMemberInTotal.QuaterFinalResults == null)
            {
                if (!SkipNullsForObjects)
                {
                    QuaterFinalResults = null;
                }
            }
            else
            {
                QuaterFinalResults.RefreshFrom(rhsMemberInTotal.QuaterFinalResults, SkipNullsForObjects, SkipNullsForNullables);
            }

            if (SemiFinalResults == null)
            {
                SemiFinalResults = rhsMemberInTotal.SemiFinalResults;
            }
            else if (rhsMemberInTotal.SemiFinalResults == null)
            {
                if (!SkipNullsForObjects)
                {
                    SemiFinalResults = null;
                }
            }
            else
            {
                SemiFinalResults.RefreshFrom(rhsMemberInTotal.SemiFinalResults, SkipNullsForObjects, SkipNullsForNullables);
            }

            if (FinalResults == null)
            {
                FinalResults = rhsMemberInTotal.FinalResults;
            }
            else if (rhsMemberInTotal.FinalResults == null)
            {
                if (!SkipNullsForObjects)
                {
                    FinalResults = null;
                }
            }
            else
            {
                FinalResults.RefreshFrom(rhsMemberInTotal.FinalResults, SkipNullsForObjects, SkipNullsForNullables);
            }


            if (!SkipNullsForNullables || rhsMemberInTotal.TotalGrade.HasValue)
            {
                TotalGrade = rhsMemberInTotal.TotalGrade;
            }

            if (!SkipNullsForNullables || rhsMemberInTotal.BallsForPlaces.HasValue)
            {
                BallsForPlaces = rhsMemberInTotal.BallsForPlaces;
            }

            id_part = rhsMemberInTotal.id_part;
        }