gHdb.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 Housekeeping system base class"
__author__  = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/03/31 01:12:19 $").split(' ')[1]
__version__ = "$Revision: 1.8 $"
__release__  = "$Name: R04-12-00 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC

import gAttr
from LATTE.client.gNode     import Node
from LATTE.database.gDb     import _regList


class GattrHsk(gAttr.Gattr):
  """\brief Class which is instantiated for each housekeeping quantity
  """
  class __AttrHsk(object):
    """Helper class for private use in this file only.
    """
    def __init__(self, node, attr):
      self.__attr = attr
      self.__node = node

      self.__data = None

      #print id(self), id(attr), node.getName(), attr.getName(), attr.flags()
      if attr.flags() == (gAttr.ATTR_READ | gAttr.ATTR_NO_DIRECT_ACCESS):
        self.set = self.__badSet
        self.get = self.__badGet
      else:
        self.set = self.__set
        self.get = self.__get

      # Callthroughs to 'parent' class
      self.setEGU        = self.__attr.setEGU
      self.setRule       = self.__attr.setRule
      self.setConstraint = self.__attr.setConstraint
      self.getEGU        = self.__attr.getEGU
      self.getRule       = self.__attr.getRule
      self.getConstraint = self.__attr.getConstraint

      self.id               = attr.id
       
    def __set(self, val, bypass=0, node=None):
      if node is not None:
        self.__data = self.__attr.set(node, val, bypass)
      else:                             # For backward compatibility
        self.__data = self.__attr.set(self.__node, val, bypass)
      
    def __get(self, bypass=0, node=None):
      if node is not None:
        val = self.__attr.get(node, self.__data, bypass)
      else:                             # For backward compatibility
        val = self.__attr.get(self.__node, self.__data, bypass)
      return val

    def __badSet(self, node, val, bypass=0):
      return -1                         # revisit
      #raise LATInterfaceException(1)

    def __badGet(self, node, val, bypass=0):
      return -1                         # revisit
      #raise LATInterfaceException(1)

    def getNode(self):
      return self.__node

  def __init__(self, name, id,
               rule       = gAttr.Gattr.defaultRule,
               constraint = gAttr.Gattr.defaultConstraint,
               egu        = gAttr.Gattr.defaultEgu):
    """GattrHsk constructor

    \param name        The name of the attribute.
    \param id          Positional identifier.
    \param rule        Optional. Attribute rule.
    \param constraint  Optional. Attribute constraint.
    \param egu         Optional. Attribute EGU
    """
    # instantiate the Gattr.
    gAttr.Gattr.__init__( self,
                          name=name, id=id, size=0, flags=gAttr.REG_READ_WRITE,
                          rule=rule, constraint=constraint, egu=egu )
    
  def create(self, node):
    return GattrHsk.__AttrHsk(node, self)

  def set(self, node, val, bypass=True):
    """
    Method for setting the value of an attribute.
    Calls the functions in the attribute's node for setting values.

    \param val    Register value to be set
    \param bypass Optional. Flag for bypassing EGU conversion
                  Default is to *not* convert to EGU.
    """
    if bypass or val == None:
      raw = val
    else:
      (val, rejected) = self._Gattr__constraint.evaluate(val)
      if rejected:
        return None
      raw = self._Gattr__egu.raw(val)

    return raw

  def get(self, node, raw, bypass=False):
    """
    Method for getting the value of an attribute.
    If bypass=0 (the default), the value will be returned in EU.
    If bypass=1, the raw value will be returned.
    """

    if bypass or raw == None:
      return raw
    else:
      egu = self._Gattr__egu.egu(raw)
      self._Gattr__rule.evaluate(egu, self, node)
      return egu

---