CSHARP-1409: added support for bitwise operators.

Author: craiggwilson

Docs/reference/content/reference/driver/expressions.md

@@ -29,6 +29,8 @@ class Person
 	public HashSet<string> FavoriteNames { get; set; }
 
 	public DateTime CreatedAtUtc { get; set; }
+
+	public int PermissionFlags { get; set; }
 }
 
 class Pet
@@ -139,6 +141,42 @@ Find(p => !localAges.Contains(p.Age));
 { Age: { $nin: [10, 20, 30] } }
 ```
 
+#### $bitsAllClear
+
+```csharp
+Find(p => (p.PermissionFlags & 7) == 0);
+```
+```json
+{ PermissionFlags: { $bitsAllClear: 7 } }
+```
+
+#### $bitsAllSet
+
+```csharp
+Find(p => (p.PermissionFlags & 7) == 7);
+```
+```json
+{ PermissionFlags: { $bitsAllSet: 7 } }
+```
+
+#### $bitsAnyClear
+
+```csharp
+Find(p => (p.PermissionFlags & 7) != 7);
+```
+```json
+{ PermissionFlags: { $bitsAnyClear: 7 } }
+```
+
+#### $bitsAnySet
+
+```csharp
+Find(p => (p.PermissionFlags & 7) != 0);
+```
+```json
+{ PermissionFlags: { $bitsAnySet: 7 } }
+```
+
 ### Logical
 
 See the [MongoDB documentation]({{< docsref "reference/operator/query/#logical" >}}) for more information on each operator.

src/MongoDB.Driver.Tests/FilterDefinitionBuilderTests.cs

@@ -127,6 +127,70 @@ public void And_with_a_nested_and_and_clashing_keys_using_ampersand()
             Assert(filter, "{$and: [{a: 1}, {a: 2}, {c: 3}]}");
         }
 
+        [Test]
+        public void BitsAllClear()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.BitsAllClear("a", 43), "{a: {$bitsAllClear: 43}}");
+        }
+
+        [Test]
+        public void BitsAllClear_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            Assert(subject.BitsAllClear(x => x.Age, 43), "{age: {$bitsAllClear: 43}}");
+        }
+
+        [Test]
+        public void BitsAllSet()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.BitsAllSet("a", 43), "{a: {$bitsAllSet: 43}}");
+        }
+
+        [Test]
+        public void BitsAllSet_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            Assert(subject.BitsAllSet(x => x.Age, 43), "{age: {$bitsAllSet: 43}}");
+        }
+
+        [Test]
+        public void BitsAnyClear()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.BitsAnyClear("a", 43), "{a: {$bitsAnyClear: 43}}");
+        }
+
+        [Test]
+        public void BitsAnyClear_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            Assert(subject.BitsAnyClear(x => x.Age, 43), "{age: {$bitsAnyClear: 43}}");
+        }
+
+        [Test]
+        public void BitsAnySet()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.BitsAnySet("a", 43), "{a: {$bitsAnySet: 43}}");
+        }
+
+        [Test]
+        public void BitsAnySet_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            Assert(subject.BitsAnySet(x => x.Age, 43), "{age: {$bitsAnySet: 43}}");
+        }
+
         [Test]
         public void ElemMatch()
         {

src/MongoDB.Driver.Tests/Linq/Translators/PredicateTranslatorTests.cs

@@ -165,6 +165,51 @@ public void Any_with_local_contains_on_a_scalar_array()
                 "{\"C.E.I\": { $in: [\"itchy\" ] } }");
         }
 
+        [Test]
+        public void BitsAllClear_with_bitwise_operators()
+        {
+            Assert(
+                x => (x.C.E.F & 20) == 0,
+                1,
+                "{'C.E.F': { $bitsAllClear: 20 } }");
+        }
+
+        [Test]
+        public void BitsAllSet_with_bitwise_operators()
+        {
+            Assert(
+                x => (x.C.E.F & 7) == 7,
+                1,
+                "{'C.E.F': { $bitsAllSet: 7 } }");
+        }
+
+        [Test]
+        public void BitsAllSet_with_HasFlag()
+        {
+            Assert(
+                x => x.Q.HasFlag(Q.One),
+                1,
+                "{Q: { $bitsAllSet: 1 } }");
+        }
+
+        [Test]
+        public void BitsAnyClear_with_bitwise_operators()
+        {
+            Assert(
+                x => (x.C.E.F & 7) != 7,
+                1,
+                "{'C.E.F': { $bitsAnyClear: 7 } }");
+        }
+
+        [Test]
+        public void BitsAnySet_with_bitwise_operators()
+        {
+            Assert(
+                x => (x.C.E.F & 20) != 0,
+                1,
+                "{'C.E.F': { $bitsAnySet: 20 } }");
+        }
+
         [Test]
         public void LocalIListContains()
         {

src/MongoDB.Driver/FilterDefinitionBuilder.cs

@@ -290,6 +290,94 @@ public FilterDefinition<TDocument> AnyNin<TItem>(Expression<Func<TDocument, IEnu
             return AnyNin(new ExpressionFieldDefinition<TDocument>(field), values);
         }
 
+        /// <summary>
+        /// Creates a bits all clear filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits all clear filter.</returns>
+        public FilterDefinition<TDocument> BitsAllClear(FieldDefinition<TDocument> field, long bitmask)
+        {
+            return new OperatorFilterDefinition<TDocument>("$bitsAllClear", field, bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits all clear filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits all clear filter.</returns>
+        public FilterDefinition<TDocument> BitsAllClear(Expression<Func<TDocument, object>> field, long bitmask)
+        {
+            return BitsAllClear(new ExpressionFieldDefinition<TDocument>(field), bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits all set filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits all set filter.</returns>
+        public FilterDefinition<TDocument> BitsAllSet(FieldDefinition<TDocument> field, long bitmask)
+        {
+            return new OperatorFilterDefinition<TDocument>("$bitsAllSet", field, bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits all set filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits all set filter.</returns>
+        public FilterDefinition<TDocument> BitsAllSet(Expression<Func<TDocument, object>> field, long bitmask)
+        {
+            return BitsAllSet(new ExpressionFieldDefinition<TDocument>(field), bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits any clear filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits any clear filter.</returns>
+        public FilterDefinition<TDocument> BitsAnyClear(FieldDefinition<TDocument> field, long bitmask)
+        {
+            return new OperatorFilterDefinition<TDocument>("$bitsAnyClear", field, bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits any clear filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits any clear filter.</returns>
+        public FilterDefinition<TDocument> BitsAnyClear(Expression<Func<TDocument, object>> field, long bitmask)
+        {
+            return BitsAnyClear(new ExpressionFieldDefinition<TDocument>(field), bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits any set filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits any set filter.</returns>
+        public FilterDefinition<TDocument> BitsAnySet(FieldDefinition<TDocument> field, long bitmask)
+        {
+            return new OperatorFilterDefinition<TDocument>("$bitsAnySet", field, bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits any set filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits any set filter.</returns>
+        public FilterDefinition<TDocument> BitsAnySet(Expression<Func<TDocument, object>> field, long bitmask)
+        {
+            return BitsAnySet(new ExpressionFieldDefinition<TDocument>(field), bitmask);
+        }
+
         /// <summary>
         /// Creates an element match filter for an array field.
         /// </summary>

src/MongoDB.Driver/Linq/Expressions/ISerializationExpression.cs

@@ -13,11 +13,13 @@
 * limitations under the License.
 */
 
+using System;
 using System.Collections;
 using MongoDB.Bson;
 using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Core.Misc;
+using MongoDB.Driver.Support;
 
 namespace MongoDB.Driver.Linq.Expressions
 {
@@ -44,6 +46,8 @@ public static BsonValue SerializeValue(this ISerializationExpression field, obje
         {
             Ensure.IsNotNull(field, nameof(field));
 
+            value = ConvertEnumIfNecessary(field.Serializer.ValueType, value);
+
             var tempDocument = new BsonDocument();
             using (var bsonWriter = new BsonDocumentWriter(tempDocument))
             {
@@ -67,7 +71,7 @@ public static BsonArray SerializeValues(this ISerializationExpression field, IEn
                 bsonWriter.WriteStartArray();
                 foreach (var value in values)
                 {
-                    field.Serializer.Serialize(context, value);
+                    field.Serializer.Serialize(context, ConvertEnumIfNecessary(field.Serializer.ValueType, value));
                 }
                 bsonWriter.WriteEndArray();
                 bsonWriter.WriteEndDocument();
@@ -89,5 +93,23 @@ private static string CombineFieldNames(string prefix, string suffix)
 
             return prefix + "." + suffix;
         }
+
+        private static object ConvertEnumIfNecessary(Type valueType, object value)
+        {
+            if (valueType.IsEnum || valueType.IsNullableEnum())
+            {
+                if (value != null)
+                {
+                    if (valueType.IsNullableEnum())
+                    {
+                        valueType = valueType.GetNullableUnderlyingType();
+                    }
+
+                    value = Enum.ToObject(valueType, value);
+                }
+            }
+
+            return value;
+        }
     }
 }