CurrValTable.py

Go to the documentation of this file.

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

__facility__ = "Online"
__abstract__ = "Current Value Table"
__author__  = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2006/03/19 00:04:42 $").split(' ')[1]
__version__ = "$Revision: 1.8 $"
__release__  = "$Name: HEAD $"
__credits__ = "SLAC"

import LICOS.copyright_SLAC

import time
import cPickle as pickle
import struct

# encode into: name, raw, flags, age: 16byte, ulong, ushort, double : 16sLHd
CV_STRUCT_FMT = "!16sLHd"


class CurrentValueBase(object):
  """!\brief CurrentValue class
  """
  FLAG_STALE          = 0x0001
  FLAG_ALARM_RED      = 0x1000
  FLAG_ALARM_YEL      = 0x2000
  FLAG_ALARM_DISABLED = 0x8000
  
  
  def __init__(self, name=None, raw=None, flags=0x0, age=0):
    self.clear()
    self.name    = name
    self.__raw   = raw
    self.__flags = flags
    self.__age   = age
    
  def rawValue(self):
    """!\brief rawValue
    
    \return observable's  value in raw (machine) units
    """
    return self.__raw
    
  def age(self):
    """!\brief 
    """
    return self.__age
    
  def flags(self):
    """!\brief 
    """
    return self.__flags
  
  def setFlags(self, flags):
    """!\brief
    """
    self.__flags |= flags
  
  def unsetFlags(self, flags):
    """!\brief
    """
    self.__flags &= ~flags
    
  def update(self, raw, aTime):
    """!\brief 
    """
    self.__raw = raw
    self.__age = aTime
    self.__flags &= ~self.FLAG_STALE
    
  def clear(self):
    """!\brief 
    """
    self.__raw = 0
    self.__age = None
  
class CurrentValue(CurrentValueBase):
  def __init__(self):
    super(CurrentValue,self).__init__()
    self.observers = []
    
  def addObserver(self, observer):
    """!\brief 
    """
    if observer not in self.observers:
      self.observers.append(observer)
    
  def delObserver(self, observer):
    """!\brief 
    """
    if observer in self.observers:
      # log.debug( "removing observer " + str(observer) + " from value " + self.name )
      self.observers.remove(observer)
  
  def nObservers(self):
    """!\brief 
    """
    return len(self.observers)
  
  def update(self, raw, aTime):
    super(CurrentValue,self).update(raw,aTime)
    self.__post()

  def __post(self):
    """!\brief 
    """
    for obs in self.observers:
      obs.update(self)


class CurrentValueTable(object):
  POOL_SIZE = 1000
  
  def __init__(self):
    
    # internal dictionary
    self.__cvt = {}
  
    self.__cvtPool = []
    self.__allocatePool()
    self.__lastUpdate = 0
    
  def fullTable(self):
    return self.__cvt
    
  def getValue(self, mnemonic, age=None):
    """!\brief 
    """
    if mnemonic not in self.__cvt:
      return None
  
    if age != None:
      # if age == None, get most recent, 
      #   otherwise require (now - age) <= object.age
      #   otherwise block until timeout or new data is available
      now = time.time()
      if (now - self.__cvt[mnemonic].age()) <= age:
        return self.__cvt[mnemonic]
    
      pass
      
      
    return self.__cvt[mnemonic]
  
  def hasValue(self, mnemonic):
    """!\brief 
    """
    return (mnemonic in self.__cvt)
    
  def setValue(self, mnemonic, value, aTime):
    """!\brief 
    """
    #passthrough for now.  Maybe otherwise?
    if mnemonic not in self.__cvt:
      self.__cvt[mnemonic] = self.__getPoolObject()
      self.__cvt[mnemonic].name = mnemonic
    self.__cvt[mnemonic].update(value, aTime)
    self.__lastUpdate = aTime
    
  def lastUpdate(self):
    return self.__lastUpdate
    
  def clearOldValues(self, maxAge):
    """!\brief 
    """
    # if value.age > maxAge, return value to pool/
    
    now = time.time()
    
    for mnem in self.__cvt:
      if (now - self.__cvt[mnem].age()) > maxAge:
        # If there are active observers, don't do this.
        self.__cvtPool.append(self.__cvt[mnem])
        self.__cvt[mnem] = None
    
    pass
    
  def removeObserver(self, observer):
    for val in self.__cvt.values():
      val.delObserver(observer)
    
  def __getPoolObject(self):
    # return one from the pool, if there's anything in the 
    # pool.  Deal with empty pool
    
    if len(self.__cvtPool) == 0:
      self.__allocatePool()    
    return self.__cvtPool.pop()
    
  def __allocatePool(self):
    # Allocate a new block of value objects into the pool
    for i in range(CurrentValueTable.POOL_SIZE):
      self.__cvtPool.append(CurrentValue())  
    
def encodeCurrentValue(cv):
  # cv is a subclass of CurrentValueBase

  encoded = pickle.dumps( (cv.name, cv.rawValue(), cv.flags(), cv.age()), 2)
  
  return encoded

def decodeCurrentValue(decode):

  p = pickle.loads(decode)
  if p is not None:
    name, raw, flags, age = p
    cv = CurrentValueBase(name, raw, flags, age)
  else:
    print "Received null object from current value table at %s" % time.asctime()
    cv = None
  
  return cv


if __name__ == '__main__':

  pass










#eof

---