CollectionMetaCommands

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (CollectionMetaCommands, B)

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def convertToCapped(size: Long, maxDocuments: Option[Int])(implicit ec: ExecutionContext): Future[Unit]

Converts this collection to a capped one.

import scala.concurrent.{ ExecutionContext, Future }

def capColl(coll: reactivemongo.api.bson.collection.BSONCollection)(
  implicit ec: ExecutionContext): Future[Unit] =
  coll.convertToCapped(size = 10L, maxDocuments = Some(100))

def create(failsIfExists: Boolean = false)(implicit ec: ExecutionContext): Future[Unit]

Creates this collection.

import scala.concurrent.{ ExecutionContext, Future }
import reactivemongo.api.CollectionMetaCommands

def createIfNotExists(coll: CollectionMetaCommands)(
  implicit ec: ExecutionContext): Future[Unit] =
  coll.create(failsIfExists = true)

def create()(implicit ec: ExecutionContext): Future[Unit]

Creates this collection.

import scala.concurrent.ExecutionContext

import reactivemongo.api.CollectionMetaCommands
import reactivemongo.api.commands.CommandError

def createColl(
  coll: CollectionMetaCommands)(implicit ec: ExecutionContext) =
  coll.create().recover {
    case CommandError.Code(48) => // NamespaceExists
      println(s"Collection \${coll} already exists")
  }

def createCapped(size: Long, maxDocuments: Option[Int], autoIndexId: Boolean = false)(implicit ec: ExecutionContext): Future[Unit]

Creates this collection as a capped one.

import scala.concurrent.{ ExecutionContext, Future }

def capped(coll: reactivemongo.api.bson.collection.BSONCollection)(
  implicit ec: ExecutionContext): Future[Unit] =
  coll.createCapped(size = 10, maxDocuments = Some(100))

def drop(failIfNotFound: Boolean)(implicit ec: ExecutionContext): Future[Boolean]

Drops this collection.

import scala.concurrent.{ ExecutionContext, Future }
import reactivemongo.api.CollectionMetaCommands

def dropIfNotFound(coll: CollectionMetaCommands)(
  implicit ec: ExecutionContext): Future[Boolean] =
  coll.drop(failIfNotFound = true)

def ensuring(cond: (CollectionMetaCommands) ⇒ Boolean, msg: ⇒ Any): CollectionMetaCommands

def ensuring(cond: (CollectionMetaCommands) ⇒ Boolean): CollectionMetaCommands

def ensuring(cond: Boolean, msg: ⇒ Any): CollectionMetaCommands

def ensuring(cond: Boolean): CollectionMetaCommands

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

def indexesManager(implicit ec: ExecutionContext): Aux[Pack]

Returns an index manager for this collection.

import scala.concurrent.{ ExecutionContext, Future }
import reactivemongo.api.CollectionMetaCommands

def listIndexes(coll: CollectionMetaCommands)(
  implicit ec: ExecutionContext): Future[List[String]] =
  coll.indexesManager.list().map(_.flatMap { idx =>
    idx.name.toList
  })

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def stats(scale: Int)(implicit ec: ExecutionContext): Future[CollStatsResult]

Returns various information about this collection.

import scala.concurrent.{ ExecutionContext, Future }

def getSize(coll: reactivemongo.api.bson.collection.BSONCollection)(
  implicit ec: ExecutionContext): Future[Double] =
  coll.stats(scale = 1024).map(_.size)

def stats()(implicit ec: ExecutionContext): Future[CollStatsResult]

Returns various information about this collection.

import scala.concurrent.{ ExecutionContext, Future }

def isCapped(coll: reactivemongo.api.bson.collection.BSONCollection)(
  implicit ec: ExecutionContext): Future[Boolean] =
  coll.stats().map(_.capped)

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (CollectionMetaCommands, B)

def drop()(implicit ec: ExecutionContext): Future[Unit]

Drops this collection.

def rename(to: String, dropExisting: Boolean = false)(implicit ec: ExecutionContext): Future[Unit]

Renames this collection.