/// <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);
}
public void When_adding_filter_to_a_delete_statement()
{
var query = FilteredQuery.Make(_table);
query.AddClause <Person, string>(p => p.Name, Operator.Equal, "Foo", Formatter.AndClauseSeparator);
query.Parameters.Count.ShouldBe(1);
query.Parameters["Name1"].ShouldBe("Foo");
var sql = query.Compile(
Table.MakeOrGet <Person>(GenericSQLDialect.Instance, string.Empty).Delete);
sql.ShouldBe(@"DELETE FROM [Person]
WHERE
1 = 1
AND
([Name]=@Name1);");
}
public void When_creating_a_filtered_query()
{
var queryOne = FilteredQuery.Make(_table);
queryOne.ShouldNotBeNull();
queryOne.Parameters.ShouldBeEmpty();
var sql = queryOne.Compile();
sql.ShouldBe(@"SELECT
[Person].[Id] AS 'Id',
[Person].[Name] AS 'Name',
[Person].[Age] AS 'Age'
FROM [Person]
WHERE
1 = 1;");
}
private Query CreateQuery()
{
CreatePendingClause();
var booleanQuery = new BooleanQuery();
Query resultQuery = booleanQuery;
if (_clauses.Count == 0)
{
if (_filters.Count > 0) // only filters applieds => transform to a boolean query
{
foreach (var clause in _filters)
{
booleanQuery.Add(clause);
}
resultQuery = booleanQuery;
}
else // search all documents, without filter or clause
{
resultQuery = new MatchAllDocsQuery(null);
}
}
else
{
foreach (var clause in _clauses)
{
booleanQuery.Add(clause);
}
if (_filters.Count > 0)
{
var filter = new BooleanQuery();
foreach (var clause in _filters)
{
filter.Add(clause);
}
var queryFilter = new QueryWrapperFilter(filter);
resultQuery = new FilteredQuery(booleanQuery, queryFilter);
}
}
Logger.Debug("New search query: {0}", resultQuery.ToString());
return(resultQuery);
}
private Query CreateQuery()
{
CreatePendingClause();
var booleanQuery = new BooleanQuery();
Query resultQuery = booleanQuery;
if (_clauses.Count == 0)
{
if (_filters.Count > 0)
{
// only filters applied => transform to a boolean query
foreach (var clause in _filters)
{
booleanQuery.Add(clause);
}
resultQuery = booleanQuery;
}
else
{
// search all documents, without filter or clause
resultQuery = new MatchAllDocsQuery();
}
}
else
{
foreach (var clause in _clauses)
{
booleanQuery.Add(clause);
}
if (_filters.Count > 0)
{
var filter = new BooleanQuery();
foreach (var clause in _filters)
{
filter.Add(clause);
}
resultQuery = new FilteredQuery(booleanQuery, new QueryWrapperFilter(filter));
}
}
return(resultQuery);
}
private static TopDocs DoSearch(IndexSearcher searcher, ScoreDoc after, Query q, Filter filter, int n, Sort sort, bool doDocScores, bool doMaxScore, Collector fc)
{
if (filter != null)
{
q = new FilteredQuery(q, filter);
}
int limit = searcher.IndexReader.MaxDoc;
if (limit == 0)
{
limit = 1;
}
n = Math.Min(n, limit);
if (after != null && after.Doc >= limit)
{
throw new System.ArgumentException("after.doc exceeds the number of documents in the reader: after.doc=" + after.Doc + " limit=" + limit);
}
if (sort != null)
{
if (after != null && !(after is FieldDoc))
{
// TODO: if we fix type safety of TopFieldDocs we can
// remove this
throw new System.ArgumentException("after must be a FieldDoc; got " + after);
}
const bool fillFields = true;
var hitsCollector = TopFieldCollector.Create(sort, n, (FieldDoc)after, fillFields, doDocScores, doMaxScore, false);
searcher.Search(q, MultiCollector.Wrap(hitsCollector, fc));
return(hitsCollector.TopDocs());
}
else
{
// TODO: can we pass the right boolean for
// in-order instead of hardwired to false...? we'd
// need access to the protected IS.search methods
// taking Weight... could use reflection...
var hitsCollector = TopScoreDocCollector.Create(n, after, false);
searcher.Search(q, MultiCollector.Wrap(hitsCollector, fc));
return(hitsCollector.TopDocs());
}
}
private static void Call(MethodCallExpression node, FilteredQuery query)
{
QueryParser.InternalParse(node.Arguments[0], query);
Log.WriteLine(string.Format(" -> Call : {0}", node.Method.Name));
switch (node.Method.Name)
{
case "Where":
ParseFilter(node.Arguments[1], query);
break;
case "Query":
ParseQuery(node.Arguments[1], query);
break;
default:
throw new Exception(string.Format("method not supported : {0}", node.Method.Name));
}
}
public void When_adding_equality_clause()
{
var query = FilteredQuery.Make(_table);
query.AddClause <Person, long>(p => p.Id, Operator.Equal, 1, Formatter.AndClauseSeparator);
query.Parameters.Count.ShouldBe(1);
query.Parameters["Id1"].ShouldBe(1);
var sql = query.Compile();
sql.ShouldBe(@"SELECT
[Person].[Id] AS 'Id',
[Person].[Name] AS 'Name',
[Person].[Age] AS 'Age'
FROM [Person]
WHERE
1 = 1
AND
([Id]=@Id1);");
}
public static int DistinctSearch(IndexBase index, SearchNode node, XElement root)
{
try
{
var query = MultiFieldQueryParser.Parse(Lucene.Net.Util.Version.LUCENE_29, node.Queries, node.Fields, node.Occurs, new PanGuAnalyzer(true));
foreach (ContainFilterNode cf in node.ContainFilters)
{
query = new FilteredQuery(query, new ContainFilter(new Term(cf.FieldName, cf.Text)));
}
return(ResponseDistinctSearch(index, query, node, root));
}
catch (Lucene.Net.QueryParsers.ParseException)
{
return(0);
}
catch (Exception ex)
{
throw ex;
}
}
public void When_adding_not_in_clause()
{
var query = FilteredQuery.Make(_table);
query.AddInClause <Person, string>(p => p.Name, Formatter.AndClauseSeparator, false, new[] { "Foo", "Bar" });
query.Parameters.Count.ShouldBe(1);
query.Parameters["Name1"].ShouldBe(new[] { "Foo", "Bar" });
var sql = query.Compile();
sql.ShouldBe(@"SELECT
[Person].[Id] AS 'Id',
[Person].[Name] AS 'Name',
[Person].[Age] AS 'Age'
FROM [Person]
WHERE
1 = 1
AND
([Name] NOT IN @Name1);");
}
private void _checkHits(bool bbox, String ptStr, double distKM, int assertNumFound, params int[] assertIds)
{
SpatialOperation op = SpatialOperation.Intersects;
var pt = (Point)ctx.ReadShape(ptStr);
double distDEG = DistanceUtils.Dist2Degrees(distKM, DistanceUtils.EARTH_MEAN_RADIUS_KM);
Shape shape = ctx.MakeCircle(pt, distDEG);
if (bbox)
{
shape = shape.GetBoundingBox();
}
SpatialArgs args = new SpatialArgs(op, shape);
//args.setDistPrecision(0.025);
Query query;
if (random.NextDouble() > 0.5)
{
query = strategy.MakeQuery(args);
}
else
{
query = new FilteredQuery(new MatchAllDocsQuery(), strategy.MakeFilter(args));
}
SearchResults results = executeQuery(query, 100);
assertEquals("" + shape, assertNumFound, results.numFound);
if (assertIds != null)
{
var resultIds = new HashSet <int>();
foreach (var result in results.results)
{
resultIds.Add(int.Parse(result.document.Get("id")));
}
foreach (int assertId in assertIds)
{
assertTrue("has " + assertId, resultIds.Contains(assertId));
}
}
}
private void _CheckHits(bool bbox, IPoint pt, double distKM, int assertNumFound, params int[] assertIds)
{
SpatialOperation op = SpatialOperation.Intersects;
double distDEG = DistanceUtils.Dist2Degrees(distKM, DistanceUtils.EARTH_MEAN_RADIUS_KM);
IShape shape = ctx.MakeCircle(pt, distDEG);
if (bbox)
{
shape = shape.BoundingBox;
}
SpatialArgs args = new SpatialArgs(op, shape);
//args.setDistPrecision(0.025);
Query query;
if (Random().nextBoolean())
{
query = strategy.MakeQuery(args);
}
else
{
query = new FilteredQuery(new MatchAllDocsQuery(), strategy.MakeFilter(args));
}
SearchResults results = executeQuery(query, 100);
assertEquals("" + shape, assertNumFound, results.numFound);
if (assertIds != null)
{
ISet <int?> resultIds = new HashSet <int?>();
foreach (SearchResult result in results.results)
{
resultIds.add(int.Parse(result.document.Get("id"), CultureInfo.InvariantCulture));
}
foreach (int assertId in assertIds)
{
assertTrue("has " + assertId, resultIds.contains(assertId));
}
}
}
public static LuceneResultNode SearchMaxHit(IndexBase index, SearchNode node, int maxHit)
{
try
{
var query = MultiFieldQueryParser.Parse(Lucene.Net.Util.Version.LUCENE_29, node.Queries, node.Fields, node.Occurs, new PanGuAnalyzer(true));
foreach (ContainFilterNode cf in node.ContainFilters)
{
query = new FilteredQuery(query, new ContainFilter(new Term(cf.FieldName, cf.Text)));
}
return(ResponseSearch(index, query, node, maxHit));
}
catch (Lucene.Net.QueryParsers.ParseException)
{
return(new LuceneResultNode()
{
AllCount = 0, Result = new List <string>()
});
}
catch (Exception ex)
{
throw ex;
}
}
public override Query Rewrite(IndexReader r)
{
if (!query.Clauses.Any())
{
return new MatchAllDocsQuery();
}
IList<Filter> filters = new List<Filter>();
IList<Query> queries = new List<Query>();
IList<BooleanClause> clauses = query.Clauses;
Query baseQuery;
int startIndex;
if (drillDownDims.Count == query.Clauses.Count())
{
baseQuery = new MatchAllDocsQuery();
startIndex = 0;
}
else
{
baseQuery = clauses[0].Query;
startIndex = 1;
}
for (int i = startIndex; i < clauses.Count; i++)
{
BooleanClause clause = clauses[i];
Query queryClause = clause.Query;
Filter filter = GetFilter(queryClause);
if (filter != null)
{
filters.Add(filter);
}
else
{
queries.Add(queryClause);
}
}
if (filters.Count == 0)
{
return query;
}
else
{
// Wrap all filters using FilteredQuery
// TODO: this is hackish; we need to do it because
// BooleanQuery can't be trusted to handle the
// "expensive filter" case. Really, each Filter should
// know its cost and we should take that more
// carefully into account when picking the right
// strategy/optimization:
Query wrapped;
if (queries.Count == 0)
{
wrapped = baseQuery;
}
else
{
// disable coord
BooleanQuery wrappedBQ = new BooleanQuery(true);
if ((baseQuery is MatchAllDocsQuery) == false)
{
wrappedBQ.Add(baseQuery, Occur.MUST);
}
foreach (Query q in queries)
{
wrappedBQ.Add(q, Occur.MUST);
}
wrapped = wrappedBQ;
}
foreach (Filter filter in filters)
{
wrapped = new FilteredQuery(wrapped, filter, FilteredQuery.QUERY_FIRST_FILTER_STRATEGY);
}
return wrapped;
}
}
public virtual Query VisitFilteredQuery(FilteredQuery filteredq)
{
throw new NotImplementedException();
}
public virtual Query VisitFilteredQuery(FilteredQuery filteredq)
{
throw new SnNotSupportedException();
}
public virtual async Task <ICollection <TModel> > ListFilteredAsync(CancellationToken cancellationToken = default)
{
return(await FilteredQuery.ToArrayAsync(cancellationToken));
}
public override Query Rewrite(IndexReader r)
{
if (!query.Clauses.Any())
{
return(new MatchAllDocsQuery());
}
IList <Filter> filters = new List <Filter>();
IList <Query> queries = new List <Query>();
IList <BooleanClause> clauses = query.Clauses;
Query baseQuery;
int startIndex;
if (drillDownDims.Count == query.Clauses.Count)
{
baseQuery = new MatchAllDocsQuery();
startIndex = 0;
}
else
{
baseQuery = clauses[0].Query;
startIndex = 1;
}
for (int i = startIndex; i < clauses.Count; i++)
{
BooleanClause clause = clauses[i];
Query queryClause = clause.Query;
Filter filter = GetFilter(queryClause);
if (filter != null)
{
filters.Add(filter);
}
else
{
queries.Add(queryClause);
}
}
if (filters.Count == 0)
{
return(query);
}
else
{
// Wrap all filters using FilteredQuery
// TODO: this is hackish; we need to do it because
// BooleanQuery can't be trusted to handle the
// "expensive filter" case. Really, each Filter should
// know its cost and we should take that more
// carefully into account when picking the right
// strategy/optimization:
Query wrapped;
if (queries.Count == 0)
{
wrapped = baseQuery;
}
else
{
// disable coord
BooleanQuery wrappedBQ = new BooleanQuery(true);
if ((baseQuery is MatchAllDocsQuery) == false)
{
wrappedBQ.Add(baseQuery, Occur.MUST);
}
foreach (Query q in queries)
{
wrappedBQ.Add(q, Occur.MUST);
}
wrapped = wrappedBQ;
}
foreach (Filter filter in filters)
{
wrapped = new FilteredQuery(wrapped, filter, FilteredQuery.QUERY_FIRST_FILTER_STRATEGY);
}
return(wrapped);
}
}
public virtual async Task <TModel> GetFilteredAsync(Expression <Func <TModel, bool> > filter, CancellationToken cancellationToken = default)
{
return(await FilteredQuery.FirstOrDefaultAsync(filter, cancellationToken));
}
public static List <Picture> GetPicturesOfComputer(
string computerId, string text, string[] tags, DateTime startDate, DateTime endDate, int start = 0, int rows = 10)
{
QueryContainer textContainer;
QueryContainer tagsContainer;
if (string.IsNullOrEmpty(text))
{
textContainer = new MatchAllQuery();
}
else
{
textContainer = new MatchQuery()
{
Field = "Text", Query = text
}
};
if ((tags == null) || (tags.Length > 0))
{
tagsContainer = new MatchAllQuery();
}
else
{
tagsContainer = new QueryContainer(new MatchQuery()
{
Field = "Tags", Query = tags[0]
});
for (int i = 1; i < tags.Length; i++)
{
tagsContainer = tagsContainer && new MatchQuery()
{
Field = "Tags", Query = tags[i]
};
}
}
QueryContainer query = new FilteredQuery()
{
Filter = new FilterContainer(
new RangeFilter()
{
Field = "Date",
GreaterThanOrEqualTo = startDate.ToString("yyyy-MM-ddTHH:mm:ss"),
LowerThanOrEqualTo = endDate.ToString("yyyy-MM-ddTHH:mm:ss")
}),
Query = new QueryContainer(
new MatchQuery()
{
Field = "ComputerId",
Query = computerId
})
};
QueryContainer finalQuery = query && textContainer && tagsContainer;
ISearchResponse <Picture> response =
_elasticClient.Search <Picture>(s => s
.Type(PICTURE_OBJECT_TYPE)
.From(start)
.Size(rows)
.SortAscending("Date")
.Query(finalQuery));
return(response.Documents.ToList());
}
public override Query VisitFilteredQuery(FilteredQuery filteredq)
{
throw new NotImplementedException();
}
public static void Search(JsonWriter jsonWriter,
NuGetSearcherManager searcherManager,
string q,
bool countOnly,
bool includePrerelease,
NuGetVersion semVerLevel,
string sortBy,
int skip,
int take,
string feed,
bool ignoreFilter,
bool luceneQuery)
{
if (jsonWriter == null)
{
throw new ArgumentNullException(nameof(jsonWriter));
}
if (searcherManager == null)
{
throw new ArgumentNullException(nameof(searcherManager));
}
var searcher = searcherManager.Get();
try
{
// The old V2 search service would treat "id:" queries (~match) in the same way as it did "packageid:" (==match).
// If "id:" is in the query, replace it.
if (luceneQuery && !string.IsNullOrEmpty(q) && q.StartsWith("id:", StringComparison.OrdinalIgnoreCase))
{
q = "packageid:" + q.Substring(3);
}
// Build the query
Query query = NuGetQuery.MakeQuery(q, searcher.Owners);
// Build filter
bool includeUnlisted = ignoreFilter;
includePrerelease = ignoreFilter || includePrerelease;
feed = ignoreFilter ? null : feed;
var combinedQuery = new BooleanQuery();
combinedQuery.Add(query, Occur.SHOULD);
// Add this clause to the query here so we still respect semVerLevel that is passed when ignoring filters.
if (!SemVerHelpers.ShouldIncludeSemVer2Results(semVerLevel))
{
combinedQuery.Add(
NuGetQuery.ConstructClauseQuery(
new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30),
MetadataConstants.LuceneMetadata.SemVerLevelPropertyName,
new List <string> {
SemVerHelpers.SemVerLevelKeySemVer2
}),
Occur.MUST_NOT);
}
query = combinedQuery;
Filter filter = null;
if (!ignoreFilter && searcher.TryGetFilter(includeUnlisted, includePrerelease, semVerLevel, feed, out filter))
{
// Filter before running the query (make the search set smaller)
query = new FilteredQuery(query, filter);
}
if (countOnly)
{
DocumentCountImpl(jsonWriter, searcher, query);
}
else
{
ListDocumentsImpl(jsonWriter, searcher, query, sortBy, skip, take, semVerLevel);
}
}
finally
{
searcherManager.Release(searcher);
}
}
public virtual async Task <ICollection <TProject> > ListFilteredAsync <TProject>(CancellationToken cancellationToken = default) where TProject : IModel <TKey>
{
return(await FilteredQuery.ProjectTo <TProject>().ToArrayAsync(cancellationToken));
}
public override Query VisitFilteredQuery(FilteredQuery filteredq)
{
throw new SnNotSupportedException();
}
//TODO this is basically old code that hasn't been verified well and should probably be removed
public virtual Query MakeQueryDistanceScore(SpatialArgs args)
{
// For starters, just limit the bbox
var shape = args.Shape;
if (!(shape is IRectangle || shape is ICircle))
{
throw new NotSupportedException("Only Rectangles and Circles are currently supported, found ["
+ shape.GetType().Name + "]");//TODO
}
IRectangle bbox = shape.BoundingBox;
if (bbox.CrossesDateLine)
{
throw new NotSupportedException("Crossing dateline not yet supported");
}
ValueSource valueSource = null;
Query spatial = null;
SpatialOperation op = args.Operation;
if (SpatialOperation.Is(op,
SpatialOperation.BBoxWithin,
SpatialOperation.BBoxIntersects))
{
spatial = MakeWithin(bbox);
}
else if (SpatialOperation.Is(op,
SpatialOperation.Intersects,
SpatialOperation.IsWithin))
{
spatial = MakeWithin(bbox);
if (args.Shape is ICircle)
{
var circle = (ICircle)args.Shape;
// Make the ValueSource
valueSource = MakeDistanceValueSource(shape.Center);
var vsf = new ValueSourceFilter(
new QueryWrapperFilter(spatial), valueSource, 0, circle.Radius);
spatial = new FilteredQuery(new MatchAllDocsQuery(), vsf);
}
}
else if (op == SpatialOperation.IsDisjointTo)
{
spatial = MakeDisjoint(bbox);
}
if (spatial == null)
{
throw new UnsupportedSpatialOperation(args.Operation);
}
if (valueSource != null)
{
valueSource = new CachingDoubleValueSource(valueSource);
}
else
{
valueSource = MakeDistanceValueSource(shape.Center);
}
Query spatialRankingQuery = new FunctionQuery(valueSource);
var bq = new BooleanQuery();
bq.Add(spatial, BooleanClause.Occur.MUST);
bq.Add(spatialRankingQuery, BooleanClause.Occur.MUST);
return(bq);
}
public virtual async Task <TProject> GetFilteredAsync <TProject>(TKey id, CancellationToken cancellationToken = default) where TProject : IModel <TKey>
{
return(await FilteredQuery.ProjectTo <TProject>().FirstOrDefaultAsync(x => x.Id.Equals(id), cancellationToken));
}
public void TestGetBestFragmentsFilteredPhraseQuery()
{
var helper = new TestHighlightRunner();
helper.TestAction = () =>
{
numHighlights = 0;
var rf = new TermRangeFilter("contents", "john", "john", true, true);
var pq = new PhraseQuery();
pq.Add(new Term("contents", "john"));
pq.Add(new Term("contents", "kennedy"));
var fq = new FilteredQuery(pq, rf);
DoSearching(fq);
helper.DoStandardHighlights(analyzer, searcher, hits, query, this);
// Currently highlights "John" and "Kennedy" separately
Assert.IsTrue(numHighlights == 2,
"Failed to find correct number of highlights " + numHighlights +
" found");
};
helper.Start();
}
public virtual async Task <TModel> GetFilteredAsync(TKey id, CancellationToken cancellationToken = default)
{
return(await FilteredQuery.FirstOrDefaultAsync(x => x.Id.Equals(id), cancellationToken));
}
/// <summary>
/// Deletes the documents for objects of the given type matching the given selection.
/// </summary>
/// <param name="writer">
/// The IndexWriter to delete the documents from.
/// </param>
/// <param name="type">
/// The type of the object to delete documents for.
/// </param>
/// <param name="selection">
/// The Query which selects the documents to delete.
/// </param>
public static void DeleteDocuments(this IndexWriter writer, Type type, Query selection)
{
Query deleteQuery = new FilteredQuery(selection, ObjectMapping.GetTypeFilter(type));
writer.DeleteDocuments(deleteQuery);
}
public virtual async Task <TProject> GetFilteredAsync <TProject>(Expression <Func <TModel, bool> > filter, CancellationToken cancellationToken = default) where TProject : IModel <TKey>
{
return(await FilteredQuery.Where(filter).ProjectTo <TProject>().FirstOrDefaultAsync(cancellationToken));
}
private static void GetTermsFromFilteredQuery(FilteredQuery query, HashSet<WeightedTerm> terms, bool prohibited, string fieldName)
{
GetTerms(query.Query, terms, prohibited, fieldName);
}
/// <summary>
/// Deletes the documents for objects of the given type matching the given selection.
/// </summary>
/// <typeparam name="TObject">
/// The type of the object to delete documents for.
/// </typeparam>
/// <param name="writer">
/// The IndexWriter to delete the documents from.
/// </param>
/// <param name="kind">
/// The kind of type to restrict the search to.
/// </param>
/// <param name="selection">
/// The Query which selects the documents to delete.
/// </param>
public static void DeleteDocuments <TObject>(this IndexWriter writer, DocumentObjectTypeKind kind, Query selection)
{
Query deleteQuery = new FilteredQuery(selection, ObjectMapping.GetTypeFilter <TObject>(kind));
writer.DeleteDocuments(deleteQuery);
}
private static void GetTermsFromFilteredQuery(FilteredQuery query, ISet <WeightedTerm> terms, bool prohibited, string fieldName)
{
GetTerms(query.Query, terms, prohibited, fieldName);
}
public void TestGetBestFragmentsFilteredQuery()
{
var helper = new TestHighlightRunner();
helper.TestAction = () =>
{
numHighlights = 0;
TermRangeFilter rf = new TermRangeFilter("contents", "john", "john", true, true);
SpanQuery[] clauses = {
new SpanTermQuery(new Term("contents", "john")),
new SpanTermQuery(new Term("contents", "kennedy"))
};
SpanNearQuery snq = new SpanNearQuery(clauses, 1, true);
FilteredQuery fq = new FilteredQuery(snq, rf);
DoSearching(fq);
helper.DoStandardHighlights(analyzer, searcher, hits, query, this);
// Currently highlights "John" and "Kennedy" separately
Assert.IsTrue(numHighlights == 2,
"Failed to find correct number of highlights " + numHighlights +
" found");
};
helper.Start();
}
