class GenericDevice(Nameable):
    cls=[   "ch.psi.pshell.device.GenericDevice", \
            "ch.psi.utils.Observable", \
            "ch.psi.pshell.device.Timestamped", \
            "java.lang.AutoCloseable", \
            "ch.psi.utils.Configurable", \
            "ch.psi.pshell.device.Record" ]
  
    def __init__(self, name=None, cls=GenericDevice.cls):
         Nameable.__init__(self, name, cls)
         self.simulated=False
         self.state=State.Ready
         self.monitored=False
         self.polling=None 
         self.cache=None
         self.age=None


    def addListener(self, listener):
        pass

    def getListeners(self):
        pass

    def removeListener(self, listener):
        pass

    def removeAllListeners(self):
        pass

    def getTimestamp(self): 
        return 0

    def getTimestampNanos(self):    
        return 0

    def getConfig(self):
        return None

    def getState(self):
        return State.Ready

    def waitState(self, state, timeout):
        return 

    def waitStateNot(self, state, timeout):
        pass
    
    def initialize(self):
        pass

    def isInitialized(self):
        return True
    
    def waitInitialized(self, timeout):
        pass

    def setSimulated(self):
        self.simulated = True
        
    def isSimulated(self):
        return self.simulated

    def isMonitored(self):
        return self.monitored
        
    def setMonitored(self,monitored):
        self.monitored=self.monitored

    def setPolling(self, interval):
        self.polling=interval

    def getPolling(self):
       return self.polling

    def isPollingBackground(self):
        return self.polling and self.polling>0
        
    def setAccessType(self, mode):    
        pass

    def getAccessType(self):
        return None

    def take(self):
        return self.cache

    def getAge(self):
        return self.age

    def request(self):
        self.update()

    def update(self):
        pass
    
    def setWaitSleep(self,  value):
        pass
    
    def getWaitSleep(self):
        return 5

    def  isPolled(self):
        return self.getPolling() > 0

    def takeAsNumber(self):
        cache = take();
        try:
            return float(cache)
        except:
            return None

    def close(self):
        pass
          
class Device(GenericDevice):
    cls="ch.psi.pshell.device.Device"
  
    def __init__(self, name=None):
         GenericDevice.__init__(self, name, [Device.cls] + GenericDevice.cls)

    def isReady():
        return getState()==State.Ready
    
    def waitReady(self, timeout):
        return
    
    def waitValue(self, value, timeout):
        return

    def waitValueNot(self, value, timeout):
        return
    
    def waitValueChange(self,timeout):
        return false
    
    def waitCacheChange(self,timeout):
        return false

    def getComponents(self):
        return None

    def getComponent(self, name):
        return None

    def getChildren(self):
        return None

    def getChild(self, name):
        return None

    def getParent(self):
        return None

    def setTriggers(self,triggers):
        pass

    def getTriggers(self):
        return None

    def takeTimestamped(self,):
        return None

    def isChild(self, device):
        return False
    
         

dev= Device("test")
add_device(dev, True)