FilterDefinition.cs

/* Copyright 2010-present MongoDB Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

usingSystem;
usingSystem.Linq.Expressions;
usingMongoDB.Bson;
usingMongoDB.Driver.Core.Misc;
usingMongoDB.Driver.Linq;

namespaceMongoDB.Driver
{
/// <summary>
/// Base class for filters.
/// </summary>
/// <typeparam name="TDocument">The type of the document.</typeparam>
publicabstractclassFilterDefinition<TDocument>
{
privatestaticreadonlyFilterDefinition<TDocument>__empty=newEmptyFilterDefinition<TDocument>();

/// <summary>
/// Gets an empty filter. An empty filter matches everything.
/// </summary>
publicstaticFilterDefinition<TDocument>Empty
{
get{return__empty;}
}

/// <summary>
/// Renders the filter to a <see cref="BsonDocument"/>.
/// </summary>
/// <param name="args">The render arguments.</param>
/// <returns>A <see cref="BsonDocument"/>.</returns>
publicabstractBsonDocumentRender(RenderArgs<TDocument>args);

/// <summary>
/// Performs an implicit conversion from <see cref="BsonDocument"/> to <see cref="FilterDefinition{TDocument}"/>.
/// </summary>
/// <param name="document">The document.</param>
/// <returns>
/// The result of the conversion.
/// </returns>
publicstaticimplicitoperatorFilterDefinition<TDocument>(BsonDocumentdocument)
{
if(document==null)
{
returnnull;
}

returnnewBsonDocumentFilterDefinition<TDocument>(document);
}

/// <summary>
/// Performs an implicit conversion from a predicate expression to <see cref="FilterDefinition{TDocument}"/>.
/// </summary>
/// <param name="predicate">The predicate.</param>
/// <returns>
/// The result of the conversion.
/// </returns>
publicstaticimplicitoperatorFilterDefinition<TDocument>(Expression<Func<TDocument,bool>>predicate)
{
if(predicate==null)
{
returnnull;
}

returnnewExpressionFilterDefinition<TDocument>(predicate);
}

/// <summary>
/// Performs an implicit conversion from <see cref="System.String"/> to <see cref="FilterDefinition{TDocument}"/>.
/// </summary>
/// <param name="json">The JSON string.</param>
/// <returns>
/// The result of the conversion.
/// </returns>
publicstaticimplicitoperatorFilterDefinition<TDocument>(stringjson)
{
if(json==null)
{
returnnull;
}

returnnewJsonFilterDefinition<TDocument>(json);
}

/// <summary>
/// Implements the operator &amp;.
/// </summary>
/// <param name="lhs">The LHS.</param>
/// <param name="rhs">The RHS.</param>
/// <returns>
/// The result of the operator.
/// </returns>
publicstaticFilterDefinition<TDocument>operator&(FilterDefinition<TDocument>lhs,FilterDefinition<TDocument>rhs)
{
returnnewAndFilterDefinition<TDocument>(new[]{lhs,rhs});
}

/// <summary>
/// Implements the operator |.
/// </summary>
/// <param name="lhs">The LHS.</param>
/// <param name="rhs">The RHS.</param>
/// <returns>
/// The result of the operator.
/// </returns>
publicstaticFilterDefinition<TDocument>operator|(FilterDefinition<TDocument>lhs,FilterDefinition<TDocument>rhs)
{
returnnewOrFilterDefinition<TDocument>(new[]{lhs,rhs});
}

/// <summary>
/// Implements the operator !.
/// </summary>
/// <param name="op">The op.</param>
/// <returns>
/// The result of the operator.
/// </returns>
publicstaticFilterDefinition<TDocument>operator!(FilterDefinition<TDocument>op)
{
returnnewNotFilterDefinition<TDocument>(op);
}
}

/// <summary>
/// A <see cref="BsonDocument"/> based filter.
/// </summary>
/// <typeparam name="TDocument">The type of the document.</typeparam>
publicsealedclassBsonDocumentFilterDefinition<TDocument>:FilterDefinition<TDocument>
{
privatereadonlyBsonDocument_document;

/// <summary>
/// Initializes a new instance of the <see cref="BsonDocumentFilterDefinition{TDocument}"/> class.
/// </summary>
/// <param name="document">The document.</param>
publicBsonDocumentFilterDefinition(BsonDocumentdocument)
{
_document=Ensure.IsNotNull(document,nameof(document));
}

/// <summary>
/// Gets the document.
/// </summary>
publicBsonDocumentDocument
{
get{return_document;}
}

/// <inheritdoc />
publicoverrideBsonDocumentRender(RenderArgs<TDocument>args)
{
return_document;
}
}

internalsealedclassEmptyFilterDefinition<TDocument>:FilterDefinition<TDocument>
{
/// <inheritdoc />
publicoverrideBsonDocumentRender(RenderArgs<TDocument>args)
{
returnnewBsonDocument();
}
}

/// <summary>
/// An <see cref="Expression"/> based filter.
/// </summary>
/// <typeparam name="TDocument">The type of the document.</typeparam>
publicsealedclassExpressionFilterDefinition<TDocument>:FilterDefinition<TDocument>
{
privatereadonlyExpression<Func<TDocument,bool>>_expression;

/// <summary>
/// Initializes a new instance of the <see cref="ExpressionFilterDefinition{TDocument}"/> class.
/// </summary>
/// <param name="expression">The expression.</param>
publicExpressionFilterDefinition(Expression<Func<TDocument,bool>>expression)
{
_expression=Ensure.IsNotNull(expression,nameof(expression));
}

/// <summary>
/// Gets the expression.
/// </summary>
publicExpression<Func<TDocument,bool>>Expression
{
get{return_expression;}
}

/// <inheritdoc />
publicoverrideBsonDocumentRender(RenderArgs<TDocument>args)
{
if(args.RenderForElemMatch)
{
returnLinqProviderAdapter.TranslateExpressionToElemMatchFilter(_expression,elementSerializer:args.DocumentSerializer,args.SerializerRegistry,args.TranslationOptions);
}
else
{
returnLinqProviderAdapter.TranslateExpressionToFilter(_expression,args.DocumentSerializer,args.SerializerRegistry,args.TranslationOptions);
}
}
}

/// <summary>
/// A JSON <see cref="String" /> based filter.
/// </summary>
/// <typeparam name="TDocument">The type of the document.</typeparam>
publicsealedclassJsonFilterDefinition<TDocument>:FilterDefinition<TDocument>
{
privatereadonlystring_json;

/// <summary>
/// Initializes a new instance of the <see cref="JsonFilterDefinition{TDocument}" /> class.
/// </summary>
/// <param name="json">The json.</param>
publicJsonFilterDefinition(stringjson)
{
_json=Ensure.IsNotNullOrEmpty(json,nameof(json));
}

/// <summary>
/// Gets the json.
/// </summary>
publicstringJson
{
get{return_json;}
}

/// <inheritdoc />
publicoverrideBsonDocumentRender(RenderArgs<TDocument>args)
{
returnBsonDocument.Parse(_json);
}
}

/// <summary>
/// An <see cref="Object" /> based filter.
/// </summary>
/// <typeparam name="TDocument">The type of the document.</typeparam>
publicsealedclassObjectFilterDefinition<TDocument>:FilterDefinition<TDocument>
{
privatereadonlyobject_obj;

/// <summary>
/// Initializes a new instance of the <see cref="ObjectFilterDefinition{TDocument}"/> class.
/// </summary>
/// <param name="obj">The object.</param>
publicObjectFilterDefinition(objectobj)
{
_obj=Ensure.IsNotNull(obj,nameof(obj));
}

/// <summary>
/// Gets the object.
/// </summary>
publicobjectObject
{
get{return_obj;}
}

/// <inheritdoc />
publicoverrideBsonDocumentRender(RenderArgs<TDocument>args)
{
varserializer=args.SerializerRegistry.GetSerializer(_obj.GetType());
returnnewBsonDocumentWrapper(_obj,serializer);
}
}
}