protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     OGSWords = ((AllOGSWords)algorithms.FindByInternalName(AlgorithmNames.DivorcedWords.AllOGSWords.InternalName)).OGSWords;
     _hasSentenceDivorcedSubjects =
         algorithms.FindByInternalName(AlgorithmNames.DivorcedWords.FindDivorcedSubject.InternalName)
             .AlgResult.HelperData.Rows.Count > 0;
     return new BaseSentenceAlgorithmData();
 }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            // источник 4.2
            _finalPredicatesCombinations = (algorithms.FindByInternalName(AlgorithmNames.Predicate.GenerateAllPredicates.InternalName) as GenerateAllPredicates).FinalPredicatesCombinations;

            return
                algorithms.FindByInternalName(AlgorithmNames.Predicate.GenerateAllPredicates.InternalName).AlgResult;
        }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            _apr3InsertsResults = algorithms.FindByInternalName(AlgorithmNames.PreProcessing.Inserts.InternalName, false)?.AlgResult;
            _apr4CheckGB = algorithms.FindByInternalName(AlgorithmNames.PreProcessing.CheckGB.InternalName, false)?.AlgResult;
            _apr2EnumerationBlockResults = algorithms.FindByInternalName(AlgorithmNames.PreProcessing.Enumerations.InternalName, false)?.AlgResult;

            return new BaseSentenceAlgorithmData();
        }
Beispiel #4
0
        public BaseHelperData CheckDataArrays(List<BaseSentenceAlgorithm> algorithms)
        {
            var result = new GeneralHelperData();
            result.PrimaryKey = null;

            var index = 0;
            // добавляем колонки
            foreach (var pair in DataArraysForCheckColunmNames)
            {
                var algorithmResult = algorithms.FindByInternalName(pair.Value, false)?.AlgResult;
                if (algorithmResult != null)
                {
                    var column = algorithmResult.HelperData.Columns[pair.Key] as BaseHelperDataColumn;
                    result.Columns.Add(new HelperDataGeneralStringColumn(column.ColumnDocumentationType, column.ColumnDocumentationNr.Replace(".", "_")));
                }
                else
                {
                    result.Columns.Add(new HelperDataGeneralStringColumn("?", "????"));
                }
                index++;

            }

            if (index > 0)
            {
                result.Rows.Add(new object[] { Guid.NewGuid().ToString() });
            }
            index = 3;

            // результаты
            foreach (var pair in DataArraysForCheckColunmNames)
            {
                var algorithmResult = algorithms.FindByInternalName(pair.Value, false)?.AlgResult;
                if (algorithmResult != null)
                {
                    var column = algorithmResult.HelperData.Columns[pair.Key] as BaseHelperDataColumn;

                    var values = algorithmResult.HelperData.ColumnValues<object>(pair.Key);
                    if (string.Join(" ", values.Select(x => x.ToString())) == string.Join(" ", GetAllIds(column).Select(x => x)))
                        result.Rows[0][index] = "ОК";
                    else
                        result.Rows[0][index] = "!!!!!!!";
                }
                else
                {
                    result.Rows[0][index] = "----";
                }
                index++;

            }

            CheckResult = result;

            return CheckResult;
        }
 protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     // источник данных алгоритм 0.4
     return
         algorithms.FindByInternalName(
             AlgorithmNames.UniformParts.QuasiUniformPartsAttachmentPreliminary.InternalName).AlgResult;
 }
