public BaseSettings(ClassIntrospector ci, AnnotationIntrospector ai,
        PropertyNamingStrategy pns, TypeFactory tf,
        TypeResolverBuilder<?> typer, DateFormat dateFormat, HandlerInstantiator hi,
        Locale locale, TimeZone tz, Base64Variant defaultBase64)
{
    _classIntrospector = ci;
    _annotationIntrospector = ai;
    _propertyNamingStrategy = pns;
    _typeFactory = tf;
    _typeResolverBuilder = typer;
    _dateFormat = dateFormat;
    _handlerInstantiator = hi;
    _locale = locale;
    _timeZone = tz;
    _defaultBase64 = defaultBase64;
}
 

/**
 * @since 2.1
 */
public BaseSettings with(Base64Variant base64) {
    if (base64 == _defaultBase64) {
        return this;
    }
    return new BaseSettings(_classIntrospector, _annotationIntrospector,
            _propertyNamingStrategy, _typeFactory,
            _typeResolverBuilder, _dateFormat, _handlerInstantiator, _locale,
            _timeZone, base64);
}
 

@Override
public byte[] getBinaryValue(Base64Variant b64variant) throws IOException
{
  if (_tokenIncomplete) {
    _finishToken();
  }
  if (_currToken != JsonToken.VALUE_EMBEDDED_OBJECT ) {
    // TODO, maybe: support base64 for text?
    _reportError("Current token ("+_currToken+") not VALUE_EMBEDDED_OBJECT, can not access as binary");
  }
  return _binaryValue;
}
 

@Override
public int readBinaryValue(Base64Variant b64variant, OutputStream out) throws IOException
{
  if (_currToken != JsonToken.VALUE_EMBEDDED_OBJECT ) {
    _reportError("Current token ("+_currToken+") not VALUE_EMBEDDED_OBJECT, can not access as binary");
  }

  // !!! TBI
  return -1;
}
 

@Override
public void writeBinary(Base64Variant bv,
    byte[] data, int offset, int len) throws IOException {
  ByteBuffer buff = ByteBuffer.wrap(data, offset, len);
  if (inMap()) {
    b.put(currFieldName, buff);
  } else {
    b.add(buff);
  }
}
 

@Override
public byte[] getBinaryValue(Base64Variant bv) throws IOException {
  ByteBuffer buf = r.getBinary();
  byte[] result = new byte[buf.remaining()];
  buf.get(result);
  return result;
}
 

@Override
public byte[] getBinaryValue(Base64Variant b64variant) throws IOException, JsonParseException {
	Object obj = getEmbeddedObject();
	if (obj instanceof byte[]) {
		return (byte[])obj;
	} else {
		return getText().getBytes();
	}
}
 

@Override
public int writeBinary(Base64Variant b64variant, InputStream data, int dataLength) throws IOException {
  if (itemFilter != null) {
    return delegate.writeBinary(b64variant, data, dataLength);
  } else {
    return -1;
  }
}
 

@Override
public byte[] getBinaryValue(Base64Variant variant) throws IOException {
  if (type() != BsonType.BINARY) {
    throw new JsonParseException(this, String.format("Can't read binary data. Expected type %s got %s", BsonType.BINARY, type()));
  }

  if (!context.hasValue()) {
    readValue();
  }

  return (byte[]) context.value;
}
 

@Override
public byte[] getBinaryValue(Base64Variant b64variant)
    throws IOException, JsonParseException
{
    // otherwise return null to mark we have no binary content
    return null;
}
 

@Override
public int readBinaryValue(Base64Variant b64variant, OutputStream out)
        throws IOException, JsonParseException
{
    byte[] data = getBinaryValue(b64variant);
    if (data != null) {
        out.write(data, 0, data.length);
        return data.length;
    }
    return 0;
}
 

public Base64Variant getBase64Variant() {
    return _defaultBase64;
}
 

@Override
public byte[] getBinaryValue(Base64Variant bv) {
    throw new UnsupportedOperationException();
}
 

@Override
public byte[] getBinaryValue(Base64Variant bv) throws IOException {
    throw new UnsupportedOperationException();
}
 

@Override
public byte[] getBinaryValue(final Base64Variant bv) throws IOException {
  return jsonParser.getBinaryValue(bv);
}
 

@Override
public int readBinaryValue(final Base64Variant bv, final OutputStream out) throws IOException {
  return jsonParser.readBinaryValue(bv, out);
}
 

@Override
public int writeBinary(Base64Variant bv,
    InputStream data, int dataLength) throws IOException {
  notImplemented();
  return 0;
}
 

@Override
public void writeBinary(Base64Variant b64variant, byte[] data, int offset, int len) throws IOException, JsonGenerationException {
    addValueToStackTop(ByteBuffer.wrap(data, offset, len));
}
 

@Override
public void writeBinary(Base64Variant b64variant, byte[] data, int offset, int len) throws IOException {
  if (itemFilter != null) {
    delegate.writeBinary(b64variant, data, offset, len);
  }
}
 

@Override
public byte[] getBinaryValue(final Base64Variant b64variant) throws IOException {
    return b64variant.decode(_textBuffer.contentsAsString());
}
 

@Override
public void writeBinary(Base64Variant bv, byte[] data, int offset, int len) throws IOException {
  throw new UnsupportedOperationException();
}
 

@Override
public void writeBinary(Base64Variant bv, byte[] data, int offset, int len) throws IOException {
  BsonBinary binary = new BsonBinary(Arrays.copyOfRange(data, offset, offset + len));
  writer.writeBinaryData(binary);
}
 

/**
 * Method called during deserialization if Base64 encoded content
 * needs to be decoded. Default version just returns default Jackson
 * uses, which is modified-mime which does not add linefeeds (because
 * those would have to be escaped in JSON strings); but this can
 * be configured on {@link ObjectWriter}.
 */
public Base64Variant getBase64Variant() {
    return _base.getBase64Variant();
}
 

/**
 * Method for constructing and returning a new instance with different
 * default {@link Base64Variant} to use with base64-encoded binary values.
 */
public final T with(Base64Variant base64) {
    return _withBase(_base.with(base64));
}