AutomanAdapter

abstract def CBDQFactory(): CBDQ

abstract def CBQFactory(): CBQ

abstract def EQFactory(): EQ

abstract def FTDQFactory(): FTDQ

abstract def FTQFactory(): FTQ

abstract def MEQFactory(): MEQ

abstract def MemoDBFactory(): MemoDB

abstract def Option(id: Symbol, text: String): QuestionOption

abstract def RBDQFactory(): RBDQ

abstract def RBQFactory(): RBQ

abstract def accept(ts: List[Task]): Option[List[Task]]

Tell the backend to accept the answer associated with this ANSWERED task.

abstract def backend_budget(): Option[BigDecimal]

Get the budget from the backend.

abstract def cancel(ts: List[Task], toState: scheduler.SchedulerState.Value): Option[List[Task]]

Cancel the given tasks.

abstract def post(ts: List[Task], exclude_worker_ids: List[String]): Option[List[Task]]

Post tasks on the backend, one task for each task.

abstract def reject(ts_reasons: List[(Task, String)]): Option[List[Task]]

Tell the backend to reject the answer associated with this ANSWERED task.

abstract def retrieve(ts: List[Task], current_time: Date): Option[List[Task]]

Ask the backend to retrieve answers given a list of RUNNING tasks.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def CheckboxDistributionQuestion(init: (CBDQ) ⇒ Unit): CBDQ.O

def CheckboxQuestion(init: (CBQ) ⇒ Unit): CBQ.O

def EstimationQuestion(init: (EQ) ⇒ Unit): EQ.O

def FreeTextDistributionQuestion(init: (FTDQ) ⇒ Unit): FTDQ.O

def FreeTextQuestion(init: (FTQ) ⇒ Unit): FTQ.O

def MultiEstimationQuestion(init: (MEQ) ⇒ Unit): MEQ.O

def RadioButtonDistributionQuestion(init: (RBDQ) ⇒ Unit): RBDQ.O

def RadioButtonQuestion(init: (RBQ) ⇒ Unit): RBQ.O

var _database_path: String

var _default_confidence: Double

var _in_mem_db: Boolean

var _locale: Locale

var _log_config: LogConfig

var _memoizer: MemoDB

var _plugins: List[Class[_ <: Plugin]]

var _plugins_initialized: List[_ <: Plugin]

var _ref_cache: Map[String, List[Outcome[_]]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def close(): Unit

def database_path: String

def database_path_=(path: String): Unit

def default_confidence: Double

def default_confidence_=(c: Double): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def in_memory_db: Boolean

def in_memory_db_=(use_memdb: Boolean): Unit

def init(): Unit

final def isInstanceOf[T0]: Boolean

def log_verbosity: LogLevel

def log_verbosity_=(v: LogLevel): Unit

def logging: LogConfig

def logging_=(lc: logging.LogConfig.Value): Unit

def memo_delete(): Unit

def memo_init(): Unit

def memo_restore(q: Question): List[Task]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def plugins: List[Class[_ <: Plugin]]

def plugins_=(ps: List[Class[_ <: Plugin]]): Unit

def plugins_init(): Unit

def plugins_memo_register(): Unit

def plugins_shutdown(): Unit

def question_shutdown_hook(q: Question): Unit

This method is called by the scheduler after an answer has been accepted by the scheduler policy.

def question_startup_hook(q: Question, t: Date): Unit

This method is called by the scheduler after question initialization but before any tasks are scheduled.

def schedule[Q <: Question](q: Q, init: (Q) ⇒ Unit): schedule.Q.O

def state_snapshot(): List[TaskSnapshot[_]]

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