Inheritance diagram for BitArray:

Public Member Functions
def	__init__ (self, auto=None, length=None, offset=None, **kwargs)

def	__new__ (cls, auto=None, length=None, offset=None, **kwargs)

def	__iadd__ (self, bs)

def	__copy__ (self)

def	__setitem__ (self, key, value)

def	__delitem__ (self, key)

def	__ilshift__ (self, n)

def	__irshift__ (self, n)

def	__imul__ (self, n)

def	__ior__ (self, bs)

def	__iand__ (self, bs)

def	__ixor__ (self, bs)

def	replace (self, old, new, start=None, end=None, count=None, bytealigned=None)

def	insert (self, bs, pos=None)

def	overwrite (self, bs, pos=None)

def	append (self, bs)

def	prepend (self, bs)

def	reverse (self, start=None, end=None)

def	set (self, value, pos=None)

def	invert (self, pos=None)

def	ror (self, bits, start=None, end=None)

def	rol (self, bits, start=None, end=None)

def	byteswap (self, fmt=None, start=None, end=None, repeat=True)

def	clear (self)

def	copy (self)

Protected Attributes
	_pos

Properties
property	int

property	uint

property	float

property	intbe

property	uintbe

property	floatbe

property	intle

property	uintle

property	floatle

property	intne

property	uintne

property	floatne

property	ue

property	se

property	uie

property	sie

property	hex

property	bin

property	oct

property	bool

property	bytes

Static Private Attributes
tuple	__slots__ = ()

None	__hash__ = None

Detailed Description

A container holding a mutable sequence of bits.

Subclass of the immutable Bits class. Inherits all of its
methods (except __hash__) and adds mutating methods.

Mutating methods:

append() -- Append a bitstring.
byteswap() -- Change byte endianness in-place.
insert() -- Insert a bitstring.
invert() -- Flip bit(s) between one and zero.
overwrite() -- Overwrite a section with a new bitstring.
prepend() -- Prepend a bitstring.
replace() -- Replace occurrences of one bitstring with another.
reverse() -- Reverse bits in-place.
rol() -- Rotate bits to the left.
ror() -- Rotate bits to the right.
set() -- Set bit(s) to 1 or 0.

Methods inherited from Bits:

all() -- Check if all specified bits are set to 1 or 0.
any() -- Check if any of specified bits are set to 1 or 0.
count() -- Count the number of bits set to 1 or 0.
cut() -- Create generator of constant sized chunks.
endswith() -- Return whether the bitstring ends with a sub-string.
find() -- Find a sub-bitstring in the current bitstring.
findall() -- Find all occurrences of a sub-bitstring in the current bitstring.
join() -- Join bitstrings together using current bitstring.
rfind() -- Seek backwards to find a sub-bitstring.
split() -- Create generator of chunks split by a delimiter.
startswith() -- Return whether the bitstring starts with a sub-bitstring.
tobytes() -- Return bitstring as bytes, padding if needed.
tofile() -- Write bitstring to file, padding if needed.
unpack() -- Interpret bits using format string.

Special methods:

Mutating operators are available: [], <<=, >>=, +=, *=, &=, |= and ^=
in addition to the inherited [], ==, !=, +, *, ~, <<, >>, &, | and ^.

Properties:

bin -- The bitstring as a binary string.
bool -- For single bit bitstrings, interpret as True or False.
bytepos -- The current byte position in the bitstring.
bytes -- The bitstring as a bytes object.
float -- Interpret as a floating point number.
floatbe -- Interpret as a big-endian floating point number.
floatle -- Interpret as a little-endian floating point number.
floatne -- Interpret as a native-endian floating point number.
hex -- The bitstring as a hexadecimal string.
int -- Interpret as a two's complement signed integer.
intbe -- Interpret as a big-endian signed integer.
intle -- Interpret as a little-endian signed integer.
intne -- Interpret as a native-endian signed integer.
len -- Length of the bitstring in bits.
oct -- The bitstring as an octal string.
pos -- The current bit position in the bitstring.
se -- Interpret as a signed exponential-Golomb code.
ue -- Interpret as an unsigned exponential-Golomb code.
sie -- Interpret as a signed interleaved exponential-Golomb code.
uie -- Interpret as an unsigned interleaved exponential-Golomb code.
uint -- Interpret as a two's complement unsigned integer.
uintbe -- Interpret as a big-endian unsigned integer.
uintle -- Interpret as a little-endian unsigned integer.
uintne -- Interpret as a native-endian unsigned integer.

Definition at line 2949 of file bitstring.py.

Constructor & Destructor Documentation

◆ init()

