Пример #1
0
        public override SpanQuery GetSpanQuery(XmlElement e)
        {
            string fieldName = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
            string value     = DOMUtils.GetNonBlankTextOrFail(e);

            JCG.List <SpanQuery> clausesList = new JCG.List <SpanQuery>();

            TokenStream ts = null;

            try
            {
                ts = analyzer.GetTokenStream(fieldName, value);
                ITermToBytesRefAttribute termAtt = ts.AddAttribute <ITermToBytesRefAttribute>();
                BytesRef bytes = termAtt.BytesRef;
                ts.Reset();
                while (ts.IncrementToken())
                {
                    termAtt.FillBytesRef();
                    SpanTermQuery stq = new SpanTermQuery(new Term(fieldName, BytesRef.DeepCopyOf(bytes)));
                    clausesList.Add(stq);
                }
                ts.End();
                SpanOrQuery soq = new SpanOrQuery(clausesList.ToArray(/*new SpanQuery[clausesList.size()]*/));
                soq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
                return(soq);
            }
            catch (Exception ioe) when(ioe.IsIOException())
            {
                throw new ParserException("IOException parsing value:" + value, ioe);
            }
            finally
            {
                IOUtils.DisposeWhileHandlingException(ts);
            }
        }
Пример #2
0
        /// <summary>
        /// (non-Javadoc)
        /// @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        public virtual Query GetQuery(XmlElement e)
        {
            string text = DOMUtils.GetText(e);

            try
            {
                Query q = null;
                if (unSafeParser != null)
                {
                    //synchronize on unsafe parser
                    lock (unSafeParser)
                    {
                        q = unSafeParser.Parse(text);
                    }
                }
                else
                {
                    string fieldName = DOMUtils.GetAttribute(e, "fieldName", defaultField);
                    //Create new parser
                    QueryParser parser = CreateQueryParser(fieldName, analyzer);
                    q = parser.Parse(text);
                }
                q.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
                return(q);
            }
            catch (ParseException e1)
            {
                throw new ParserException(e1.Message);
            }
        }
Пример #3
0
        /// <summary>
        /// (non-Javadoc)
        /// @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        public virtual Query GetQuery(XmlElement e)
        {
            BooleanQuery bq = new BooleanQuery(DOMUtils.GetAttribute(e, "disableCoord", false));

            bq.MinimumNumberShouldMatch = DOMUtils.GetAttribute(e, "minimumNumberShouldMatch", 0);
            bq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);

            XmlNodeList nl = e.ChildNodes;

            for (int i = 0; i < nl.Count; i++)
            {
                XmlNode node = nl.Item(i);
                if (node.LocalName.Equals("Clause", StringComparison.Ordinal))
                {
                    XmlElement clauseElem = (XmlElement)node;
                    Occur      occurs     = GetOccursValue(clauseElem);

                    XmlElement clauseQuery = DOMUtils.GetFirstChildOrFail(clauseElem);
                    Query      q           = factory.GetQuery(clauseQuery);
                    bq.Add(new BooleanClause(q, occurs));
                }
            }

            return(bq);
        }
Пример #4
0
        /// <summary>
        /// (non-Javadoc)
        /// @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        public virtual Query GetQuery(XmlElement e)
        {
            string text = DOMUtils.GetText(e);

            try
            {
                Query q = null;
                if (unSafeParser != null)
                {
                    //synchronize on unsafe parser
                    UninterruptableMonitor.Enter(unSafeParser);
                    try
                    {
                        q = unSafeParser.Parse(text);
                    }
                    finally
                    {
                        UninterruptableMonitor.Exit(unSafeParser);
                    }
                }
                else
                {
                    string fieldName = DOMUtils.GetAttribute(e, "fieldName", defaultField);
                    //Create new parser
                    QueryParser parser = CreateQueryParser(fieldName, analyzer);
                    q = parser.Parse(text);
                }
                q.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
                return(q);
            }
            catch (Lucene.Net.QueryParsers.Classic.ParseException e1) // LUCENENET: Classic QueryParser has its own ParseException that is different than the one in Support
            {
                throw new ParserException(e1.Message, e1);
            }
        }
