org.bson.BsonInvalidOperationException Java Examples

protected static BsonDocument generateFilterDoc(BsonDocument keyDoc, BsonDocument valueDoc, OperationType opType) {
    if (keyDoc.keySet().isEmpty()) {
        if (opType.equals(OperationType.CREATE) || opType.equals(OperationType.READ)) {
            //create: no PK info in keyDoc -> generate ObjectId
            return new BsonDocument(DBCollection.ID_FIELD_NAME,new BsonObjectId());
        }
        //update or delete: no PK info in keyDoc -> take everything in 'before' field
        try {
            BsonDocument filter = valueDoc.getDocument(JSON_DOC_BEFORE_FIELD);
            if (filter.isEmpty())
                throw new BsonInvalidOperationException("value doc before field is empty");
            return filter;
        } catch(BsonInvalidOperationException exc) {
            throw new DataException("error: value doc 'before' field is empty or has invalid type" +
                    " for update/delete operation which seems severely wrong -> defensive actions taken!",exc);
        }
    }
    //build filter document composed of all PK columns
    BsonDocument pk = new BsonDocument();
    for (String f : keyDoc.keySet()) {
        pk.put(f,keyDoc.get(f));
    }
    return new BsonDocument(DBCollection.ID_FIELD_NAME,pk);
}
 

@Test public void
write_map_with_null_values_to_bson() {
    Map<String, Integer> mapToSerialise = new HashMap<>();
    mapToSerialise.put("foo", 42);
    mapToSerialise.put("bar", null);

    BsonDocument doc = (BsonDocument) BsonMapSerialiser
            .writingValuesWith(BsonSerialisers.toInteger)
            .apply(mapToSerialise);

    assertEquals("invalid foo", 42, doc.getInt32("foo").getValue());
    try {
        Integer value = doc.getInt32("bar").getValue();
        fail("bar should not have been written to the document");
    } catch (BsonInvalidOperationException e) {
        // expected
    }
}
 

Stream<Value> valuesFrom(BsonValue bsonValue) throws BsonInvalidOperationException {
    BsonDocument doc = bsonValue.asDocument();
    return deserialiserMap.values().stream()
            .map(d -> d.apply(doc))
            .filter(Optional::isPresent)
            .map(Optional::get);
}
 

void startArray() {
    if (!(value instanceof List)) {
        throw new BsonInvalidOperationException(Sofia.invalidBsonOperation(List.class, getCurrentBsonType()));
    }
    if (!(nextReaderState instanceof ListValueReaderState)) {
        processNextStages(new ListEndReaderState(reader), new ArrayIterator(reader, ((List) value).iterator()));
    }
}
 

void startDocument() {
    if (!(value instanceof Document)) {
        throw new BsonInvalidOperationException(Sofia.invalidBsonOperation(Document.class, getCurrentBsonType()));
    }
    if (!(nextReaderState instanceof DocumentStartReaderState)) {
        processNextStages(new DocumentEndReaderState(reader), new DocumentIterator(reader, ((Document) value).entrySet().iterator()));
        next(new DocumentStartReaderState(reader, ArrayIterator.empty())).advance();
    } else {
        advance();
    }
}
 

@Override
public PMap<String, T> applyUnsafe(BsonValue p) throws BsonInvalidOperationException {
    BsonDocument doc = p.asDocument();
    Map<String, T> values = new HashMap<>();
    for (Map.Entry<String,BsonValue> e : doc.entrySet()) {
        values.put(e.getKey(), valueDeserialiser.apply(e.getValue()));
    }

    return HashTreePMap.from(values);
}
 