def __init__	(		self,
			auto = `None`,
			length = `None`,
			offset = `None`,
		**	kwargs
	)

Either specify an 'auto' initialiser:
auto -- a string of comma separated tokens, an integer, a file object,
        a bytearray, a boolean iterable or another bitstring.

Or initialise via **kwargs with one (and only one) of:
bytes -- raw data as a string, for example read from a binary file.
bin -- binary string representation, e.g. '0b001010'.
hex -- hexadecimal string representation, e.g. '0x2ef'
oct -- octal string representation, e.g. '0o777'.
uint -- an unsigned integer.
int -- a signed integer.
float -- a floating point number.
uintbe -- an unsigned big-endian whole byte integer.
intbe -- a signed big-endian whole byte integer.
floatbe - a big-endian floating point number.
uintle -- an unsigned little-endian whole byte integer.
intle -- a signed little-endian whole byte integer.
floatle -- a little-endian floating point number.
uintne -- an unsigned native-endian whole byte integer.
intne -- a signed native-endian whole byte integer.
floatne -- a native-endian floating point number.
se -- a signed exponential-Golomb code.
ue -- an unsigned exponential-Golomb code.
sie -- a signed interleaved exponential-Golomb code.
uie -- an unsigned interleaved exponential-Golomb code.
bool -- a boolean (True or False).
filename -- a file which will be opened in binary read-only mode.

Other keyword arguments:
length -- length of the bitstring in bits, if needed and appropriate.
          It must be supplied for all integer and float initialisers.
offset -- bit offset to the data. These offset bits are
          ignored and this is intended for use when
          initialising using 'bytes' or 'filename'.

Reimplemented from Bits.

Reimplemented in BitStream.

Definition at line 3025 of file bitstring.py.

    def __init__(self, auto=None, length=None, offset=None, **kwargs):
        """Either specify an 'auto' initialiser:
        auto -- a string of comma separated tokens, an integer, a file object,
                a bytearray, a boolean iterable or another bitstring.
 
        Or initialise via **kwargs with one (and only one) of:
        bytes -- raw data as a string, for example read from a binary file.
        bin -- binary string representation, e.g. '0b001010'.
        hex -- hexadecimal string representation, e.g. '0x2ef'
        oct -- octal string representation, e.g. '0o777'.
        uint -- an unsigned integer.
        int -- a signed integer.
        float -- a floating point number.
        uintbe -- an unsigned big-endian whole byte integer.
        intbe -- a signed big-endian whole byte integer.
        floatbe - a big-endian floating point number.
        uintle -- an unsigned little-endian whole byte integer.
        intle -- a signed little-endian whole byte integer.
        floatle -- a little-endian floating point number.
        uintne -- an unsigned native-endian whole byte integer.
        intne -- a signed native-endian whole byte integer.
        floatne -- a native-endian floating point number.
        se -- a signed exponential-Golomb code.
        ue -- an unsigned exponential-Golomb code.
        sie -- a signed interleaved exponential-Golomb code.
        uie -- an unsigned interleaved exponential-Golomb code.
        bool -- a boolean (True or False).
        filename -- a file which will be opened in binary read-only mode.
 
        Other keyword arguments:
        length -- length of the bitstring in bits, if needed and appropriate.
                  It must be supplied for all integer and float initialisers.
        offset -- bit offset to the data. These offset bits are
                  ignored and this is intended for use when
                  initialising using 'bytes' or 'filename'.
 
        """
        # For mutable BitArrays we always read in files to memory:
        if not isinstance(self._datastore, ByteStore):
            self._ensureinmemory()
 

Member Function Documentation

◆ copy()

def __copy__ ( self )

Return a new copy of the BitArray.

Reimplemented from Bits.

Reimplemented in BitStream.

Definition at line 3081 of file bitstring.py.

    def __copy__(self):
        """Return a new copy of the BitArray."""
        s_copy = BitArray()
        if not isinstance(self._datastore, ByteStore):
            # Let them both point to the same (invariant) array.
            # If either gets modified then at that point they'll be read into memory.
            s_copy._datastore = self._datastore
        else:
            s_copy._datastore = copy.copy(self._datastore)
        return s_copy
 

◆ delitem()

def __delitem__	(	self,
		key
	)

Delete item or range.

Indices are in units of the step parameter (default 1 bit).
Stepping is used to specify the number of bits in each item.

>>> a = BitArray('0x001122')
>>> del a[1:2:8]
>>> print a
0x0022