Пример #5
0
        public virtual Query GetQuery(XmlElement e)
        {
            string    field = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
            string    value = DOMUtils.GetNonBlankTextOrFail(e);
            TermQuery tq    = new TermQuery(new Term(field, value));

            tq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
            return(tq);
        }
Пример #6
0
        public virtual Query GetQuery(XmlElement e)
        {
            XmlElement filterElem = DOMUtils.GetFirstChildOrFail(e);

            Query q = new ConstantScoreQuery(filterFactory.GetFilter(filterElem));

            q.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
            return(q);
        }
Пример #7
0
        public override SpanQuery GetSpanQuery(XmlElement e)
        {
            string        fieldName = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
            string        value     = DOMUtils.GetNonBlankTextOrFail(e);
            SpanTermQuery stq       = new SpanTermQuery(new Term(fieldName, value));

            stq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
            return(stq);
        }
Пример #8
0
        public virtual Query GetQuery(XmlElement e)
        {
            string field          = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
            string lowerTerm      = DOMUtils.GetAttributeOrFail(e, "lowerTerm");
            string upperTerm      = DOMUtils.GetAttributeOrFail(e, "upperTerm");
            bool   lowerInclusive = DOMUtils.GetAttribute(e, "includeLower", true);
            bool   upperInclusive = DOMUtils.GetAttribute(e, "includeUpper", true);
            int    precisionStep  = DOMUtils.GetAttribute(e, "precisionStep", NumericUtils.PRECISION_STEP_DEFAULT);

            string type = DOMUtils.GetAttribute(e, "type", "int");

            try
            {
                Query filter;
                if (type.Equals("int", StringComparison.OrdinalIgnoreCase))
                {
                    filter = NumericRangeQuery.NewInt32Range(field, precisionStep,
                                                             J2N.Numerics.Int32.Parse(lowerTerm, NumberFormatInfo.InvariantInfo),
                                                             J2N.Numerics.Int32.Parse(upperTerm, NumberFormatInfo.InvariantInfo),
                                                             lowerInclusive,
                                                             upperInclusive);
                }
                else if (type.Equals("long", StringComparison.OrdinalIgnoreCase))
                {
                    filter = NumericRangeQuery.NewInt64Range(field, precisionStep,
                                                             J2N.Numerics.Int64.Parse(lowerTerm, NumberFormatInfo.InvariantInfo),
                                                             J2N.Numerics.Int64.Parse(upperTerm, NumberFormatInfo.InvariantInfo),
                                                             lowerInclusive,
                                                             upperInclusive);
                }
                else if (type.Equals("double", StringComparison.OrdinalIgnoreCase))
                {
                    filter = NumericRangeQuery.NewDoubleRange(field, precisionStep,
                                                              J2N.Numerics.Double.Parse(lowerTerm, NumberFormatInfo.InvariantInfo),
                                                              J2N.Numerics.Double.Parse(upperTerm, NumberFormatInfo.InvariantInfo),
                                                              lowerInclusive,
                                                              upperInclusive);
                }
                else if (type.Equals("float", StringComparison.OrdinalIgnoreCase))
                {
                    filter = NumericRangeQuery.NewSingleRange(field, precisionStep,
                                                              J2N.Numerics.Single.Parse(lowerTerm, NumberFormatInfo.InvariantInfo),
                                                              J2N.Numerics.Single.Parse(upperTerm, NumberFormatInfo.InvariantInfo),
                                                              lowerInclusive,
                                                              upperInclusive);
                }
                else
                {
                    throw new ParserException("type attribute must be one of: [long, int, double, float]");
                }
                return(filter);
            }
            catch (Exception nfe) when(nfe.IsNumberFormatException())
            {
                throw new ParserException("Could not parse lowerTerm or upperTerm into a number", nfe);
            }
        }
