// static methods
        public static BulkWriteBatchResult Create(
            bool isOrdered,
            IReadOnlyList<WriteRequest> requests,
            BsonDocument writeCommandResponse,
            IndexMap indexMap)
        {
            var writeErrors = CreateWriteErrors(writeCommandResponse);
            var writeConcernError = CreateWriteConcernError(writeCommandResponse);
            var processedRequests = CreateProcessedRequests(requests, writeErrors, isOrdered);
            var unprocessedRequests = CreateUnprocessedRequests(requests, writeErrors, isOrdered);
            var upserts = CreateUpserts(writeCommandResponse);

            var n = writeCommandResponse.GetValue("n", 0).ToInt64();
            var matchedCount = 0L;
            var deletedCount = 0L;
            var insertedCount = 0L;
            long? modifiedCount = 0L;
            var firstRequest = requests.FirstOrDefault();
            if (firstRequest != null)
            {
                switch (firstRequest.RequestType)
                {
                    case WriteRequestType.Delete:
                        deletedCount = n;
                        break;
                    case WriteRequestType.Insert:
                        insertedCount = n;
                        break;
                    case WriteRequestType.Update:
                        matchedCount = n - upserts.Count();
                        BsonValue nModified;
                        if (writeCommandResponse.TryGetValue("nModified", out nModified))
                        {
                            modifiedCount = nModified.ToInt64();
                        }
                        else
                        {
                            modifiedCount = null;
                        }
                        break;
                }
            }

            return new BulkWriteBatchResult(
                requests.Count,
                processedRequests,
                unprocessedRequests,
                matchedCount,
                deletedCount,
                insertedCount,
                modifiedCount,
                upserts,
                writeErrors,
                writeConcernError,
                indexMap);
        }
        public static BulkWriteBatchResult Create(
           BulkWriteOperationResult result,
           MongoBulkWriteOperationException exception,
           IndexMap indexMap)
        {
            var matchedCount = 0L;
            var deletedCount = 0L;
            var insertedCount = 0L;
            long? modifiedCount = null;
            var upserts = __noUpserts;
            if (result.IsAcknowledged)
            {
                matchedCount = result.MatchedCount;
                deletedCount = result.DeletedCount;
                insertedCount = result.InsertedCount;
                modifiedCount = result.IsModifiedCountAvailable ? (long?)result.ModifiedCount : null;
                upserts = result.Upserts;
            }

            var unprocessedRequests = __noWriteRequests;
            var writeErrors = __noWriteErrors;
            BulkWriteConcernError writeConcernError = null;
            if (exception != null)
            {
                unprocessedRequests = exception.UnprocessedRequests;
                writeErrors = exception.WriteErrors;
                writeConcernError = exception.WriteConcernError;
            }

            return new BulkWriteBatchResult(
                result.RequestCount,
                result.ProcessedRequests,
                unprocessedRequests,
                matchedCount,
                deletedCount,
                insertedCount,
                modifiedCount,
                upserts,
                writeErrors,
                writeConcernError,
                indexMap);
        }
 // constructors
 public BulkWriteBatchResult(
     int batchCount,
     IReadOnlyList<WriteRequest> processedRequests,
     IReadOnlyList<WriteRequest> unprocessedRequests,
     long matchedCount,
     long deletedCount,
     long insertedCount,
     long? modifiedCount,
     IReadOnlyList<BulkWriteOperationUpsert> upserts,
     IReadOnlyList<BulkWriteOperationError> writeErrors,
     BulkWriteConcernError writeConcernError,
     IndexMap indexMap)
 {
     _batchCount = batchCount;
     _matchedCount = matchedCount;
     _deletedCount = deletedCount;
     _insertedCount = insertedCount;
     _modifiedCount = modifiedCount;
     _indexMap = indexMap;
     _processedRequests = processedRequests;
     _writeErrors = writeErrors;
     _unprocessedRequests = unprocessedRequests;
     _upserts = upserts;
     _writeConcernError = writeConcernError;
 }
        public static BulkWriteBatchResult Create(
            WriteRequest request,
            WriteConcernResult writeConcernResult,
            MongoWriteConcernException writeConcernException,
            IndexMap indexMap)
        {
            var processedRequests = new[] { request };
            var unprocessedRequests = __noWriteRequests;
            BsonValue upsertId = null;
            var documentsAffected = 0L;

            if (writeConcernResult != null)
            {
                upsertId = writeConcernResult.Upserted;
                documentsAffected = writeConcernResult.DocumentsAffected;
                var updateRequest = request as UpdateRequest;

                if (upsertId == null &&
                    documentsAffected == 1 &&
                    updateRequest != null &&
                    updateRequest.IsUpsert &&
                    !writeConcernResult.UpdatedExisting)
                {
                    // Get the _id field first from the Update document
                    // and then from the Query document.
                    upsertId =
                        updateRequest.Update.ToBsonDocument().GetValue("_id", null) ??
                        updateRequest.Filter.ToBsonDocument().GetValue("_id", null);
                }
            }

            var upserts = (upsertId == null) ? __noUpserts : new[] { new BulkWriteOperationUpsert(0, upsertId) };
            var writeErrors = __noWriteErrors;
            BulkWriteConcernError writeConcernError = null;

            if (writeConcernException != null)
            {
                var getLastErrorResponse = writeConcernResult.Response;
                if (IsGetLasterrorResponseAWriteConcernError(getLastErrorResponse))
                {
                    writeConcernError = CreateWriteConcernErrorFromGetLastErrorResponse(getLastErrorResponse);
                }
                else
                {
                    writeErrors = new[] { CreateWriteErrorFromGetLastErrorResponse(getLastErrorResponse) };
                }
            }

            if (request.RequestType == WriteRequestType.Insert && writeErrors.Count == 0)
            {
                documentsAffected = 1; // note: DocumentsAffected is 0 for inserts
            }

            var matchedCount = 0L;
            var deletedCount = 0L;
            var insertedCount = 0L;
            long? modifiedCount = 0L;
            switch (request.RequestType)
            {
                case WriteRequestType.Delete:
                    deletedCount = documentsAffected;
                    break;
                case WriteRequestType.Insert:
                    insertedCount = documentsAffected;
                    break;
                case WriteRequestType.Update:
                    matchedCount = documentsAffected - upserts.Count();
                    modifiedCount = null; // getLasterror does not report this value
                    break;
            }

            return new BulkWriteBatchResult(
                1, // batchCount
                processedRequests,
                unprocessedRequests,
                matchedCount,
                deletedCount,
                insertedCount,
                modifiedCount,
                upserts,
                writeErrors,
                writeConcernError,
                indexMap);
        }
 // methods
 internal BulkWriteOperationUpsert WithMappedIndex(IndexMap indexMap)
 {
     var mappedIndex = indexMap.Map(_index);
     return (_index == mappedIndex) ? this : new BulkWriteOperationUpsert(mappedIndex, _id);
 }
 // methods
 internal BulkWriteError WithMappedIndex(IndexMap indexMap)
 {
     var mappedIndex = indexMap.Map(_index);
     return (_index == mappedIndex) ? this : new BulkWriteError(mappedIndex, Code, Message, Details);
 }