public void SetFVEKnowledge(IWebFVExtractorKnowledge _knowledge)
 {
     if (_knowledge is semanticFVExtractorKnowledge)
     {
         semanticFVExtractorKnowledge knowledge = (semanticFVExtractorKnowledge)_knowledge;
         WLTableOfIndustryClass      = knowledge.WLTableOfIndustryClass;
         WLChunkTableOfIndustryClass = knowledge.WLChunkTableOfIndustryClass;
         semanticCloud = knowledge.semanticCloud;
     }
     FVEKnowledge = _knowledge;
 }
Exemple #2
0
        public void SaveCaseKnowledge <T>(DocumentSetCase setCase, kFoldValidationCase validationCase, ILogBuilder logger) where T : class, IWebFVExtractorKnowledge, new()
        {
            IWebFVExtractorKnowledge knowledge = GetKnowledgeInstance <T>(setCase, validationCase, logger);

            if (!savedKnowledge.Contains(knowledge))
            {
                lock (savedKnowledgeLock)
                {
                    if (!savedKnowledge.Contains(knowledge))
                    {
                        savedKnowledge.Add(knowledge);
                        knowledge.OnBeforeSave();
                    }
                }
            }
        }
Exemple #3
0
        /// <summary>
        /// Gets the knowledge instance.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="name">The name.</param>
        /// <param name="validationCase">The validation case.</param>
        /// <param name="type">The type.</param>
        /// <param name="logger">The logger.</param>
        /// <returns></returns>
        protected T GetKnowledgeInstance <T>(String name, kFoldValidationCase validationCase, WebFVExtractorKnowledgeType type, ILogBuilder logger) where T : class, IWebFVExtractorKnowledge, new()
        {
            IWebFVExtractorKnowledge knowledge = null;
            Boolean found = false;

            if (type == WebFVExtractorKnowledgeType.aboutCategory)
            {
                if (!registry[validationCase].TryGetValue(name, out knowledge))
                {
                    lock (createKnowledgeLock)
                    {
                        if (!registry[validationCase].ContainsKey(name))
                        {
                            statistics[name] = 0;
                            knowledge        = CreateKnowledgeInstance <T>(name, validationCase, type, logger);
                            registry[validationCase][name] = knowledge;
                        }
                        else
                        {
                            knowledge = registry[validationCase][name];
                        }
                    }
                }
                else
                {
                    found = true;
                }
            }
            else
            {
                if (!registryForCases.TryGetValue(name, out knowledge))
                {
                    lock (createCaseKnowledgeLock)
                    {
                        if (!registryForCases.ContainsKey(name))
                        {
                            statistics[name]       = 0;
                            knowledge              = CreateKnowledgeInstance <T>(name, validationCase, type, logger);
                            registryForCases[name] = knowledge;
                        }
                        else
                        {
                            knowledge = registryForCases[name];
                        }
                    }
                }
                else
                {
                    found = true;
                }
            }


            if (doKeepStatisticsOnAccess)
            {
                if (found)
                {
                    statistics[name]++;
                }
            }

            return(knowledge as T);
        }