Utils

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def JSONEscapeString(s: String): String
def abs(n: Int): Int

Get the absolute value of the given number.
Get the absolute value of the given number. If the number is Int.MinValue return 0. This is different from java.lang.Math.abs or scala.math.abs in that they return Int.MinValue (!).
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asString(props: Properties): String

Turn a properties map into a string
def circularIterator[T](coll: Iterable[T]): Iterator[T]

Create a circular (looping) iterator over a collection.
Create a circular (looping) iterator over a collection.
coll
An iterable over the underlying collection.
returns
A circular iterator over the collection.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def crc32(bytes: Array[Byte], offset: Int, size: Int): Long

Compute the CRC32 of the segment of the byte array given by the specificed size and offset
Compute the CRC32 of the segment of the byte array given by the specificed size and offset
bytes
The bytes to checksum
offset
the offset at which to begin checksumming
size
the number of bytes to checksum
returns
The CRC32
def crc32(bytes: Array[Byte]): Long

Compute the CRC32 of the byte array
Compute the CRC32 of the byte array
bytes
The array to compute the checksum for
returns
The CRC32
def createFile(path: String): File

Create a file with the given path
Create a file with the given path
path
The path to create
returns
The created file

Exceptions thrown
KafkaStorageException
If the file create fails
def createObject[T <: AnyRef](className: String, args: AnyRef*): T

Create an instance of the class with the given class name
def croak(message: String): Unit

Print an error message and shutdown the JVM
Print an error message and shutdown the JVM
message
The error message
def daemonThread(name: String, fun: () ⇒ Unit): Thread

Create a daemon thread
Create a daemon thread
name
The name of the thread
fun
The runction to execute in the thread
returns
The unstarted thread
def daemonThread(name: String, runnable: Runnable): Thread

Create a daemon thread
Create a daemon thread
name
The name of the thread
runnable
The runnable to execute in the background
returns
The unstarted thread
def daemonThread(runnable: Runnable): Thread

Create a daemon thread
Create a daemon thread
runnable
The runnable to execute in the background
returns
The unstarted thread
def debug(msg: ⇒ String, e: ⇒ Throwable): Unit

Definition Classes
Logging
def debug(e: ⇒ Throwable): Any

Definition Classes
Logging
def debug(msg: ⇒ String): Unit

Definition Classes
Logging
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equal(b1: ByteBuffer, b2: ByteBuffer): Boolean

Test if two byte buffers are equal.
Test if two byte buffers are equal. In this case equality means having the same bytes from the current position to the limit
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def error(msg: ⇒ String, e: ⇒ Throwable): Unit

Definition Classes
Logging
def error(e: ⇒ Throwable): Any

Definition Classes
Logging
def error(msg: ⇒ String): Unit

Definition Classes
Logging
def fatal(msg: ⇒ String, e: ⇒ Throwable): Unit

Definition Classes
Logging
def fatal(e: ⇒ Throwable): Any

Definition Classes
Logging
def fatal(msg: ⇒ String): Unit

Definition Classes
Logging
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def groupby[K, V](vals: Iterable[V], f: (V) ⇒ K): Map[K, List[V]]

Group the given values by keys extracted with the given function
def hashCode(): Int

Definition Classes
AnyRef → Any
def hashcode(as: Any*): Int

Compute the hash code for the given items
def inLock[T](lock: Lock)(fun: ⇒ T): T

Execute the given function inside the lock
def inReadLock[T](lock: ReadWriteLock)(fun: ⇒ T): T
def inWriteLock[T](lock: ReadWriteLock)(fun: ⇒ T): T
def info(msg: ⇒ String, e: ⇒ Throwable): Unit

Definition Classes
Logging
def info(e: ⇒ Throwable): Any

Definition Classes
Logging
def info(msg: ⇒ String): Unit

Definition Classes
Logging
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def loadProps(filename: String): Properties

Read a properties file from the given path
Read a properties file from the given path
filename
The path of the file to read
var logIdent: String

Attributes
protected
Definition Classes
Logging
lazy val logger: Logger

Definition Classes
Logging
val loggerName: String

Definition Classes
Logging
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newThread(runnable: Runnable, daemon: Boolean): Thread

Create a new thread
Create a new thread
runnable
The work for the thread to do
daemon
Should the thread block JVM shutdown?
returns
The unstarted thread
def newThread(name: String, runnable: Runnable, daemon: Boolean): Thread

Create a new thread
Create a new thread
name
The name of the thread
runnable
The work for the thread to do
daemon
Should the thread block JVM shutdown?
returns
The unstarted thread
def notNull[V](v: V): V

Throw an exception if the given value is null, else return it.
Throw an exception if the given value is null, else return it. You can use this like: val myValue = Utils.notNull(expressionThatShouldntBeNull)
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def nullOrEmpty(s: String): Boolean

