gDb.py

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


__facility__ = "Online"
__abstract__ = "GLAST functional block base class"
__author__  = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2004/09/07 21:00:29 $").split(' ')[1]
__version__ = "$Revision: 2.13 $"
__release__  = "$Name: P04-06-05 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC

import gAttr
from LATTE.client.gNode import Node

class Gdb(Node):
  """\brief Base class for all GLAST LAT functional blocks.

     Uses __getattr__ and __setattr__ methods to feature an SCL like syntax
     for referencing attributes
  """
  def __init__(self, client, parent, id, valid_attrs=[], addr=None):
    """gNode constructor.

    \param valid_regs A list of valid attribute names.
    """
    Node.__init__(self, client)
    self.__parent = parent
    self.__id = id
    if addr is None:
      self.__addr = id
    else:
      self.__addr = addr

    attrDict = _regList()
    self.__dict__['regs'] = attrDict

    #Instantiate all attributes
    for attr in valid_attrs:
      attrDict[attr.getName()] = attr.create(self)

  def up(self):
    """Return the parent of this component
    """
    return self.__parent

  def id(self):
    """Return the hardware id of this component
    """
    return self.__id

  def addr(self):
    """Return the hardware address of this component
    """
    return self.__addr

  def root(self):
    """Return the root node in this node's hierarchy

    \return The root node
    """
    root = self
    while root.up() is not None:
      root = root.up()
    return root

  def getIdTuple(self):
    """Return the node id(s) in this node's hierarchy

    \return The root node
    """
    idtuple = []
    root = self
    while root.up() is not None:
      idtuple.append(root.id())
      root = root.up()
    idtuple.reverse()
    return tuple(idtuple)
    
  def getName(self):
    return self.__class__.__name__

  def getOpaque(self, name=None):
    """\brief Retrieves the named opaque data included in the schema
    The opaque data needs to be associated with a node therefore this
    method only returns the opaque data that is associated with that
    node.

    \param  name Name of the opaque XML data (optional)

    \return      A list of XML DOM objects matching \a name
                 or if \a name is None a dictionary of a list
                 of XML DOM objects
    """
    root = self.root()
    rname = root.__class__.__name__
    rdict = root.__dict__
    opaque = rdict["_" + rname + '__opaque']
    if self in opaque:
      if name is None:
        return opaque[self]
      elif name in opaque[self]:
        return opaque[self][name]

  def getSerialNos(self, component=None):
    """\brief Retrieves the serial numbers associated with the node

    \param  component Hardware component identifier (optional)

    \return           A dictionary matching \a component
                      or if \a component is None a dictionary of all
                      components and their serial numbers
    """
    root = self.root()
    rname = root.__class__.__name__
    rdict = root.__dict__
    serialnos = rdict["_" + rname + '__serialnos']
    if self in serialnos:
      if component is None:
        return serialnos[self]
      elif component in serialnos[self]:
        return {component: serialnos[self][component]}

## private:
#
#  The following was an attempt to optimize access for mixed case attribute
#  names.  Unfortunately we run into trouble with the tem.regs['configuration']
#  type notation, and with constructs like 'for reg in regs' which returns
#  the attribute in each casing.  We punt on it for now (Thu Aug 19 2004)
#
#   def __setattr__(self, attribute, value):
#     attrDict = self.__dict__
#     if attribute in attrDict:
#       attrDict[attribute] = value
#       return
#     try:
#       regs = attrDict['regs']
#     except KeyError:
#       attrDict[attribute] = value
#       return
#     try:
#       regs[attribute].set(value, 0, self)
#     except KeyError:
#       try:
#         attr = regs[attribute.lower()]
#       except KeyError:
#         raise AttributeError("Attribute " + attribute + " not found")
#       regs[attribute] = attr
#       attr.set(value, 0, self)

#   def __getattr__(self, attribute):
#     attrDict = self.__dict__
#     if attribute in attrDict:
#       return attrDict[attribute]
#     try:
#       regs = attrDict['regs']
#       return regs[attribute].get(0, self)
#     except KeyError:
#       try:
#         attr = regs[attribute.lower()]
#       except KeyError:
#         raise AttributeError("Attribute " + attribute + " not found")
#       regs[attribute] = attr
#       return attr.get(0, self)

  def __setattr__(self, attribute, value):
    """Gets called when a syntax like 'gtem.configuration = 5' is used"""
    attrDict = self.__dict__
    try:
      regs = attrDict['regs']
      if attribute in regs:
        regs[attribute].set(value, 0, self)
      elif attribute in attrDict:
        attrDict[attribute] = value
      else:
        raise AttributeError("Attribute " + attribute + " not found")
    except KeyError:
      if 'regs' not in attrDict:
        attrDict[attribute] = value
      else:
        raise AttributeError("Attribute " + attribute + " not found")

  def __getattr__(self, attribute):
    """Gets called when a syntax like 'print gtem.configuration' is used"""
    try:
      return self.__dict__['regs'][attribute].get(0, self)
    except KeyError:
      raise AttributeError("Attribute " + attribute + " not found")

class _regList(dict):
  def __init__(self):
    dict.__init__(self)

  def __getitem__(self, attribute):
    return dict.__getitem__(self, attribute.lower())

  def __setitem__ (self, attribute, value):
    dict.__setitem__(self, attribute.lower(), value)

  def get (self, attribute, default=None):
    return dict.get(self, attribute.lower(), default)

  def has_key(self, attribute):
    return dict.has_key(self, attribute.lower())

  def __contains__(self, attribute):
    return dict.__contains__(self, attribute.lower())


class Children(dict):
  BCASTID = 0xff

  def __init__(self, parent, type):
    dict.__init__(self)
    self.__parent = parent
    self.__type = type
    self.__bcast = None

  def remove(self, id):
    if id in self:
      self.__delitem__(id)
    elif id == Children.BCASTID:
      self.__bcast = None
    else:
      print "*** gDb: id %d not found for %s %d" %(id, self.__parent.getName(), self.__parent.id())

  def add(self, id):
    if id == Children.BCASTID:
      if self.__bcast is not None:
        print "*** gDb: bcast %s already exists for %s %d" \
              %(self.__bcast.getName(),
                self.__parent.getName(), self.__parent.id())
      else:
        self.__bcast = self.__type(self.__parent.client(), self.__parent, id)
        return self.__bcast
    elif id in self:
      print "*** gDb: child %s %d already exists for %s %d" \
            %(self[id].getName(), id,
              self.__parent.getName(), self.__parent.id())
    else:
      self[id] = self.__type(self.__parent.client(), self.__parent, id)
      return self[id]

  def down(self, id):
    if id in self:
      return self[id]
    elif id == Children.BCASTID:
      return self.__bcast
    else:
      return None

  def exists(self, id):
    if id in self:
      return True
    elif id == Children.BCASTID and self.__bcast is not None:
      return True
    return False

  def all(self):
    return self.__bcast

---