gBits.py

#!/usr/local/bin/python
#
#                               Copyright 2004
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#


__facility__ = "Online"
__abstract__ = "Bit field utility methods"
__author__   = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST I&T/Online"
__date__     = ("$Date: 2004/12/09 02:08:39 $").split(' ')[1]
__version__  = "$Revision: 2.5 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

import sys
import string
import inspect
import struct

class bf(object):
  def __init__(self,value=0L):
    self._d = long(value)

  def set(self, value):
    self._d = long(value)

  def __getitem__(self, index):
    return (self._d >> index) & 1

  def __setitem__(self,index,value):
    value    = (value&1L)<<index
    mask     = 1L<<index
    self._d  = (self._d & ~mask) | value

  def __getslice__(self, start, end):
    mask = 2**(end - start) -1
    return (self._d >> start) & mask

  def __setslice__(self, start, end, value):
    mask = 2**(end - start) -1
    value = (long(value) & mask) << start
    mask = mask << start
    self._d = (self._d & ~mask) | value
    return (self._d >> start) & mask

  def getOnBits(self):
    value = self._d
    i = 0
    bits = []
    while value != 0:
      bit = value & 1L
      if bit: bits.append(i)
      value = value >> 1
      i+=1
    return bits

  def __int__(self):
    return self._d

  def __str__(self):
    return str(self._d)

class BitField(object):
  def __init__(self, ui, bf_def):
    self.bf_ui = bf(ui)
    self.bf_def = bf_def

  def set(self, ui):
    self.bf_ui.set(ui)

  def __setattr__(self, attribute, val):
    if attribute == 'ui':
      self.__dict__['bf_ui'] = bf(val)
      return
    elif attribute in ('bf_ui', 'bf_def'):
      self.__dict__[attribute] = val
      return
    else:
      for (bitField, fromBit, toBit) in self.bf_def:
        if attribute.lower() == bitField:
          self.bf_ui[fromBit:toBit] = val
          return
    self.__dict__[attribute] = val

  def __getattr__(self, attribute):
    if attribute == 'ui':
      return int(self.__dict__['bf_ui'])
    elif attribute in ('bf_ui', 'bf_def'):
      return self.__dict__[attribute]
    else:
      for (bitField, fromBit, toBit) in self.bf_def:
        if attribute == bitField:
          return self.bf_ui[fromBit:toBit]
    return self.__dict__[attribute]

  def __int__(self):
    return int(self.__dict__['bf_ui'])

  def __str__(self):
    return str(self.__dict__['bf_ui'])


def hexConvert(s, size=1, outPutStyle="0x%s "):
  """
  Convert binary string s
  to a hex format

  Keyword arguments:

  'size'        -- How large should each hex value be

  'outPutStyle' -- How should each value be formatted
  """
  res=[]
  while s:
      temp=s[:size]
      s=s[size:]
      l=[]
      for i in temp:
          l.append("%02x"%ord(i))
      val=string.join(l,'')
      res.append(outPutStyle%val)
  return string.join(res,'')

def lhex(x, size=8):
  xs = string.lower(hex(x))
  l = len(xs)
  if xs[l-1] == "l":
    xs = xs[2:l-1]
  else:
    xs = xs[2:l]
  l = len(xs)
  xs = '0'*(size-l) + xs
  return xs

def q(cond,on_true,on_false):
  if cond:
    if not inspect.isfunction(on_true):
      return on_true
    else:
      return apply(on_true)
  else:
    if not inspect.isfunction(on_false):
      return on_false
    else:
      return apply(on_false)

def dump_cells(data):
  fmt = '!%dI' %(len(data) >> 2)
  words = struct.unpack(fmt, data)
  counter = 0
  for word in words:
    if ((counter%4) == 0): print '\n  ',
    print '0x%08x' %(word),
    counter += 1
  print

def population(mask):
  n = 0
  while (mask != 0):
    n = n+1
    mask = mask & (mask-1)
  return n

---