Пример #9
0
        public override SpanQuery GetSpanQuery(XmlElement e)
        {
            string fieldName = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
            string value     = DOMUtils.GetNonBlankTextOrFail(e);

            PayloadTermQuery btq = new PayloadTermQuery(new Term(fieldName, value), new AveragePayloadFunction());

            btq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
            return(btq);
        }
Пример #10
0
        public virtual Filter GetFilter(XmlElement e)
        {
            string fieldName = DOMUtils.GetAttributeWithInheritance(e, "fieldName");

            string lowerTerm    = e.GetAttribute("lowerTerm");
            string upperTerm    = e.GetAttribute("upperTerm");
            bool   includeLower = DOMUtils.GetAttribute(e, "includeLower", true);
            bool   includeUpper = DOMUtils.GetAttribute(e, "includeUpper", true);

            return(TermRangeFilter.NewStringRange(fieldName, lowerTerm, upperTerm, includeLower, includeUpper));
        }
Пример #11
0
        public override SpanQuery GetSpanQuery(XmlElement e)
        {
            int        end   = DOMUtils.GetAttribute(e, "end", 1);
            XmlElement child = DOMUtils.GetFirstChildElement(e);
            SpanQuery  q     = factory.GetSpanQuery(child);

            SpanFirstQuery sfq = new SpanFirstQuery(q, end);

            sfq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
            return(sfq);
        }
Пример #12
0
        public virtual Filter GetFilter(XmlElement e)
        {
            string field          = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
            string lowerTerm      = DOMUtils.GetAttributeOrFail(e, "lowerTerm");
            string upperTerm      = DOMUtils.GetAttributeOrFail(e, "upperTerm");
            bool   lowerInclusive = DOMUtils.GetAttribute(e, "includeLower", true);
            bool   upperInclusive = DOMUtils.GetAttribute(e, "includeUpper", true);
            int    precisionStep  = DOMUtils.GetAttribute(e, "precisionStep", NumericUtils.PRECISION_STEP_DEFAULT);

            string type = DOMUtils.GetAttribute(e, "type", "int");

            try
            {
                Filter filter;
                if (type.Equals("int", StringComparison.OrdinalIgnoreCase))
                {
                    filter = NumericRangeFilter.NewInt32Range(field, precisionStep, Convert
                                                              .ToInt32(lowerTerm, CultureInfo.InvariantCulture), Convert.ToInt32(upperTerm, CultureInfo.InvariantCulture), lowerInclusive,
                                                              upperInclusive);
                }
                else if (type.Equals("long", StringComparison.OrdinalIgnoreCase))
                {
                    filter = NumericRangeFilter.NewInt64Range(field, precisionStep, Convert
                                                              .ToInt64(lowerTerm, CultureInfo.InvariantCulture), Convert.ToInt64(upperTerm, CultureInfo.InvariantCulture), lowerInclusive,
                                                              upperInclusive);
                }
                else if (type.Equals("double", StringComparison.OrdinalIgnoreCase))
                {
                    filter = NumericRangeFilter.NewDoubleRange(field, precisionStep, Convert
                                                               .ToDouble(lowerTerm, CultureInfo.InvariantCulture), Convert.ToDouble(upperTerm, CultureInfo.InvariantCulture), lowerInclusive,
                                                               upperInclusive);
                }
                else if (type.Equals("float", StringComparison.OrdinalIgnoreCase))
                {
                    filter = NumericRangeFilter.NewSingleRange(field, precisionStep, Convert
                                                               .ToSingle(lowerTerm, CultureInfo.InvariantCulture), Convert.ToSingle(upperTerm, CultureInfo.InvariantCulture), lowerInclusive,
                                                               upperInclusive);
                }
                else
                {
                    throw new ParserException("type attribute must be one of: [long, int, double, float]");
                }
                return(filter);
            }
            catch (FormatException nfe)
            {
                if (strictMode)
                {
                    throw new ParserException("Could not parse lowerTerm or upperTerm into a number", nfe);
                }
                return(NO_MATCH_FILTER);
            }
        }
