HandlerConverters

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

implicit final def fromDocumentHandler[T](h: BSONDocumentHandler[T]): OFormat[T]

Implicit conversion from new BSONDocumentHandler to Play JSON.

import reactivemongo.play.json.compat.HandlerConverters.fromDocumentHandler

def bar[T](bh: reactivemongo.api.bson.BSONDocumentHandler[T]) = {
  val h: play.api.libs.json.OFormat[T] = bh
  h
}

implicit final def fromDocumentWriter[T](implicit w: BSONDocumentWriter[T]): OWrites[T]

Resolves a OWrites provided a BSON document writer is found.

import play.api.libs.json.OWrites
import reactivemongo.play.json.compat.HandlerConverters

def bar[T: reactivemongo.api.bson.BSONDocumentWriter]: OWrites[T] =
  HandlerConverters.fromDocumentWriter[T]

implicit final def fromDocumentWriterConv[T](w: BSONDocumentWriter[T]): OWrites[T]

import reactivemongo.play.json.compat.fromDocumentWriterConv

def bar[T](lw: reactivemongo.api.bson.BSONDocumentWriter[T]) = {
  val w: play.api.libs.json.OWrites[T] = lw
  w
}

implicit final def fromHandler[T](h: BSONHandler[T]): Format[T]

implicit final def fromReader[T](implicit r: BSONReader[T]): Reads[T]

Provided there is a BSON reader, a JSON one is resolved.

import play.api.libs.json.Reads
import reactivemongo.api.bson.BSONReader
import reactivemongo.play.json.compat.fromReader

def foo[T: BSONReader]: Reads[T] = implicitly[Reads[T]]

implicit final def fromReaderConv[T](r: BSONReader[T]): Reads[T]

implicit final def fromWriter[T](implicit w: BSONWriter[T]): Writes[T]

Provided there is a BSON writer, resolves a JSON one.

import play.api.libs.json.Writes
import reactivemongo.api.bson.BSONWriter
import reactivemongo.play.json.compat.fromWriter

def foo[T: BSONWriter] = implicitly[Writes[T]] // resolve fromWriter

implicit final def fromWriterConv[T](w: BSONWriter[T]): Writes[T]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

implicit final def toDocumentHandler[T](h: OFormat[T]): BSONDocumentHandler[T]

Implicit conversion from Play JSON OFormat to the BSON API.

import reactivemongo.play.json.compat.HandlerConverters.toDocumentHandler

def foo[T](jh: play.api.libs.json.OFormat[T]) = {
  val h: reactivemongo.api.bson.BSONDocumentHandler[T] = jh
  h
}

final def toDocumentReaderConv[T](r: Reads[T]): BSONDocumentReader[T]

Raises a JsError is the JSON value is not a JsObject.

import reactivemongo.play.json.compat.toDocumentReaderConv

def lorem[T](jr: play.api.libs.json.Reads[T]) =
  toDocumentReaderConv(jr)

implicit final def toDocumentWriter[T](implicit w: OWrites[T]): BSONDocumentWriter[T]

Provided there is a Play JSON OWrites, resolve a document writer.

import play.api.libs.json.OWrites
import reactivemongo.api.bson.BSONDocumentWriter
import reactivemongo.play.json.compat.toDocumentWriter

def foo[T : OWrites]: BSONDocumentWriter[T] =
  implicitly[BSONDocumentWriter[T]]

implicit final def toDocumentWriterConv[T](w: OWrites[T]): BSONDocumentWriter[T]

import reactivemongo.play.json.compat.HandlerConverters.toDocumentWriterConv

def foo[T](jw: play.api.libs.json.OWrites[T]) = {
  val w: reactivemongo.api.bson.BSONDocumentWriter[T] = jw
  w
}

implicit final def toHandler[T](h: Format[T]): BSONHandler[T]

implicit final def toReader[T](implicit r: Reads[T]): BSONReader[T]

Provided there is a Play JSON Reads, resolve a BSON reader.

import play.api.libs.json.Reads
import reactivemongo.api.bson.BSONReader
import reactivemongo.play.json.compat.toReader

def foo[T: Reads]: BSONReader[T] = implicitly[BSONReader[T]]

implicit final def toReaderConv[T](r: Reads[T]): BSONReader[T]

Converts a Play JSON Reads to a BSON reader.

import play.api.libs.json.Reads
import reactivemongo.api.bson.BSONReader
import reactivemongo.play.json.compat.toReaderConv

def foo[T](implicit r: Reads[T]): BSONReader[T] = r

def toString(): String

implicit final def toWriter[T](w: Writes[T]): BSONWriter[T]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

implicit final val jsObjectWrites: OWrites[JsObject]