Definition at line 3200 of file bitstring.py.

    def __delitem__(self, key):
        """Delete item or range.
 
        Indices are in units of the step parameter (default 1 bit).
        Stepping is used to specify the number of bits in each item.
 
        >>> a = BitArray('0x001122')
        >>> del a[1:2:8]
        >>> print a
        0x0022
 
        """
        try:
            # A slice
            start = 0
            step = key.step if key.step is not None else 1
        except AttributeError:
            # single element
            if key < 0:
                key += self.len
            if not 0 <= key < self.len:
                raise IndexError("Slice index out of range.")
            self._delete(1, key)
            return
        else:
            if step != 1:
                # convert to binary string and use string slicing
                # TODO: Horribly inefficent
                temp = list(self._getbin())
                temp.__delitem__(key)
                self._setbin_unsafe(''.join(temp))
                return
            stop = key.stop
            if key.start is not None:
                start = key.start
                if key.start < 0 and stop is None:
                    start += self.len
                if start < 0:
                    start = 0
            if stop is None:
                stop = self.len
            if start > stop:
                return
            stop = min(stop, self.len)
            start = max(start, 0)
            start = min(start, stop)
            self._delete(stop - start, start)
            return
 

◆ iadd()

def __iadd__	(	self,
		bs
	)

Append bs to current bitstring. Return self.

bs -- the bitstring to append.

Definition at line 3072 of file bitstring.py.

    def __iadd__(self, bs):
        """Append bs to current bitstring. Return self.
 
        bs -- the bitstring to append.
 
        """
        self.append(bs)
        return self
 

◆ iand()

def __iand__	(	self,
		bs
	)

Definition at line 3297 of file bitstring.py.

    def __iand__(self, bs):
        bs = Bits(bs)
        if self.len != bs.len:
            raise ValueError("Bitstrings must have the same length "
                             "for &= operator.")
        return self._iand(bs)
 

◆ ilshift()

def __ilshift__	(	self,
		n
	)

Shift bits by n to the left in place. Return self.

n -- the number of bits to shift. Must be >= 0.

Definition at line 3249 of file bitstring.py.

    def __ilshift__(self, n):
        """Shift bits by n to the left in place. Return self.
 
        n -- the number of bits to shift. Must be >= 0.
 
        """
        if n < 0:
            raise ValueError("Cannot shift by a negative amount.")
        if not self.len:
            raise ValueError("Cannot shift an empty bitstring.")
        if not n:
            return self
        n = min(n, self.len)
        return self._ilshift(n)
 

◆ imul()

def __imul__	(	self,
		n
	)

Concatenate n copies of self in place. Return self.

Called for expressions of the form 'a *= 3'.
n -- The number of concatenations. Must be >= 0.

Definition at line 3279 of file bitstring.py.

    def __imul__(self, n):
        """Concatenate n copies of self in place. Return self.
 
        Called for expressions of the form 'a *= 3'.
        n -- The number of concatenations. Must be >= 0.
 
        """
        if n < 0:
            raise ValueError("Cannot multiply by a negative integer.")
        return self._imul(n)
 

◆ ior()

def __ior__	(	self,
		bs
	)

Definition at line 3290 of file bitstring.py.

    def __ior__(self, bs):
        bs = Bits(bs)
        if self.len != bs.len:
            raise ValueError("Bitstrings must have the same length "
                             "for |= operator.")
        return self._ior(bs)
 

◆ irshift()

def __irshift__	(	self,
		n
	)

Shift bits by n to the right in place. Return self.

n -- the number of bits to shift. Must be >= 0.

Definition at line 3264 of file bitstring.py.

    def __irshift__(self, n):
        """Shift bits by n to the right in place. Return self.
 
        n -- the number of bits to shift. Must be >= 0.
 
        """
        if n < 0:
            raise ValueError("Cannot shift by a negative amount.")
        if not self.len:
            raise ValueError("Cannot shift an empty bitstring.")
        if not n:
            return self
        n = min(n, self.len)
        return self._irshift(n)
 

◆ ixor()

def __ixor__	(	self,
		bs
	)

Definition at line 3304 of file bitstring.py.

    def __ixor__(self, bs):
        bs = Bits(bs)
        if self.len != bs.len:
            raise ValueError("Bitstrings must have the same length "
                             "for ^= operator.")
        return self._ixor(bs)
 

◆ new()

def __new__	(		cls,
			auto = `None`,
			length = `None`,
			offset = `None`,
		**	kwargs
	)

Reimplemented from Bits.

Definition at line 3066 of file bitstring.py.

    def __new__(cls, auto=None, length=None, offset=None, **kwargs):
        x = super(BitArray, cls).__new__(cls)
        y = Bits.__new__(BitArray, auto, length, offset, **kwargs)
        x._datastore = y._datastore
        return x
 