Пример #13
0
        public override SpanQuery GetSpanQuery(XmlElement e)
        {
            string slopString = DOMUtils.GetAttributeOrFail(e, "slop");
            int    slop       = int.Parse(slopString, CultureInfo.InvariantCulture);
            bool   inOrder    = DOMUtils.GetAttribute(e, "inOrder", false);

            JCG.List <SpanQuery> spans = new JCG.List <SpanQuery>();
            for (XmlNode kid = e.FirstChild; kid != null; kid = kid.NextSibling)
            {
                if (kid.NodeType == XmlNodeType.Element)
                {
                    spans.Add(factory.GetSpanQuery((XmlElement)kid));
                }
            }
            SpanQuery[] spanQueries = spans.ToArray(/*new SpanQuery[spans.size()]*/);
            return(new SpanNearQuery(spanQueries, slop, inOrder));
        }
Пример #14
0
        public override SpanQuery GetSpanQuery(XmlElement e)
        {
            JCG.List <SpanQuery> clausesList = new JCG.List <SpanQuery>();
            for (XmlNode kid = e.FirstChild; kid != null; kid = kid.NextSibling)
            {
                if (kid.NodeType == XmlNodeType.Element)
                {
                    SpanQuery clause = factory.GetSpanQuery((XmlElement)kid);
                    clausesList.Add(clause);
                }
            }
            SpanQuery[] clauses = clausesList.ToArray(/*new SpanQuery[clausesList.size()]*/);
            SpanOrQuery soq     = new SpanOrQuery(clauses);

            soq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
            return(soq);
        }
Пример #15
0
        /// <summary>
        /// (non-Javadoc)
        /// @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
        /// </summary>
        public virtual Query GetQuery(XmlElement e)
        {
            XmlElement filterElement = DOMUtils.GetChildByTagOrFail(e, "Filter");

            filterElement = DOMUtils.GetFirstChildOrFail(filterElement);
            Filter f = filterFactory.GetFilter(filterElement);

            XmlElement queryElement = DOMUtils.GetChildByTagOrFail(e, "Query");

            queryElement = DOMUtils.GetFirstChildOrFail(queryElement);
            Query q = queryFactory.GetQuery(queryElement);

            FilteredQuery fq = new FilteredQuery(q, f);

            fq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
            return(fq);
        }
Пример #16
0
        public virtual Query GetQuery(XmlElement e)
        {
            XmlElement mainQueryElem = DOMUtils.GetChildByTagOrFail(e, "Query");

            mainQueryElem = DOMUtils.GetFirstChildOrFail(mainQueryElem);
            Query mainQuery = factory.GetQuery(mainQueryElem);

            XmlElement boostQueryElem = DOMUtils.GetChildByTagOrFail(e, "BoostQuery");
            float      boost          = DOMUtils.GetAttribute(boostQueryElem, "boost", DEFAULT_BOOST);

            boostQueryElem = DOMUtils.GetFirstChildOrFail(boostQueryElem);
            Query boostQuery = factory.GetQuery(boostQueryElem);

            BoostingQuery bq = new BoostingQuery(mainQuery, boostQuery, boost);

            bq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
            return(bq);
        }
