class PizzaToppings(Flags):
"""
Some pizza toppings, with obviously meaningful bitwise values.
"""
# Note 1<<1 < 1<<4 > 1<<2, so we are ensuring here that the definition
# order is different from the order of the values, which lets us test that
# we're not somehow ordering by value and happen the get the same results.
mozzarella = FlagConstant(1 << 1)
pesto = FlagConstant(1 << 4)
pepperoni = FlagConstant(1 << 2)
class Switches(Flags):
r = FlagConstant()
g = FlagConstant()
b = FlagConstant()
r.description = u"red"
g.description = u"green"
b.description = u"blue"
black = FlagConstant()
class FXF(Flags):
# Implicitly assign three flag values based on definition order
READ = FlagConstant()
WRITE = FlagConstant()
APPEND = FlagConstant()
# Explicitly assign one flag value by passing it in
EXCLUSIVE = FlagConstant(0x20)
# Implicitly assign another flag value, following the previously
# specified explicit value.
TEXT = FlagConstant()
def _setMatchFunctions(flags):
"""
Compute a predicate and normalize functions for the given match
expression flags.
@param flags: Match expression flags.
@type flags: L{MatchFlags}
@return: Predicate and normalize functions.
@rtype: L{tuple} of callables.
"""
predicate = lambda x: x
normalize = lambda x: x
def caseInsensitivify(x):
# Case insensitive only makes sense conceptually for text
# Note we are intentionally not treating bytes as text
if isinstance(x, unicode):
return x.lower()
else:
return x
if flags is None:
flags = FlagConstant()
else:
for flag in flags:
if flag == MatchFlags.NOT:
predicate = lambda x: not x
elif flag == MatchFlags.caseInsensitive:
normalize = caseInsensitivify
else:
raise NotImplementedError(
"Unknown query flag: {0}".format(describe(flag))
)
flags._predicate = predicate
flags._normalize = normalize
return flags
class CONTROLS(Flags):
"""
Control frame specifiers.
"""
CONTINUE = FlagConstant(0)
TEXT = FlagConstant(1)
BINARY = FlagConstant(2)
CLOSE = FlagConstant(8)
PING = FlagConstant(9)
PONG = FlagConstant(10)
class Authorization(Flags):
"""
Authorizations
"""
imsAdmin = FlagConstant()
readPersonnel = FlagConstant()
readIncidents = FlagConstant()
writeIncidents = FlagConstant()
readIncidentReports = FlagConstant()
writeIncidentReports = FlagConstant()
class TunnelFlags(Flags):
"""
L{TunnelFlags} defines more flags which are used to configure the behavior
of a tunnel device.
@cvar IFF_TUN: This indicates a I{tun}-type device. This type of tunnel
carries IP datagrams. This flag is mutually exclusive with C{IFF_TAP}.
@cvar IFF_TAP: This indicates a I{tap}-type device. This type of tunnel
carries ethernet frames. This flag is mutually exclusive with C{IFF_TUN}.
@cvar IFF_NO_PI: This indicates the I{protocol information} header will
B{not} be included in data read from the tunnel.
@see: U{https://www.kernel.org/doc/Documentation/networking/tuntap.txt}
"""
IFF_TUN = FlagConstant(0x0001)
IFF_TAP = FlagConstant(0x0002)
TUN_FASYNC = FlagConstant(0x0010)
TUN_NOCHECKSUM = FlagConstant(0x0020)
TUN_NO_PI = FlagConstant(0x0040)
TUN_ONE_QUEUE = FlagConstant(0x0080)
TUN_PERSIST = FlagConstant(0x0100)
TUN_VNET_HDR = FlagConstant(0x0200)
IFF_NO_PI = FlagConstant(0x1000)
IFF_ONE_QUEUE = FlagConstant(0x2000)
IFF_VNET_HDR = FlagConstant(0x4000)
IFF_TUN_EXCL = FlagConstant(0x8000)
class TIMEX(Flags):
# (timex.mode)
ADJ_OFFSET = FlagConstant(0x0001) # time offset
# xntp 3.4 compatibility names
MOD_OFFSET = FlagConstant(0x0001)
class MatchFlags(Flags):
"""
Match expression flags.
"""
NOT = FlagConstant()
NOT.description = u"not"
caseInsensitive = FlagConstant()
caseInsensitive.description = u"case insensitive"
none = None
@staticmethod
def _setMatchFunctions(flags):
"""
Compute a predicate and normalize functions for the given match
expression flags.
@param flags: Match expression flags.
@type flags: L{MatchFlags}
@return: Predicate and normalize functions.
@rtype: L{tuple} of callables.
"""
predicate = lambda x: x
normalize = lambda x: x
def caseInsensitivify(x):
# Case insensitive only makes sense conceptually for text
# Note we are intentionally not treating bytes as text
if isinstance(x, unicode):
return x.lower()
else:
return x
if flags is None:
flags = FlagConstant()
else:
for flag in flags:
if flag == MatchFlags.NOT:
predicate = lambda x: not x
elif flag == MatchFlags.caseInsensitive:
normalize = caseInsensitivify
else:
raise NotImplementedError("Unknown query flag: {0}".format(
describe(flag)))
flags._predicate = predicate
flags._normalize = normalize
return flags
@staticmethod
def predicator(flags):
"""
Determine a predicate function for the given flags.
@param flags: Match expression flags.
@type flags: L{MatchFlags}
@return: a L{callable} that accepts an L{object} argument and returns a
L{object} that has the opposite or same truth value as the argument,
depending on whether L{MatchFlags.NOT} is or is not in C{flags}.
@rtype: callable
"""
if not hasattr(flags, "_predicate"):
flags = MatchFlags._setMatchFunctions(flags)
return flags._predicate
@staticmethod
def normalizer(flags):
"""
Determine a normalize function for the given flags.
@param flags: Match expression flags.
@type flags: L{MatchFlags}
@return: a L{callable} that accepts a L{unicode} and returns the same
L{unicode} or a normalized L{unicode} that can be compared with other
normalized L{unicode}s in a case-insensitive fashion, depending on
whether L{MatchFlags.caseInsensitive} is not or is in C{flags}.
@rtype: callable
"""
if not hasattr(flags, "_normalize"):
flags = MatchFlags._setMatchFunctions(flags)
return flags._normalize
class OtherAccess(Flags):
"""
More access types.
"""
delete = FlagConstant()
class Access(Flags):
"""
Some access types.
"""
read = FlagConstant()
write = FlagConstant()