◆ setitem()

def __setitem__	(	self,
		key,
		value
	)

Set item or range to new value.

Indices are in units of the step parameter (default 1 bit).
Stepping is used to specify the number of bits in each item.

If the length of the bitstring is changed then pos will be moved
to after the inserted section, otherwise it will remain unchanged.

>>> s = BitArray('0xff')
>>> s[0:1:4] = '0xe'
>>> print s
'0xef'
>>> s[4:4] = '0x00'
>>> print s
'0xe00f'

Definition at line 3092 of file bitstring.py.

    def __setitem__(self, key, value):
        """Set item or range to new value.
 
        Indices are in units of the step parameter (default 1 bit).
        Stepping is used to specify the number of bits in each item.
 
        If the length of the bitstring is changed then pos will be moved
        to after the inserted section, otherwise it will remain unchanged.
 
        >>> s = BitArray('0xff')
        >>> s[0:1:4] = '0xe'
        >>> print s
        '0xef'
        >>> s[4:4] = '0x00'
        >>> print s
        '0xe00f'
 
        """
        try:
            # A slice
            start, step = 0, 1
            if key.step is not None:
                step = key.step
        except AttributeError:
            # single element
            if key < 0:
                key += self.len
            if not 0 <= key < self.len:
                raise IndexError("Slice index out of range.")
            if isinstance(value, numbers.Integral):
                if not value:
                    self._unset(key)
                    return
                if value in (1, -1):
                    self._set(key)
                    return
                raise ValueError("Cannot set a single bit with integer {0}.".format(value))
            value = Bits(value)
            if value.len == 1:
                # TODO: this can't be optimal
                if value[0]:
                    self._set(key)
                else:
                    self._unset(key)
            else:
                self._delete(1, key)
                self._insert(value, key)
            return
        else:
            if step != 1:
                # convert to binary string and use string slicing
                # TODO: Horribly inefficent
                temp = list(self._getbin())
                v = list(Bits(value)._getbin())
                temp.__setitem__(key, v)
                self._setbin_unsafe(''.join(temp))
                return
 
            # If value is an integer then we want to set the slice to that
            # value rather than initialise a new bitstring of that length.
            if not isinstance(value, numbers.Integral):
                try:
                    # TODO: Better way than calling constructor here?
                    value = Bits(value)
                except TypeError:
                    raise TypeError("Bitstring, integer or string expected. "
                                    "Got {0}.".format(type(value)))
            if key.start is not None:
                start = key.start
                if key.start < 0:
                    start += self.len
                if start < 0:
                    start = 0
            stop = self.len
            if key.stop is not None:
                stop = key.stop
                if key.stop < 0:
                    stop += self.len
            if start > stop:
                # The standard behaviour for lists is to just insert at the
                # start position if stop < start and step == 1.
                stop = start
            if isinstance(value, numbers.Integral):
                if value >= 0:
                    value = self.__class__(uint=value, length=stop - start)
                else:
                    value = self.__class__(int=value, length=stop - start)
            stop = min(stop, self.len)
            start = max(start, 0)
            start = min(start, stop)
            if (stop - start) == value.len:
                if not value.len:
                    return
                if step >= 0:
                    self._overwrite(value, start)
                else:
                    self._overwrite(value.__getitem__(slice(None, None, 1)), start)
            else:
                # TODO: A delete then insert is wasteful - it could do unneeded shifts.
                # Could be either overwrite + insert or overwrite + delete.
                self._delete(stop - start, start)
                if step >= 0:
                    self._insert(value, start)
                else:
                    self._insert(value.__getitem__(slice(None, None, 1)), start)
                # pos is now after the inserted piece.
            return
 

◆ append()

def append	(	self,
		bs
	)

Append a bitstring to the current bitstring.

bs -- The bitstring to append.

Definition at line 3430 of file bitstring.py.

    def append(self, bs):
        """Append a bitstring to the current bitstring.
 
        bs -- The bitstring to append.
 
        """
        # The offset is a hint to make bs easily appendable.
        bs = self._converttobitstring(bs, offset=(self.len + self._offset) % 8)
        self._append(bs)
 

◆ byteswap()

def byteswap	(	self,
		fmt = `None`,
		start = `None`,
		end = `None`,
		repeat = `True`
	)

Change the endianness in-place. Return number of repeats of fmt done.

fmt -- A compact structure string, an integer number of bytes or
       an iterable of integers. Defaults to 0, which byte reverses the
       whole bitstring.
start -- Start bit position, defaults to 0.
end -- End bit position, defaults to self.len.
repeat -- If True (the default) the byte swapping pattern is repeated
          as much as possible.