static BsonDocument generateFilterDoc(
    final BsonDocument keyDoc, final BsonDocument valueDoc, final OperationType opType) {
  if (keyDoc.keySet().isEmpty()) {
    if (opType.equals(OperationType.CREATE) || opType.equals(OperationType.READ)) {
      // create: no PK info in keyDoc -> generate ObjectId
      return new BsonDocument(ID_FIELD, new BsonObjectId());
    }
    // update or delete: no PK info in keyDoc -> take everything in 'before' field
    try {
      BsonDocument filter = valueDoc.getDocument(JSON_DOC_BEFORE_FIELD);
      if (filter.isEmpty()) {
        throw new BsonInvalidOperationException("value doc before field is empty");
      }
      return filter;
    } catch (BsonInvalidOperationException exc) {
      throw new DataException(
          "Error: value doc 'before' field is empty or has invalid type"
              + " for update/delete operation which seems severely wrong -> defensive actions taken!",
          exc);
    }
  }
  // build filter document composed of all PK columns
  BsonDocument pk = new BsonDocument();
  for (String f : keyDoc.keySet()) {
    pk.put(f, keyDoc.get(f));
  }
  return new BsonDocument(ID_FIELD, pk);
}
 

default S apply(BsonValue p) {
    try {
        return applyUnsafe(p);
    } catch (BsonInvalidOperationException e) {
        throw new BsonDeserialisationException(e);
    }
}
 

@Override
public Validation<T> applyUnsafe(BsonValue p) throws BsonInvalidOperationException {
    try {
        return validated(reader.apply(p));
    } catch (RecordValidationException e) {
        return e.toValidation();
    }
}
 

@Override
public PrimitiveArray decode(BsonReader reader, DecoderContext decoderContext) {
    reader.readStartDocument();
    String key = reader.readString("key");

    List<Number> value = Lists.newArrayList();
    if (StringUtils.equals(key, PrimitiveArray.BYTE_ARRAY_ID)) {
        reader.readName("value");
        reader.readStartArray();
        while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) {
            value.add(byteCodec.decode(reader, decoderContext));
        }

        reader.readEndArray();
    } else if (StringUtils.equals(key, PrimitiveArray.INT_ARRAY_ID)) {
        reader.readName("value");
        reader.readStartArray();
        while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) {
            value.add(integerCodec.decode(reader, decoderContext));
        }

        reader.readEndArray();
    } else if (StringUtils.equals(key, PrimitiveArray.LONG_ARRAY_ID)) {
        reader.readName("value");
        reader.readStartArray();
        while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) {
            value.add(longCodec.decode(reader, decoderContext));
        }

        reader.readEndArray();
    } else {
        reader.readEndDocument();
        throw new BsonInvalidOperationException("Unsupported primitive type");
    }

    reader.readEndDocument();
    return new PrimitiveArray(key, value);
}
 

@Override
public URI decode(BsonReader reader, DecoderContext decoderContext) {
    String uriString = reader.readString();
    try {
        return new URI(uriString);
    } catch (URISyntaxException e) {
        throw new BsonInvalidOperationException(
                String.format("Cannot create URI from string '%s'", uriString));

    }
}
 

public BsonDeserialisationException(BsonInvalidOperationException e) {
    super(e);
}
 

@Override
public Record applyUnsafe(BsonValue bsonValue) throws BsonInvalidOperationException {
    return Record.of(valuesFrom(bsonValue));
}
 

@Override
public PVector<V> applyUnsafe(BsonValue p) throws BsonInvalidOperationException {
    BsonArray bsonArray = p.asArray();
    List<V> values = bsonArray.getValues().stream().map(v -> itemDeserialiser.apply(v)).collect(Collectors.toList());
    return TreePVector.from(values);
}
 

void endArray() {
    throw new BsonInvalidOperationException(Sofia.invalidBsonOperation(List.class, getCurrentBsonType()));
}
 

void endDocument() {
    throw new BsonInvalidOperationException(Sofia.invalidBsonOperation(Document.class, getCurrentBsonType()));
}
 

@Override
String name() {
    throw new BsonInvalidOperationException(Sofia.cannotReadName());
}
 

void end(final String message) {
    if (getIterator().hasNext()) {
        throw new BsonInvalidOperationException(message);
    }
    advance();
}
 

S applyUnsafe(BsonValue p) throws BsonInvalidOperationException;