Is the given string null or empty ("")?
def openChannel(file: File, mutable: Boolean): FileChannel

Open a channel for the given file
def parseCsvList(csvList: String): Seq[String]

Parse a comma separated string into a sequence of strings.
Parse a comma separated string into a sequence of strings. Whitespace surrounding the comma will be removed.
def parseCsvMap(str: String): Map[String, String]

This method gets comma separated values which contains key,value pairs and returns a map of key value pairs.
This method gets comma separated values which contains key,value pairs and returns a map of key value pairs. the format of allCSVal is key1:val1, key2:val2 ....
def read(channel: ReadableByteChannel, buffer: ByteBuffer): Int

Read some bytes into the provided buffer, and return the number of bytes read.
Read some bytes into the provided buffer, and return the number of bytes read. If the channel has been closed or we get -1 on the read for any reason, throw an EOFException
def readBytes(buffer: ByteBuffer, offset: Int, size: Int): Array[Byte]

Read a byte array from the given offset and size in the buffer
def readBytes(buffer: ByteBuffer): Array[Byte]

Read the given byte buffer into a byte array
def readFileAsString(path: String, charset: Charset = Charset.defaultCharset()): String

Attempt to read a file as a string
def readInt(bytes: Array[Byte], offset: Int): Int

Read a big-endian integer from a byte array
def readProps(s: String, defaults: Properties): Properties

Read some properties with the given default values
def readString(buffer: ByteBuffer, encoding: String = Charset.defaultCharset.toString): String

Translate the given buffer into a string
Translate the given buffer into a string
buffer
The buffer to translate
encoding
The encoding to use in translating bytes to characters
def readUnsignedInt(buffer: ByteBuffer, index: Int): Long

Read an unsigned integer from the given position without modifying the buffers position
Read an unsigned integer from the given position without modifying the buffers position
buffer
the buffer to read from
index
the index from which to read the integer
returns
The integer read, as a long to avoid signedness
def readUnsignedInt(buffer: ByteBuffer): Long

Read an unsigned integer from the current position in the buffer, incrementing the position by 4 bytes
Read an unsigned integer from the current position in the buffer, incrementing the position by 4 bytes
buffer
The buffer to read from
returns
The integer read, as a long to avoid signedness
def registerMBean(mbean: AnyRef, name: String): Boolean