Definition at line 3566 of file bitstring.py.

    def byteswap(self, fmt=None, start=None, end=None, repeat=True):
        """Change the endianness in-place. Return number of repeats of fmt done.
 
        fmt -- A compact structure string, an integer number of bytes or
               an iterable of integers. Defaults to 0, which byte reverses the
               whole bitstring.
        start -- Start bit position, defaults to 0.
        end -- End bit position, defaults to self.len.
        repeat -- If True (the default) the byte swapping pattern is repeated
                  as much as possible.
 
        """
        start, end = self._validate_slice(start, end)
        if fmt is None or fmt == 0:
            # reverse all of the whole bytes.
            bytesizes = [(end - start) // 8]
        elif isinstance(fmt, numbers.Integral):
            if fmt < 0:
                raise ValueError("Improper byte length {0}.".format(fmt))
            bytesizes = [fmt]
        elif isinstance(fmt, basestring):
            m = STRUCT_PACK_RE.match(fmt)
            if not m:
                raise ValueError("Cannot parse format string {0}.".format(fmt))
            # Split the format string into a list of 'q', '4h' etc.
            formatlist = re.findall(STRUCT_SPLIT_RE, m.group('fmt'))
            # Now deal with multiplicative factors, 4h -> hhhh etc.
            bytesizes = []
            for f in formatlist:
                if len(f) == 1:
                    bytesizes.append(PACK_CODE_SIZE[f])
                else:
                    bytesizes.extend([PACK_CODE_SIZE[f[-1]]] * int(f[:-1]))
        elif isinstance(fmt, collections.abc.Iterable):
            bytesizes = fmt
            for bytesize in bytesizes:
                if not isinstance(bytesize, numbers.Integral) or bytesize < 0:
                    raise ValueError("Improper byte length {0}.".format(bytesize))
        else:
            raise TypeError("Format must be an integer, string or iterable.")
 
        repeats = 0
        totalbitsize = 8 * sum(bytesizes)
        if not totalbitsize:
            return 0
        if repeat:
            # Try to repeat up to the end of the bitstring.
            finalbit = end
        else:
            # Just try one (set of) byteswap(s).
            finalbit = start + totalbitsize
        for patternend in xrange(start + totalbitsize, finalbit + 1, totalbitsize):
            bytestart = patternend - totalbitsize
            for bytesize in bytesizes:
                byteend = bytestart + bytesize * 8
                self._reversebytes(bytestart, byteend)
                bytestart += bytesize * 8
            repeats += 1
        return repeats
 

◆ clear()

def clear ( self )

Remove all bits, reset to zero length.

Definition at line 3626 of file bitstring.py.

    def clear(self):
        """Remove all bits, reset to zero length."""
        self._clear()
 

◆ copy()

def copy ( self )

Return a copy of the bitstring.

Definition at line 3630 of file bitstring.py.

    def copy(self):
        """Return a copy of the bitstring."""
        return self._copy()
 

◆ insert()

def insert	(	self,
		bs,
		pos = `None`
	)

Insert bs at bit position pos.

bs -- The bitstring to insert.
pos -- The bit position to insert at.

Raises ValueError if pos < 0 or pos > self.len.

Definition at line 3378 of file bitstring.py.

    def insert(self, bs, pos=None):
        """Insert bs at bit position pos.
 
        bs -- The bitstring to insert.
        pos -- The bit position to insert at.
 
        Raises ValueError if pos < 0 or pos > self.len.
 
        """
        bs = Bits(bs)
        if not bs.len:
            return self
        if bs is self:
            bs = self.__copy__()
        if pos is None:
            try:
                pos = self._pos
            except AttributeError:
                raise TypeError("insert require a bit position for this type.")
        if pos < 0:
            pos += self.len
        if not 0 <= pos <= self.len:
            raise ValueError("Invalid insert position.")
        self._insert(bs, pos)
 

◆ invert()

def invert	(	self,
		pos = `None`
	)

Invert one or many bits from 0 to 1 or vice versa.

pos -- Either a single bit position or an iterable of bit positions.
       Negative numbers are treated in the same way as slice indices.

Raises IndexError if pos < -self.len or pos >= self.len.

Definition at line 3499 of file bitstring.py.

    def invert(self, pos=None):
        """Invert one or many bits from 0 to 1 or vice versa.
 
        pos -- Either a single bit position or an iterable of bit positions.
               Negative numbers are treated in the same way as slice indices.
 
        Raises IndexError if pos < -self.len or pos >= self.len.
 
        """
        if pos is None:
            self._invert_all()
            return
        if not isinstance(pos, collections.abc.Iterable):
            pos = (pos,)
        length = self.len
 
        for p in pos:
            if p < 0:
                p += length
            if not 0 <= p < length:
                raise IndexError("Bit position {0} out of range.".format(p))
            self._invert(p)
 

◆ overwrite()

def overwrite	(	self,
		bs,
		pos = `None`
	)

Overwrite with bs at bit position pos.

bs -- The bitstring to overwrite with.
pos -- The bit position to begin overwriting from.

Raises ValueError if pos < 0 or pos + bs.len > self.len

Definition at line 3403 of file bitstring.py.

    def overwrite(self, bs, pos=None):
        """Overwrite with bs at bit position pos.
 
        bs -- The bitstring to overwrite with.
        pos -- The bit position to begin overwriting from.
 
        Raises ValueError if pos < 0 or pos + bs.len > self.len
 
        """
        bs = Bits(bs)
        if not bs.len:
            return
        if pos is None:
            try:
                pos = self._pos
            except AttributeError:
                raise TypeError("overwrite require a bit position for this type.")
        if pos < 0:
            pos += self.len
        if pos < 0 or pos + bs.len > self.len:
            raise ValueError("Overwrite exceeds boundary of bitstring.")
        self._overwrite(bs, pos)
        try:
            self._pos = pos + bs.len
        except AttributeError:
            pass
 

◆ prepend()

def prepend	(	self,
		bs
	)

Prepend a bitstring to the current bitstring.

bs -- The bitstring to prepend.

Reimplemented in BitStream.

Definition at line 3440 of file bitstring.py.

    def prepend(self, bs):
        """Prepend a bitstring to the current bitstring.
 
        bs -- The bitstring to prepend.
 
        """
        bs = Bits(bs)
        self._prepend(bs)
 

◆ replace()

def replace	(	self,
		old,
		new,
		start = `None`,
		end = `None`,
		count = `None`,
		bytealigned = `None`
	)

Replace all occurrences of old with new in place.

Returns number of replacements made.

old -- The bitstring to replace.
new -- The replacement bitstring.
start -- Any occurrences that start before this will not be replaced.
         Defaults to 0.
end -- Any occurrences that finish after this will not be replaced.
       Defaults to self.len.
count -- The maximum number of replacements to make. Defaults to
         replace all occurrences.
bytealigned -- If True replacements will only be made on byte
               boundaries.

Raises ValueError if old is empty or if start or end are
out of range.

Definition at line 3311 of file bitstring.py.

                bytealigned=None):
        """Replace all occurrences of old with new in place.
 
        Returns number of replacements made.
 
        old -- The bitstring to replace.
        new -- The replacement bitstring.
        start -- Any occurrences that start before this will not be replaced.
                 Defaults to 0.
        end -- Any occurrences that finish after this will not be replaced.
               Defaults to self.len.
        count -- The maximum number of replacements to make. Defaults to
                 replace all occurrences.
        bytealigned -- If True replacements will only be made on byte
                       boundaries.
 
        Raises ValueError if old is empty or if start or end are
        out of range.
 
        """
        old = Bits(old)
        new = Bits(new)
        if not old.len:
            raise ValueError("Empty bitstring cannot be replaced.")
        start, end = self._validate_slice(start, end)
        if bytealigned is None:
            bytealigned = globals()['bytealigned']
        # Adjust count for use in split()
        if count is not None:
            count += 1
        sections = self.split(old, start, end, count, bytealigned)
        lengths = [s.len for s in sections]
        if len(lengths) == 1:
            # Didn't find anything to replace.
            return 0  # no replacements done
        if new is self:
            # Prevent self assignment woes
            new = copy.copy(self)
        positions = [lengths[0] + start]
        for k in lengths[1:-1]:
            # Next position is the previous one plus the length of the next section.
            positions.append(positions[-1] + k)
        # We have all the positions that need replacements. We do them
        # in reverse order so that they won't move around as we replace.
        positions.reverse()
        try:
            # Need to calculate new pos, if this is a bitstream
            newpos = self._pos
            for p in positions:
                self[p:p + old.len] = new
            if old.len != new.len:
                diff = new.len - old.len
                for p in positions:
                    if p >= newpos:
                        continue
                    if p + old.len <= newpos:
                        newpos += diff
                    else:
                        newpos = p
            self._pos = newpos
        except AttributeError:
            for p in positions:
                self[p:p + old.len] = new
        assert self._assertsanity()
        return len(lengths) - 1
 

