Scala bitwise-like method argument - scala

Question

Let's say there is a generic method declaration that performs a set of operations based upon a designated mode that would look something like this:
def doSomethingSmart(mode: OpMode, someGoodyList: List[Any]): Boolean = { /* do foo */ }
Where OpMode is a type/enumeration consisting of:
Read
Create
Delete
Modify
Whatever
Putting the two together would obviously yield a single-mode, reusable, code block.
Now, the type/enumeration part would probably look something like this:
object OpMode extends Enumeration {
type OpMode = Value
val Read, Write, Create, Modify, Delete, Whatever = Value
}
But let's say you wanted to expand the scope of doSomethingSmart() to span what is typically done using bitwise operators, for example: Create & Modify & Whatever. Is there a "scala-way" of restricting the bit-masked argument to that limited data-set (ie, the enumeration/type). Maybe something along these lines:
def doSomethingSmarter(more: T < [BitwiseSelectionOf[OpMode]], ...
Or, is it best to simply drop back to binary-indexed value assignments - in which cases there is no "type" checking per se?
TIA.
EDIT: I guess another possibility would be to change the OpMode to be a List and then just run a series of "contains" operations.
EDIT 2: In particular, I was looking for an efficient mechanism that provides an inline construct when making a call to doSomethingSmarter()

Answer 1

Enumeration defines an inner type called ValueSet which gives you at least some of the functionality you are looking for. The methods on it are still Set-like (you would add a new mode using +, and check for a mode using contains), but it may serve your purposes.
EDIT: had some fun fiddling around and came up with this:
import scala.collection.BitSet
object OpMode extends Enumeration {
protected case class Val(name: String, val mask: Int) extends super.Val(nextId, name)
type OpMode = Val
val Read = Val("Read", 1)
val Write = Val("Write", 2)
val Create = Val("Create", 4)
val Modify = Val("Modify", 8)
val Delete = Val("Delete", 16)
val Whatever = Val("Whatever", 32)
case class FlagSet(bits: BitSet) {
def isSet(mode: OpMode) = bits.contains(mode.mask)
def +(mode: OpMode) = new FlagSet(bits + mode.mask)
def -(mode: OpMode) = new FlagSet(bits - mode.mask)
def &(other: FlagSet) = new FlagSet(bits & other.bits)
def &~(other: FlagSet) = new FlagSet(bits &~ other.bits)
def ^(other: FlagSet) = new FlagSet(bits ^ other.bits)
def |(other: FlagSet) = new FlagSet(bits | other.bits)
def size = bits.size
// etc.
}
object FlagSet {
def apply(flags: OpMode*): FlagSet = apply(BitSet(flags.map(_.mask):_*))
def apply(modes: ValueSet): FlagSet = apply(BitSet(modes.toSeq.map{ case m: OpMode => m.mask }:_*))
}
}
def doSomethingSmarter(modes: OpMode.FlagSet, someGoodyList: List[Any]) = modes.size
val flags = OpMode.FlagSet(OpMode.Read, OpMode.Write)
doSomethingSmarter(flags, Nil)
val modes = OpMode.ValueSet(OpMode.Read, OpMode.Write)
doSomethingSmarter(OpMode.FlagSet(modes), Nil)
Basically, I extended the Enumeration.Val type to add a suitable bit mask for each mode, and added an inner class FlagSet to interoperate between OpModes and an under-the-covers BitSet. Changing doSomethingSmarter to take in such a FlagSet enables usage that should be closer to what you are hoping for.
The above can probably be improved upon, but working with Enumeration can be tricky. As an alternative, you might find it preferable to work with a sealed trait and case classes/objects extending it - this can often give semantics closer to what is possible with Java's enum types.