Register the given mbean with the platform mbean server, unregistering any mbean that was there before.
Register the given mbean with the platform mbean server, unregistering any mbean that was there before. Note, this method will not throw an exception if the registration fails (since there is nothing you can do and it isn't fatal), instead it just returns false indicating the registration failed.
mbean
The object to register as an mbean
name
The name to register this mbean with
returns
true if the registration succeeded
def replaceSuffix(s: String, oldSuffix: String, newSuffix: String): String

Replace the given string suffix with the new suffix.
Replace the given string suffix with the new suffix. If the string doesn't end with the given suffix throw an exception.
def rm(file: File): Unit

Recursively delete the given file/directory and any subfiles (if any exist)
Recursively delete the given file/directory and any subfiles (if any exist)
file
The root file at which to begin deleting
def rm(files: Seq[String]): Unit

Recursively delete the list of files/directories and any subfiles (if any exist)
def rm(file: String): Unit

Recursively delete the given file/directory and any subfiles (if any exist)
Recursively delete the given file/directory and any subfiles (if any exist)
file
The root file at which to begin deleting
def runnable(fun: ⇒ Unit): Runnable

Wrap the given function in a java.
Wrap the given function in a java.lang.Runnable
fun
A function
returns
A Runnable that just executes the function
def stackTrace(e: Throwable): String

Get the stack trace from an exception as a string
def swallow(log: (AnyRef, Throwable) ⇒ Unit, action: ⇒ Unit): Unit

Do the given action and log any exceptions thrown without rethrowing them
Do the given action and log any exceptions thrown without rethrowing them
log
The log method to use for logging. E.g. logger.warn
action
The action to execute
def swallow(action: ⇒ Unit): Unit

Definition Classes
Logging
def swallowDebug(action: ⇒ Unit): Unit

Definition Classes
Logging
def swallowError(action: ⇒ Unit): Unit

Definition Classes
Logging
def swallowInfo(action: ⇒ Unit): Unit

Definition Classes
Logging
def swallowTrace(action: ⇒ Unit): Unit

Definition Classes
Logging
def swallowWarn(action: ⇒ Unit): Unit

Definition Classes
Logging
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def trace(msg: ⇒ String, e: ⇒ Throwable): Unit

Definition Classes
Logging
def trace(e: ⇒ Throwable): Any

Definition Classes
Logging
def trace(msg: ⇒ String): Unit

Definition Classes
Logging
def unregisterMBean(name: String): Unit

Unregister the mbean with the given name, if there is one registered
Unregister the mbean with the given name, if there is one registered
name
The mbean name to unregister
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def warn(msg: ⇒ String, e: ⇒ Throwable): Unit

Definition Classes
Logging
def warn(e: ⇒ Throwable): Any

Definition Classes
Logging
def warn(msg: ⇒ String): Unit

Definition Classes
Logging
def writeUnsignedInt(buffer: ByteBuffer, index: Int, value: Long): Unit

Write the given long value as a 4 byte unsigned integer.
Write the given long value as a 4 byte unsigned integer. Overflow is ignored.
buffer
The buffer to write to
index
The position in the buffer at which to begin writing
value
The value to write
def writetUnsignedInt(buffer: ByteBuffer, value: Long): Unit

Write the given long value as a 4 byte unsigned integer.
Write the given long value as a 4 byte unsigned integer. Overflow is ignored.
buffer
The buffer to write to
value
The value to write

object Utils extends Logging

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def JSONEscapeString(s: String): String

def abs(n: Int): Int

final def asInstanceOf[T0]: T0

def asString(props: Properties): String

def circularIterator[T](coll: Iterable[T]): Iterator[T]

def clone(): AnyRef

def crc32(bytes: Array[Byte], offset: Int, size: Int): Long

def crc32(bytes: Array[Byte]): Long

def createFile(path: String): File

def createObject[T <: AnyRef](className: String, args: AnyRef*): T

def croak(message: String): Unit

def daemonThread(name: String, fun: () ⇒ Unit): Thread

def daemonThread(name: String, runnable: Runnable): Thread

def daemonThread(runnable: Runnable): Thread

def debug(msg: ⇒ String, e: ⇒ Throwable): Unit

def debug(e: ⇒ Throwable): Any

def debug(msg: ⇒ String): Unit

final def eq(arg0: AnyRef): Boolean

def equal(b1: ByteBuffer, b2: ByteBuffer): Boolean

def equals(arg0: Any): Boolean

def error(msg: ⇒ String, e: ⇒ Throwable): Unit

def error(e: ⇒ Throwable): Any

def error(msg: ⇒ String): Unit

def fatal(msg: ⇒ String, e: ⇒ Throwable): Unit

def fatal(e: ⇒ Throwable): Any

def fatal(msg: ⇒ String): Unit

def finalize(): Unit

final def getClass(): Class[_]

def groupby[K, V](vals: Iterable[V], f: (V) ⇒ K): Map[K, List[V]]

def hashCode(): Int

def hashcode(as: Any*): Int

def inLock[T](lock: Lock)(fun: ⇒ T): T

def inReadLock[T](lock: ReadWriteLock)(fun: ⇒ T): T

def inWriteLock[T](lock: ReadWriteLock)(fun: ⇒ T): T

def info(msg: ⇒ String, e: ⇒ Throwable): Unit

def info(e: ⇒ Throwable): Any

def info(msg: ⇒ String): Unit

final def isInstanceOf[T0]: Boolean

def loadProps(filename: String): Properties

var logIdent: String

lazy val logger: Logger

val loggerName: String

final def ne(arg0: AnyRef): Boolean

def newThread(runnable: Runnable, daemon: Boolean): Thread

def newThread(name: String, runnable: Runnable, daemon: Boolean): Thread

def notNull[V](v: V): V

final def notify(): Unit

final def notifyAll(): Unit

def nullOrEmpty(s: String): Boolean

def openChannel(file: File, mutable: Boolean): FileChannel

def parseCsvList(csvList: String): Seq[String]

def parseCsvMap(str: String): Map[String, String]

def read(channel: ReadableByteChannel, buffer: ByteBuffer): Int

def readBytes(buffer: ByteBuffer, offset: Int, size: Int): Array[Byte]

def readBytes(buffer: ByteBuffer): Array[Byte]

def readFileAsString(path: String, charset: Charset = Charset.defaultCharset()): String

def readInt(bytes: Array[Byte], offset: Int): Int

def readProps(s: String, defaults: Properties): Properties

def readString(buffer: ByteBuffer, encoding: String = Charset.defaultCharset.toString): String

def readUnsignedInt(buffer: ByteBuffer, index: Int): Long

def readUnsignedInt(buffer: ByteBuffer): Long

def registerMBean(mbean: AnyRef, name: String): Boolean

def replaceSuffix(s: String, oldSuffix: String, newSuffix: String): String

def rm(file: File): Unit

def rm(files: Seq[String]): Unit

def rm(file: String): Unit

def runnable(fun: ⇒ Unit): Runnable

def stackTrace(e: Throwable): String

def swallow(log: (AnyRef, Throwable) ⇒ Unit, action: ⇒ Unit): Unit

def swallow(action: ⇒ Unit): Unit

def swallowDebug(action: ⇒ Unit): Unit

def swallowError(action: ⇒ Unit): Unit

def swallowInfo(action: ⇒ Unit): Unit

def swallowTrace(action: ⇒ Unit): Unit