◆ reverse()

def reverse	(	self,
		start = `None`,
		end = `None`
	)

Reverse bits in-place.

start -- Position of first bit to reverse. Defaults to 0.
end -- One past the position of the last bit to reverse.
       Defaults to self.len.

Using on an empty bitstring will have no effect.

Raises ValueError if start < 0, end > self.len or end < start.

Definition at line 3449 of file bitstring.py.

    def reverse(self, start=None, end=None):
        """Reverse bits in-place.
 
        start -- Position of first bit to reverse. Defaults to 0.
        end -- One past the position of the last bit to reverse.
               Defaults to self.len.
 
        Using on an empty bitstring will have no effect.
 
        Raises ValueError if start < 0, end > self.len or end < start.
 
        """
        start, end = self._validate_slice(start, end)
        if start == 0 and end == self.len:
            self._reverse()
            return
        s = self._slice(start, end)
        s._reverse()
        self[start:end] = s
 

◆ rol()

def rol	(	self,
		bits,
		start = `None`,
		end = `None`
	)

Rotate bits to the left in-place.

bits -- The number of bits to rotate by.
start -- Start of slice to rotate. Defaults to 0.
end -- End of slice to rotate. Defaults to self.len.

Raises ValueError if bits < 0.

Definition at line 3544 of file bitstring.py.

    def rol(self, bits, start=None, end=None):
        """Rotate bits to the left in-place.
 
        bits -- The number of bits to rotate by.
        start -- Start of slice to rotate. Defaults to 0.
        end -- End of slice to rotate. Defaults to self.len.
 
        Raises ValueError if bits < 0.
 
        """
        if not self.len:
            raise Error("Cannot rotate an empty bitstring.")
        if bits < 0:
            raise ValueError("Cannot rotate left by negative amount.")
        start, end = self._validate_slice(start, end)
        bits %= (end - start)
        if not bits:
            return
        lhs = self._slice(start, start + bits)
        self._delete(bits, start)
        self._insert(lhs, end - bits)
 