Пример #17
0
        public override SpanQuery GetSpanQuery(XmlElement e)
        {
            XmlElement includeElem = DOMUtils.GetChildByTagOrFail(e, "Include");

            includeElem = DOMUtils.GetFirstChildOrFail(includeElem);

            XmlElement excludeElem = DOMUtils.GetChildByTagOrFail(e, "Exclude");

            excludeElem = DOMUtils.GetFirstChildOrFail(excludeElem);

            SpanQuery include = factory.GetSpanQuery(includeElem);
            SpanQuery exclude = factory.GetSpanQuery(excludeElem);

            SpanNotQuery snq = new SpanNotQuery(include, exclude);

            snq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
            return(snq);
        }
Пример #18
0
        /// <summary>
        /// (non-Javadoc)
        /// @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
        /// </summary>
        public virtual Query GetQuery(XmlElement e)
        {
            float tieBreaker       = DOMUtils.GetAttribute(e, "tieBreaker", 0.0f);
            DisjunctionMaxQuery dq = new DisjunctionMaxQuery(tieBreaker);

            dq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);

            XmlNodeList nl = e.ChildNodes;

            for (int i = 0; i < nl.Count; i++)
            {
                XmlNode node = nl.Item(i);
                if (node is XmlElement queryElem)
                { // all elements are disjuncts.
                    Query q = factory.GetQuery(queryElem);
                    dq.Add(q);
                }
            }

            return(dq);
        }
Пример #19
0
        public virtual Query GetQuery(XmlElement e)
        {
            XmlNodeList        nl          = e.GetElementsByTagName("Field");
            int                maxNumTerms = DOMUtils.GetAttribute(e, "maxNumTerms", DEFAULT_MAX_NUM_TERMS);
            FuzzyLikeThisQuery fbq         = new FuzzyLikeThisQuery(maxNumTerms, analyzer);

            fbq.IgnoreTF = DOMUtils.GetAttribute(e, "ignoreTF", DEFAULT_IGNORE_TF);

            for (int i = 0; i < nl.Count; i++)
            {
                XmlElement fieldElem     = (XmlElement)nl.Item(i);
                float      minSimilarity = DOMUtils.GetAttribute(fieldElem, "minSimilarity", DEFAULT_MIN_SIMILARITY);
                int        prefixLength  = DOMUtils.GetAttribute(fieldElem, "prefixLength", DEFAULT_PREFIX_LENGTH);
                string     fieldName     = DOMUtils.GetAttributeWithInheritance(fieldElem, "fieldName");

                string value = DOMUtils.GetText(fieldElem);
                fbq.AddTerms(value, fieldName, minSimilarity, prefixLength);
            }

            fbq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
            return(fbq);
        }
Пример #20
0
        public virtual Query GetQuery(XmlElement e)
        {
            string fieldName = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
            string text      = DOMUtils.GetNonBlankTextOrFail(e);

            BooleanQuery bq = new BooleanQuery(DOMUtils.GetAttribute(e, "disableCoord", false));

            bq.MinimumNumberShouldMatch = DOMUtils.GetAttribute(e, "minimumNumberShouldMatch", 0);
            TokenStream ts = null;

            try
            {
                ts = analyzer.GetTokenStream(fieldName, text);
                ITermToBytesRefAttribute termAtt = ts.AddAttribute <ITermToBytesRefAttribute>();
                Term     term  = null;
                BytesRef bytes = termAtt.BytesRef;
                ts.Reset();
                while (ts.IncrementToken())
                {
                    termAtt.FillBytesRef();
                    term = new Term(fieldName, BytesRef.DeepCopyOf(bytes));
                    bq.Add(new BooleanClause(new TermQuery(term), Occur.SHOULD));
                }
                ts.End();
            }
            catch (Exception ioe) when(ioe.IsIOException())
            {
                throw RuntimeException.Create("Error constructing terms from index:" + ioe, ioe);
            }
            finally
            {
                IOUtils.DisposeWhileHandlingException(ts);
            }

            bq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
            return(bq);
        }
