Java Code Examples for org.bson.codecs.configuration.CodecRegistry#get()

@SuppressWarnings("unchecked")
protected Codec<T> getCodecFromDocument(final BsonReader reader, final boolean useDiscriminator, final String discriminatorKey,
                                        final CodecRegistry registry, final DiscriminatorLookup discriminatorLookup,
                                        final Codec<T> defaultCodec) {
    Codec<T> codec = null;
    if (useDiscriminator) {
        BsonReaderMark mark = reader.getMark();
        try {
            reader.readStartDocument();
            while (codec == null && reader.readBsonType() != BsonType.END_OF_DOCUMENT) {
                if (discriminatorKey.equals(reader.readName())) {
                    codec = (Codec<T>) registry.get(discriminatorLookup.lookup(reader.readString()));
                } else {
                    reader.skipValue();
                }
            }
        } catch (Exception e) {
            throw new CodecConfigurationException(String.format("Failed to decode '%s'. Decoding errored with: %s",
                morphiaCodec.getEntityModel().getName(), e.getMessage()), e);
        } finally {
            mark.reset();
        }
    }
    return codec != null ? codec : defaultCodec;
}
 

public JacksonCodec(ObjectMapper bsonObjectMapper,
                    CodecRegistry codecRegistry,
                    Class<T> type) {
    this.bsonObjectMapper = bsonObjectMapper;
    this.rawBsonDocumentCodec = codecRegistry.get(RawBsonDocument.class);
    this.type = type;
}
 

public JacksonCodec(ObjectMapper bsonObjectMapper,
                    CodecRegistry codecRegistry,
                    Class<T> type) {
    this.bsonObjectMapper = bsonObjectMapper;
    this.rawBsonDocumentCodec = codecRegistry.get(RawBsonDocument.class);
    this.type = type;
}
 

/**
 * Gson Factory which gives preference to existing adapters from {@code gson} instance. However,
 * if type is not supported it will query {@link CodecRegistry} to create one (if possible).
 *
 * <p>This allows supporting Bson types by Gson natively (eg. for {@link org.bson.types.ObjectId}).
 *
 * @param registry existing registry which will be used if type is unknown to {@code gson}.
 * @return factory which delegates to {@code registry} for unknown types.
 */
public static TypeAdapterFactory delegatingTypeAdapterFactory(final CodecRegistry registry) {
  Preconditions.checkNotNull(registry, "registry");
  return new TypeAdapterFactory() {
    @Override
    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
      boolean hasAdapter;
      try {
        TypeAdapter<T> adapter = gson.getDelegateAdapter(this, type);
        hasAdapter = !isReflectiveTypeAdapter(adapter);
      } catch (IllegalArgumentException e) {
        hasAdapter = false;
      }

      if (hasAdapter) {
        return null;
      }

      try {
        @SuppressWarnings("unchecked")
        Codec<T> codec = (Codec<T>) registry.get(type.getRawType());
        return typeAdapterFromCodec(codec);
      } catch (CodecConfigurationException e1) {
        return null;
      }

    }
  };
}
 

public static Serializers serializers(final CodecRegistry registry) {
  return new Serializers.Base() {
    @Override
    public JsonSerializer<?> findSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc) {
      try {
        Codec<?> codec = registry.get(type.getRawClass());
        return serializer(codec);
      } catch (CodecConfigurationException e) {
        return null;
      }
    }
  };
}
 

private static <T> Codec<T> findCodecOrNull(CodecRegistry registry, Class<T> type) {
  try {
    return registry.get(type);
  } catch (CodecConfigurationException e) {
    return null;
  }
}
 

@Override
public <TDocument> BsonDocument toBsonDocument(final Class<TDocument> tDocumentClass, final CodecRegistry codecRegistry) {
    DocumentWriter writer = new DocumentWriter();

    MorphiaCodec codec = (MorphiaCodec) codecRegistry.get(entity.getClass());
    codec.encode(writer, entity, EncoderContext.builder().build());

    Document document = writer.getDocument();
    document.remove("_id");
    MappedField versionField = codec.getMappedClass().getVersionField();
    if (versionField != null) {
        document.remove(versionField.getMappedFieldName());
    }
    return document.toBsonDocument(Document.class, codecRegistry);
}
 

JacksonCodec(ObjectMapper mapper, Class<T> clazz, CodecRegistry registry) {
  this.mapper = mapper;
  this.clazz = clazz;
  this.codec = registry.get(RawBsonDocument.class);
}
 

public Stream(final EventStream eventStream,
              final Class<T> resultClass,
              final CodecRegistry codecRegistry) {
  this.eventStream = eventStream;
  this.decoder = codecRegistry.get(resultClass);
}
 

public static <T> Codec<T> getCodec(
    final CodecRegistry codecRegistry,
    final Class<T> documentClass
) {
  return codecRegistry.get(documentClass);
}
 

@Override
public <C> BsonDocument toBsonDocument(Class<C> documentClass, CodecRegistry codecRegistry) {
  return new BsonDocumentWrapper<>(obj, codecRegistry.get(JsonObject.class));
}