◆ ror()

def ror	(	self,
		bits,
		start = `None`,
		end = `None`
	)

Rotate bits to the right in-place.

bits -- The number of bits to rotate by.
start -- Start of slice to rotate. Defaults to 0.
end -- End of slice to rotate. Defaults to self.len.

Raises ValueError if bits < 0.

Definition at line 3522 of file bitstring.py.

    def ror(self, bits, start=None, end=None):
        """Rotate bits to the right in-place.
 
        bits -- The number of bits to rotate by.
        start -- Start of slice to rotate. Defaults to 0.
        end -- End of slice to rotate. Defaults to self.len.
 
        Raises ValueError if bits < 0.
 
        """
        if not self.len:
            raise Error("Cannot rotate an empty bitstring.")
        if bits < 0:
            raise ValueError("Cannot rotate right by negative amount.")
        start, end = self._validate_slice(start, end)
        bits %= (end - start)
        if not bits:
            return
        rhs = self._slice(end - bits, end)
        self._delete(bits, end - bits)
        self._insert(rhs, start)
 

◆ set()

def set	(	self,
		value,
		pos = `None`
	)

Set one or many bits to 1 or 0.

value -- If True bits are set to 1, otherwise they are set to 0.
pos -- Either a single bit position or an iterable of bit positions.
       Negative numbers are treated in the same way as slice indices.
       Defaults to the entire bitstring.

Raises IndexError if pos < -self.len or pos >= self.len.

Definition at line 3469 of file bitstring.py.

    def set(self, value, pos=None):
        """Set one or many bits to 1 or 0.
 
        value -- If True bits are set to 1, otherwise they are set to 0.
        pos -- Either a single bit position or an iterable of bit positions.
               Negative numbers are treated in the same way as slice indices.
               Defaults to the entire bitstring.
 
        Raises IndexError if pos < -self.len or pos >= self.len.
 
        """
        f = self._set if value else self._unset
        if pos is None:
            pos = xrange(self.len)
        try:
            length = self.len
            for p in pos:
                if p < 0:
                    p += length
                if not 0 <= p < length:
                    raise IndexError("Bit position {0} out of range.".format(p))
                f(p)
        except TypeError:
            # Single pos
            if pos < 0:
                pos += self.len
            if not 0 <= pos < length:
                raise IndexError("Bit position {0} out of range.".format(pos))
            f(pos)
 

Member Data Documentation

◆ hash

None __hash__ = None

staticprivate

Definition at line 3023 of file bitstring.py.

◆ slots

tuple __slots__ = ()

staticprivate

Definition at line 3020 of file bitstring.py.

◆ _pos

_pos

protected

Definition at line 3371 of file bitstring.py.

Property Documentation

◆ bin

property bin

static

Initial value:

= property(Bits._getbin, Bits._setbin_safe,

doc=)

Definition at line 3685 of file bitstring.py.

◆ bool

property bool

static

Initial value:

= property(Bits._getbool, Bits._setbool,

doc=)

Definition at line 3691 of file bitstring.py.

◆ bytes

property bytes

static

Initial value:

= property(Bits._getbytes, Bits._setbytes_safe,

doc=)

Definition at line 3694 of file bitstring.py.

◆ float

property float

static

Initial value:

= property(Bits._getfloat, Bits._setfloat,

doc=)

Definition at line 3640 of file bitstring.py.

◆ floatbe

property floatbe

static

Initial value:

= property(Bits._getfloat, Bits._setfloat,

doc=)

Definition at line 3649 of file bitstring.py.

◆ floatle

property floatle

static

Initial value:

= property(Bits._getfloatle, Bits._setfloatle,

doc=)

Definition at line 3658 of file bitstring.py.

◆ floatne

property floatne

static

Initial value:

= property(Bits._getfloatne, Bits._setfloatne,

doc=)

Definition at line 3667 of file bitstring.py.

◆ hex

property hex

static

Initial value:

= property(Bits._gethex, Bits._sethex,

doc=)

Definition at line 3682 of file bitstring.py.

◆ int

property int

static

Initial value:

= property(Bits._getint, Bits._setint,

doc=)

Definition at line 3634 of file bitstring.py.

◆ intbe

property intbe

static

Initial value:

= property(Bits._getintbe, Bits._setintbe,

doc=)

Definition at line 3643 of file bitstring.py.

◆ intle

property intle

static

Initial value:

= property(Bits._getintle, Bits._setintle,

doc=)

Definition at line 3652 of file bitstring.py.

◆ intne

property intne

static

Initial value:

= property(Bits._getintne, Bits._setintne,

doc=)

Definition at line 3661 of file bitstring.py.

◆ oct

property oct

static

Initial value:

= property(Bits._getoct, Bits._setoct,

doc=)

Definition at line 3688 of file bitstring.py.

◆ se

property se

static

Initial value:

= property(Bits._getse, Bits._setse,

doc=)

Definition at line 3673 of file bitstring.py.

◆ sie

property sie

static

Initial value:

= property(Bits._getsie, Bits._setsie,

doc=)

Definition at line 3679 of file bitstring.py.

◆ ue

property ue

static

Initial value:

= property(Bits._getue, Bits._setue,

doc=)

Definition at line 3670 of file bitstring.py.

◆ uie

property uie

static

Initial value:

= property(Bits._getuie, Bits._setuie,

doc=)

Definition at line 3676 of file bitstring.py.

◆ uint

property uint

static

Initial value:

= property(Bits._getuint, Bits._setuint,

doc=)

Definition at line 3637 of file bitstring.py.

◆ uintbe

property uintbe

static

Initial value:

= property(Bits._getuintbe, Bits._setuintbe,

doc=)

Definition at line 3646 of file bitstring.py.

◆ uintle

property uintle

static

Initial value:

= property(Bits._getuintle, Bits._setuintle,

doc=)

Definition at line 3655 of file bitstring.py.

◆ uintne

property uintne

static

Initial value:

= property(Bits._getuintne, Bits._setuintne,

doc=)

Definition at line 3664 of file bitstring.py.

The documentation for this class was generated from the following file:

trg/scripts/bitstring.py

Public Member Functions

Protected Attributes

Properties

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __copy__()

◆ __delitem__()

◆ __iadd__()

◆ __iand__()

◆ __ilshift__()

◆ __imul__()

◆ __ior__()

◆ __irshift__()

◆ __ixor__()

◆ __new__()

◆ __setitem__()

◆ append()

◆ byteswap()

◆ clear()

◆ copy()

◆ insert()

◆ invert()

◆ overwrite()

◆ prepend()

◆ replace()

◆ reverse()

◆ rol()

◆ ror()

◆ set()

Member Data Documentation

◆ __hash__

◆ __slots__

◆ _pos

Property Documentation

◆ bin

◆ bool

◆ bytes

◆ float

◆ floatbe

◆ floatle

◆ floatne

◆ hex

◆ int

◆ intbe

◆ intle

◆ intne

◆ oct

◆ se

◆ sie

◆ ue

◆ uie

◆ uint

◆ uintbe

◆ uintle

◆ uintne

◆ init()

◆ copy()

◆ delitem()

◆ iadd()

◆ iand()

◆ ilshift()

◆ imul()

◆ ior()

◆ irshift()

◆ ixor()

◆ new()

◆ setitem()

◆ hash

◆ slots