Beispiel #6
0
 public static void RetrieveSubCharacterImages(string path, string rootPath, string _namespace, bool trimRootPath, out LogDataList log, ref List <RMCharImageGroup> collection, RMCharImageFile.ImageTypes imageType, RMCharImageCollection parent)
 {
     log = new LogDataList();
     log.WriteInformationLog(LoggerMessages.RMPackage.Info.RetrievedAutoData(parent.Parent.Name, path, RMCollectionType.Characters), _namespace);
     string[] files = null;
     try
     {
         files = Directory.GetFiles(path, "*" + RMPConstants.GenFileNamePrefixANDSuffix.PNG);
     }
     catch (Exception ex)
     {
         log.WriteErrorLog(LoggerMessages.RMPackage.Error.RetrieveAutoError(path, parent.Parent.Name, RMCollectionType.Characters), _namespace, ex);
         return;
     }
     if (files == null || files.Length == 0)
     {
         return;
     }
     for (int i = 0; i < files.Length; ++i)
     {
         string realFileName = Path.GetFileNameWithoutExtension(files[i]);
         if (string.IsNullOrWhiteSpace(realFileName))
         {
             continue;
         }
         string nonLoweredPath = files[i];
         files[i] = files[i].ToLower();
         string           fileName = realFileName.ToLower();
         string           rootFileName;
         bool             atlas = IsAnAtlasPartFile(realFileName, out rootFileName);
         RMCharImageGroup parentNode;
         parentNode = collection.FindByInternalName((atlas) ? rootFileName.ToLower() : fileName);
         if (parentNode == null)
         {
             parentNode = new RMCharImageGroup(parent);
             parentNode.internalName = (atlas) ? rootFileName.ToLower() : fileName;
             parentNode.Name         = (atlas) ? rootFileName : realFileName;
             collection.Add(parentNode);
         }
         RMCharImageFile newFile = new RMCharImageFile(parentNode);
         newFile.FileName  = realFileName;
         newFile.ImageType = imageType;
         if (trimRootPath)
         {
             newFile.Path = Helper.GetRelativePath(nonLoweredPath, rootPath);
         }
         else
         {
             newFile.Path = nonLoweredPath;
         }
         parentNode.Files.Add(newFile);
         log.WriteInformationLog(LoggerMessages.RMPackage.Info.RetrievedFile(parent.Parent.Name, nonLoweredPath, RMCollectionType.Characters), _namespace);
     }
 }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            // источник данных алгоритм 1.1 и 1.2
            var prevResultHlpData = new GeneralHelperData();

            prevResultHlpData.Merge(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.Subject.SimpleSubject.InternalName));
            prevResultHlpData.Merge(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.Subject.WhichSubject.InternalName));

            var subjAlgResult = algorithms.FindByInternalName(AlgorithmNames.Subject.SimpleSubject.InternalName).AlgResult;
            subjAlgResult.HelperData = prevResultHlpData;
            return subjAlgResult;
        }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            var initedData = new BaseSentenceAlgorithmData();
            var sourceResult = algorithms.FindByInternalName(AlgorithmNames.DivorcedWords.DivorcedWordsRoot.InternalName).AlgResult;
            initedData.HelperData = new GeneralHelperData();

            var gosIds = sourceResult.HelperData.ColumnIntPositiveValues(HelperDataDivorcedWordsRootRootId.Name);
            var gsfData = algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.DivorcedWords.PhantomPredicateRoot.InternalName);
            var gsfIds = gsfData.ColumnIntPositiveValues(HelperDataPhantomPredicateRootRootId.Name);
            var allGOSIds = gosIds.Concat(gsfIds);

            foreach (var gosId in allGOSIds)
                initedData.HelperData.Rows.Add(Guid.NewGuid().ToString(), gosId, "");

            return initedData;
        }
 protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     GrammaticalBasises = ((AllGO)algorithms.FindByInternalName(AlgorithmNames.GrammaticalBasis.AllGO.InternalName)).GrammaticalBasises;
     return new BaseSentenceAlgorithmData();
 }
