FFTHalfLogicImpl

abstract def inSize(nominal: Int): Int

abstract def outSize(nominal: Int): Int

abstract def performFFT(fft: DoubleFFT_1D, fftBuf: Array[Double]): Unit

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def abortEmitting(out: Outlet[_]): Unit

final def abortReading(in: Inlet[_]): Unit

def afterPostStop(): Unit

final def allocOutBuf0(): BufD

final def allocOutputBuffers(): Int

final def asInstanceOf[T0]: T0

def beforePreStart(): Unit

final var bufIn0: BufD

final var bufIn1: BufI

final var bufIn2: BufI

final var bufIn3: BufI

final var bufOut0: BufD

final def canRead: Boolean

Whether all inputs are available or have been closed and buffered.

final def canWrite: Boolean

Whether all outputs are available for pushing.

final def cancel[T](in: Inlet[T]): Unit

def clone(): AnyRef

final def complete[T](out: Outlet[T]): Unit

final def completeStage(): Unit

final def conditionalTerminateInput(predicate: () ⇒ Boolean): InHandler

final def conditionalTerminateOutput(predicate: () ⇒ Boolean): OutHandler

implicit final val control: Control

final def copyInputToWindow(inOff: Int, writeToWinOff: Long, chunk: Int): Unit

final def copyWindowToOutput(readFromWinOff: Long, outOff: Int, chunk: Int): Unit

final def createAsyncCallback[T](handler: Procedure[T]): AsyncCallback[T]

final def eagerTerminateInput: InHandler

final def eagerTerminateOutput: OutHandler

final def emit[T](out: Outlet[T], elem: T, andThen: Effect): Unit

final def emit[T](out: Outlet[T], elem: T): Unit

final def emit[T](out: Outlet[T], elem: T, andThen: () ⇒ Unit): Unit

final def emitMultiple[T](out: Outlet[T], elems: Iterator[T]): Unit

final def emitMultiple[T](out: Outlet[T], elems: Iterator[T], andThen: () ⇒ Unit): Unit

final def emitMultiple[T](out: Outlet[T], elems: Iterator[T], andThen: Effect): Unit

final def emitMultiple[T](out: Outlet[T], elems: Iterator[T]): Unit

final def emitMultiple[T](out: Outlet[T], elems: Iterable[T]): Unit

final def emitMultiple[T](out: Outlet[T], elems: Iterable[T], andThen: () ⇒ Unit): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def fail[T](out: Outlet[T], ex: Throwable): Unit

final def failAsync(ex: Exception): Unit

final def failStage(ex: Throwable): Unit

final var fft: DoubleFFT_1D

final var fftBuf: Array[Double]

final var fftSize: Int

def finalize(): Unit

final def freeInputBuffers(): Unit

final def freeOutputBuffers(): Unit

final def getAsyncCallback[T](handler: (T) ⇒ Unit): AsyncCallback[T]

final def getClass(): Class[_]

final def getHandler(out: Outlet[_]): OutHandler

final def getHandler(in: Inlet[_]): InHandler

final def getStageActor(receive: ((ActorRef, Any)) ⇒ Unit): StageActor

final def grab[T](in: Inlet[T]): T

final def hasBeenPulled[T](in: Inlet[T]): Boolean

def hashCode(): Int

final def ignoreTerminateInput: InHandler

final def ignoreTerminateOutput: OutHandler

final def in0: Inlet[BufD]

final def in1: Inlet[BufI]

final def in2: Inlet[BufI]

final def in3: Inlet[BufI]

val inCount: Int

final var inOff: Int

final var inRemain: Int

final def inValid: Boolean

Whether all input buffers are valid.

final def inputsEnded: Boolean

final def isAvailable[T](out: Outlet[T]): Boolean

final def isAvailable[T](in: Inlet[T]): Boolean

final def isClosed[T](out: Outlet[T]): Boolean

final def isClosed[T](in: Inlet[T]): Boolean

final def isInAvailable[A](in: Inlet[A]): Boolean

Exposed from protected GraphStageLogic API.

final def isInstanceOf[T0]: Boolean

final def isOutAvailable[A](out: Outlet[A]): Boolean

Exposed from protected GraphStageLogic API.

def materializer: Materializer

final var mode: Int

final val name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def out0: Outlet[BufD]

val outCount: Int

final var outOff: Int

final var outRemain: Int

final def passAlong[Out, In <: Out](from: Inlet[In], to: Outlet[Out], doFinish: Boolean, doFail: Boolean, doPull: Boolean): Unit

final def postStop(): Unit

Calls stopped and then removes the node from the control.

def preStart(): Unit

final def process(): Unit

final def processChunk(): Boolean

Should read and possibly update inRemain, outRemain, inOff, outOff.

final def processWindow(writeToWinOff: Long): Long

final def pull[T](in: Inlet[T]): Unit

final def push[T](out: Outlet[T], elem: T): Unit

final def read[T](in: Inlet[T], andThen: Procedure[T], onClose: Effect): Unit

final def read[T](in: Inlet[T])(andThen: (T) ⇒ Unit, onClose: () ⇒ Unit): Unit

final def readIns(): Int

final def readN[T](in: Inlet[T], n: Int, andThen: Procedure[List[T]], onClose: Procedure[List[T]]): Unit

final def readN[T](in: Inlet[T], n: Int)(andThen: (Seq[T]) ⇒ Unit, onClose: (Seq[T]) ⇒ Unit): Unit

final def setHandler(out: Outlet[_], handler: OutHandler): Unit

final def setHandler(in: Inlet[_], handler: InHandler): Unit

final def setHandlers(in: Inlet[_], out: Outlet[_], handler: InHandler with OutHandler): Unit

final def setInHandler[A](in: Inlet[A], h: InHandler): Unit

Exposed from protected GraphStageLogic API.

final def setKeepGoing(enabled: Boolean): Unit

final def setOutHandler[A](out: Outlet[A], h: OutHandler): Unit

Exposed from protected GraphStageLogic API.

final val shape: FanInShape4[BufD, BufI, BufI, BufI, BufD]

final def shouldComplete(): Boolean

final def stageActor: StageActor

final def startNextWindow(inOff: Int): Long

Notifies about the start of the next window.

def stopped(): Unit

def subFusingMaterializer: Materializer

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

def toString(): String

final def totallyIgnorantInput: InHandler

final def tryPull[T](in: Inlet[T]): Unit

final def updateCanRead(): Unit

Requests the update of the canRead status.

final def updateCanWrite(): Unit

Requests the update of the canWrite status.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def writeOuts(outOff: Int): Unit