Пример #21
0
        public virtual Filter GetFilter(XmlElement e)
        {
            string          fieldName = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
            DuplicateFilter df        = new DuplicateFilter(fieldName);

            string keepMode = DOMUtils.GetAttribute(e, "keepMode", "first");

            if (keepMode.Equals("first", StringComparison.OrdinalIgnoreCase))
            {
                df.KeepMode = KeepMode.KM_USE_FIRST_OCCURRENCE;
            }
            else if (keepMode.Equals("last", StringComparison.OrdinalIgnoreCase))
            {
                df.KeepMode = KeepMode.KM_USE_LAST_OCCURRENCE;
            }
            else
            {
                throw new ParserException("Illegal keepMode attribute in DuplicateFilter:" + keepMode);
            }

            string processingMode = DOMUtils.GetAttribute(e, "processingMode", "full");

            if (processingMode.Equals("full", StringComparison.OrdinalIgnoreCase))
            {
                df.ProcessingMode = ProcessingMode.PM_FULL_VALIDATION;
            }
            else if (processingMode.Equals("fast", StringComparison.OrdinalIgnoreCase))
            {
                df.ProcessingMode = ProcessingMode.PM_FAST_INVALIDATION;
            }
            else
            {
                throw new ParserException("Illegal processingMode attribute in DuplicateFilter:" + processingMode);
            }

            return(df);
        }
Пример #22
0
        /// <summary>
        /// (non-Javadoc)
        /// @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
        /// </summary>
        public virtual Query GetQuery(XmlElement e)
        {
            string fieldsList = e.GetAttribute("fieldNames"); //a comma-delimited list of fields

            string[] fields = defaultFieldNames;
            if ((fieldsList != null) && (fieldsList.Trim().Length > 0))
            {
                fields = fieldsList.Trim().Split(',').TrimEnd();
                //trim the fieldnames
                for (int i = 0; i < fields.Length; i++)
                {
                    fields[i] = fields[i].Trim();
                }
            }

            //Parse any "stopWords" attribute
            //TODO MoreLikeThis needs to ideally have per-field stopWords lists - until then
            //I use all analyzers/fields to generate multi-field compatible stop list
            string        stopWords    = e.GetAttribute("stopWords");
            ISet <string> stopWordsSet = null;

            if ((stopWords != null) && (fields != null))
            {
                stopWordsSet = new JCG.HashSet <string>();
                foreach (string field in fields)
                {
                    TokenStream ts = null;
                    try
                    {
                        ts = analyzer.GetTokenStream(field, stopWords);
                        ICharTermAttribute termAtt = ts.AddAttribute <ICharTermAttribute>();
                        ts.Reset();
                        while (ts.IncrementToken())
                        {
                            stopWordsSet.Add(termAtt.ToString());
                        }
                        ts.End();
                    }
                    catch (IOException ioe)
                    {
                        throw new ParserException("IoException parsing stop words list in "
                                                  + GetType().Name + ":" + ioe.Message);
                    }
                    finally
                    {
                        IOUtils.DisposeWhileHandlingException(ts);
                    }
                }
            }

            MoreLikeThisQuery mlt = new MoreLikeThisQuery(DOMUtils.GetText(e), fields, analyzer, fields[0]);

            mlt.MaxQueryTerms       = DOMUtils.GetAttribute(e, "maxQueryTerms", DEFAULT_MAX_QUERY_TERMS);
            mlt.MinTermFrequency    = DOMUtils.GetAttribute(e, "minTermFrequency", DEFAULT_MIN_TERM_FREQUENCY);
            mlt.PercentTermsToMatch = DOMUtils.GetAttribute(e, "percentTermsToMatch", DEFAULT_PERCENT_TERMS_TO_MATCH) / 100;
            mlt.StopWords           = stopWordsSet;
            int minDocFreq = DOMUtils.GetAttribute(e, "minDocFreq", -1);

            if (minDocFreq >= 0)
            {
                mlt.MinDocFreq = minDocFreq;
            }

            mlt.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);

            return(mlt);
        }