Beispiel #10
0
 protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     // источник данных алгоритм 4.1 (таблица 3)
     return algorithms.FindByInternalName(AlgorithmNames.UniformParts.WordWithLostConjunction.InternalName).AlgResult;
 }
 protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     // источник данных алгоритм 2.4
     return algorithms.FindByInternalName(AlgorithmNames.UniformParts.FindElliptedNoun.InternalName).AlgResult;
 }
 protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     // источник 5.3.1
     return algorithms.FindByInternalName(AlgorithmNames.GrammaticalBasis.SubjectPredicatePair.InternalName).AlgResult;
 }
 protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     return algorithms.FindByInternalName(AlgorithmNames.Subject.SubjectUpdateStage1.InternalName).AlgResult;
 }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            GrammaticalBasises = ((FindConjunctedGB)algorithms.FindByInternalName(AlgorithmNames.SimpleSentencesWithNoUniformElements.FindConjunctedGB.InternalName)).GrammaticalBasises;

            return new BaseSentenceAlgorithmData();
        }
 protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     var sourceData = algorithms.FindByInternalName(AlgorithmNames.DivorcedWords.ThenConjunction.InternalName);
     _predicates = sourceData.AlgResult.FinalResults.PredicateBFinalResults.All.FindAll(y => y.PartType == PredicatePartType.Root);
     return sourceData.AlgResult;
 }
        private void _addDataActionsForAddConjunction(List<BaseSentenceAlgorithm> algorithms)
        {
            // - False ParticleI
            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.ParticleIParent.InternalName),
                new ParticleIAddConjunctionPostProcessingAction()));
            // добавление соч связи - ПСС и ССПСС
            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.ConjunctedWordsForPSS.InternalName),
                new PSSAddConjunctionPostProcessingAction()));
            // добавление соч связи - ПЭС и ССПЭС
            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.UPAdjectiveForElliptedNoun.InternalName),
                new PESAddConjunctionPostProcessingAction()));

            // добавление соч связи - Квази ОЧ приложение
            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.QuasiUniformPartsAttachmentMain.InternalName),
                    new QuasiUPAttachmentAddConjunctionPostProcessingAction()));

            // СПСС
            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(algorithms.FindByInternalName(AlgorithmNames.UniformParts.WordWithLostConjunction.InternalName).AlgResult.HelperDataElements.Find(x => x.TableName == WordWithLostConjunction.ResultTableName),
                    new SPSSAddConjunctionPostProcessingAction()));
        }
        private void _addDataActionsForModifySyntacticParent(List<BaseSentenceAlgorithm> algorithms)
        {
            // ложный С
            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.FindFalseConjunctionS.InternalName),
                new FalseSChangeSyntacticParentPostProcessingAction()));
            // ПСС
            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.ConjunctedWordsForPSS.InternalName),
                new PSSChangeSyntacticParentPostProcessingAction()));
            // ПЭС
            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.UPAdjectiveForElliptedNoun.InternalName),
                new PESChangeSyntacticParentPostProcessingAction()));
            // признак связи для ПЭС
            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.ElliptedNounLinkFeature.InternalName),
                new PESFeatureLinkChangeSyntacticParentPostProcessingAction()));

            // квази ОЧ приложения
            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.QuasiUniformPartsAttachmentMain.InternalName),
                new QuasiUPAttachmentChangeSyntacticParentPostProcessingAction()));

            // СПСС
            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(algorithms.FindByInternalName(AlgorithmNames.UniformParts.WordWithLostConjunction.InternalName).AlgResult.HelperDataElements.Find(x => x.TableName == WordWithLostConjunction.ResultTableName),
                new SPSSChangeSyntacticParentPostProcessingAction()));
        }
        private void _addDataActionsForModifyPartOfSpeech(List<BaseSentenceAlgorithm> algorithms)
        {
            // частица И
            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.FindFalseParticleI.InternalName),
                new ParticleIChangePartOfSpeechPostProcessingAction()));

            // союз С
            var data = new BaseSentenceAlgorithmData();
            var falseSalg = algorithms.FindByInternalName(AlgorithmNames.UniformParts.FindFalseConjunctionS.InternalName) as FindFalseConjunctionS;
            data.Sentence = falseSalg.AlgResult.Sentence;
            data.HelperData = new GeneralHelperData();

            if (falseSalg.FalseSIds != null)
            {
                foreach (var falseSSentenceElement in falseSalg.FalseSIds.Select(falseSId => data.Sentence.GetElement(falseSId)))
                {
                    data.HelperData.Rows.Add(falseSSentenceElement.GUID, falseSSentenceElement.Id, falseSSentenceElement.Text);
                }
            }

            _dataAndActions.Add(new KeyValuePair<BaseHelperData, BasePostProcessingAction>(data.HelperData, new FalseSChangePartOfSpeechPostProcessingAction()));
        }
 protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     // источник данных алгоритм 1.2
     return algorithms.FindByInternalName(AlgorithmNames.UniformParts.ConjunctedWordsForPSS.InternalName).AlgResult; ;
 }
 protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     // источник 4.1
     return
         algorithms.FindByInternalName(AlgorithmNames.Predicate.ConjunctedPredicates.InternalName).AlgResult;
 }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            var independentInfinitiveResultHlpData = algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.Predicate.IndependentInfinitive.InternalName);
            var participlesResultHlpData = algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.Predicate.Participles.InternalName);
            var adverbialParticiplesAndPhantomsResultHlpData = algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.Predicate.AdverbialParticiplesAndPhantom.InternalName);

            var predicateInfos = new List<Tuple<string, PredicateType>>();

            foreach (DataRow row in independentInfinitiveResultHlpData.Rows)
            {
                var predicateId = row.Field<int>(HelperDataIndependentInfinitiveTruePredicateIds.Name);
                if (predicateId > 0)
                    predicateInfos.Add(new Tuple<string, PredicateType>(row.Field<string>(HelperDataColumnElementGUID.Name), PredicateType.Predicate));
            }

            foreach (DataRow row in participlesResultHlpData.Rows)
            {
                var participleId = row.Field<int>(HelperDataParticiplesParticipleFinalId.Name);
                if (participleId > 0)
                    predicateInfos.Add(new Tuple<string, PredicateType>(row.Field<string>(HelperDataColumnElementGUID.Name), PredicateType.Participle));
            }

            foreach (DataRow row in adverbialParticiplesAndPhantomsResultHlpData.Rows)
            {
                var advParticipleId = row.Field<int>(HelperDataAdverbialParticiplesAdverbialParticipleIds.Name);
                var phantomId = row.Field<int>(HelperDataAdverbialParticiplesPhantomIds.Name);

                if (advParticipleId > 0)
                    predicateInfos.Add(new Tuple<string, PredicateType>(row.Field<string>(HelperDataColumnElementGUID.Name), PredicateType.AdverbialParticiple));
                if (phantomId > 0)
                    predicateInfos.Add(new Tuple<string, PredicateType>(row.Field<string>(HelperDataColumnElementGUID.Name), PredicateType.Phantom));

            }

            var result = new BaseSentenceAlgorithmData();
            var resultHelpData = new PredicateUnionHelperData(Info.InternalName);
            var tmpAlgResult = algorithms.FindByInternalName(AlgorithmNames.Predicate.IndependentInfinitive.InternalName).AlgResult;

            foreach (var info in predicateInfos)
                resultHelpData.AddOrUpdateCustomRow(info.Item1, tmpAlgResult.Sentence.Elements.Find(x => x.GUID == info.Item1).Id, info.Item2.ToString());

            result.HelperData = resultHelpData;

            return result;
        }
 protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     return algorithms.FindByInternalName(AlgorithmNames.Predicate.SimplePredicate.InternalName).AlgResult;
 }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            // берем КСО сказуемые и смотрим в какие ряды ОЧ они входят
            var uniformPartsRows = algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.UPRowsMerge.InternalName);
            var predicatePartsRows = algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.Predicate.PredicateParts.InternalName);
            var result = new BaseSentenceAlgorithmData
            {
                Sentence = algorithms.FindByInternalName(AlgorithmNames.Predicate.PredicateParts.InternalName).AlgResult.Sentence,
                HelperData = new ConjunctedPredicatesSourceHelperData(Info.InternalName)
            };

            foreach (DataRow row in predicatePartsRows.Rows)
            {
                var predicateGUID = row.Field<string>(HelperDataColumnElementGUID.Name);
                var uniformPartsInfoForPredicate = uniformPartsRows.AsEnumerable().ToList().Find(x => x.Field<string>(HelperDataColumnElementGUID.Name) == predicateGUID);

                var predicateId = row.Field<int>(HelperDataPredicatePartsIds.Name);
                var predicateOrder = row.Field<int>(HelperDataPredicatePartsOrder.Name);
                var predicateParent = row.Field<int>(HelperDataPredicatePartsParentId.Name);
                var predicateType = row.Field<string>(HelperDataPredicatePartsPredicateType.Name);
                var predicatePartParentId = row.Field<int>(HelperDataPredicatePartsPartParentId.Name);
                var predicateLevel = row.Field<int>(HelperDataPredicatePartsPredicatePartLevel.Name);
                var predicatePartType = row.Field<string>(HelperDataPredicatePartsPredicatePartType.Name);

                string predicateUPRowNr;
                if (uniformPartsInfoForPredicate != null)
                    predicateUPRowNr = uniformPartsInfoForPredicate.Field<string>(HelperDataUPRowsUPMergeFullRowNr.Name);
                else
                    predicateUPRowNr = "";

                var realPredicatesData = algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.Predicate.IndependentInfinitive.InternalName);

                var predicateIsReal = realPredicatesData.AsEnumerable()
                    .ToList()
                    .Find(x => x.Field<int>(HelperDataIndependentInfinitiveTruePredicateIds.Name) == predicateId) != null;

                ((ConjunctedPredicatesSourceHelperData) result.HelperData).AddOrUpdateCustomRow(predicateGUID,
                    predicateId, predicateOrder, predicateParent, predicatePartParentId, predicatePartType, predicateLevel, predicateType, predicateUPRowNr, predicateIsReal);
            }

            result.RestoreGapsInIdsAndTextsInHelperData();
            return result;
        }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            var sourceAlgResult = algorithms.FindByInternalName(AlgorithmNames.DivorcedWords.AllOGSWords.InternalName).AlgResult;
            _ogsWords = (algorithms.FindByInternalName(AlgorithmNames.DivorcedWords.AllOGSWords.InternalName) as AllOGSWords).OGSWords;
            _allLOPredicateIds = sourceAlgResult.FinalResults.PredicateBFinalResults.All.Select(x => new { x.Id, x.Order}).Distinct().ToDictionary(x => x.Id, x => x.Order);

            return sourceAlgResult;
        }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            DirectObjects = new List<DirectObject>();
            var sentence = algorithms.FindByInternalName(AlgorithmNames.DirectObject.StandartDirectObject.InternalName).AlgResult.Sentence;

            var data = algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.DirectObject.StandartDirectObject.InternalName);
            _prepareDirectObject(data, HelperDataStandartDirectObjectId.Name, HelperDataStandartDirectObjectConrolPredicateId.Name, HelperDataStandartDirectObjectConrolPredicateNr.Name, DirectObjectType.Direct, sentence);

            data = algorithms.FindByInternalName(AlgorithmNames.DirectObject.WhichDirectObject.InternalName).AlgResult.HelperDataElements.Find(x => x.TableName == WhichDirectObject.MainHelperDataTableName);
            _prepareDirectObject(data, HelperDataWhichDirectObjectObjectMainObjectId.Name, HelperDataWhichDirectObjectObjectMainConrolPredicateId.Name,
                HelperDataWhichDirectObjectObjectMainConrolPredicateNr.Name, DirectObjectType.Which, sentence);

            data = algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.DirectObject.InfinitiveDirectObject.InternalName);
            _prepareDirectObject(data, HelperDataInfinitiveDirectObjectId.Name, HelperDataInfinitiveDirectObjectKSO4Id.Name, HelperDataInfinitiveDirectObjectKSONr.Name, DirectObjectType.Infinitive, sentence);

            return new BaseSentenceAlgorithmData();
        }
 protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     var spCorrelationElements =
         algorithms.FindByInternalName(AlgorithmNames.Subject.SubjectPredicateСorrelation.InternalName)
             .AlgResult.HelperDataElements;
     // получаем таблицу про восстановленные подлежащие БЫТЬ, если она присутствует по факту
     _newPredicatesIds = spCorrelationElements.Count > 1 ? spCorrelationElements[1].ColumnValues<int>(HelperDataRecoveredPredicatesRecoveredPredicateId.Name) :
         new List<int>();
     // источник 4.09
     return algorithms.FindByInternalName(AlgorithmNames.Predicate.PredicateModalityCheck.InternalName).AlgResult;
 }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            _predicateIds = algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.Predicate.PredicateModalityCheck.InternalName).ColumnValues<int>(HelperDataPredicateModalityCheckRootOldPredicateId.Name).ToList();

            return algorithms.FindByInternalName(AlgorithmNames.Subject.SubjectUpdateStage1.InternalName).AlgResult;
        }
 protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
 {
     // источник данных алгоритм 2.2
     return algorithms.FindByInternalName(AlgorithmNames.UniformParts.SubjectAndPredicateConjunction.InternalName).AlgResult;
 }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            GrammaticalBasises = ((MainAndSubordinatingPredicates) algorithms.FindByInternalName(AlgorithmNames.SimpleSentencesWithNoUniformElements.MainAndSubordinatingPredicates.InternalName)).GrammaticalBasises;

            return new BaseSentenceAlgorithmData();
        }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            _uniformPartsFinalResults = algorithms.FindByInternalName(AlgorithmNames.DivorcedWords.RestoreToBe.InternalName).AlgResult.FinalResults.UniformPartsFinalResults;

            return new BaseSentenceAlgorithmData();
        }
        protected override BaseSentenceAlgorithmData InitSourceData(List<BaseSentenceAlgorithm> algorithms)
        {
            // источник данных алгоритм 5.1 -- 5.8

            // структура у всех данных с 5.1 по 5.7 одинаковая, используем структуру от стандартных КСО ОЧ
            var prevResultHlpData = new StandartUPRowsHelperData(Info.InternalName);

            prevResultHlpData.Merge(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.StandartUPRows.InternalName), true, MissingSchemaAction.Ignore);
            prevResultHlpData.PrimaryKey = null;
            prevResultHlpData.Merge(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.ParticleIRows.InternalName), true, MissingSchemaAction.Ignore);
            // Алгоритм удален 19.09.2016
            // prevResultHlpData.Merge(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformPartsFinalResults.QuasiUPRows.InternalName), true, MissingSchemaAction.Ignore);
            prevResultHlpData.Merge(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.SPSSRows.InternalName), true, MissingSchemaAction.Ignore);
            prevResultHlpData.Merge(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.QuasiUPAttachmentRows.InternalName), true, MissingSchemaAction.Ignore);
            prevResultHlpData.Merge(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.QuasiUPAttachmentVerbRows.InternalName), true, MissingSchemaAction.Ignore);
            prevResultHlpData.Merge(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.PSSRows.InternalName), true, MissingSchemaAction.Ignore);
            prevResultHlpData.Merge(algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.AdjectiveForElliptedNounRows.InternalName), true, MissingSchemaAction.Ignore);

            var upAlgResult = algorithms.FindByInternalName(AlgorithmNames.UniformParts.StandartUPRows.InternalName).AlgResult;
            upAlgResult.HelperData = prevResultHlpData;

            _conjunctedLinkHelperData = (ConjunctionLinkFeatureHelperData)algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.ConjunctedLinkFeature.InternalName);
            _elliptedNounLinkHelperData = (ElliptedNounLinkFeatureHelperData)algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.ElliptedNounLinkFeature.InternalName);
            _сonjILinkHelperData = (ConjunctionILinkFeatureHelperData)algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.ConjunctionILinkFeature.InternalName);
            _pssLinkHelperData = (PSSLinkFeatureHelperData)algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.PSSLinkFeature.InternalName);
            _quasiUPAttachmentLinkFeatureHelperData = (QuasiUPAttachmentLinkFeatureHelperData)algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.QuasiUPAttachmentLinkFeature.InternalName);
            _quasiUPAttachmentVerbLinkFeatureHelperData = (QuasiUPAttachmentVerbLinkFeatureHelperData)algorithms.FindHelperDataTableByAlgInternalName(AlgorithmNames.UniformParts.QuasiUPAttachmentVerbLinkFeature.InternalName);

            return upAlgResult;
        }