Пример #1
0
  /*
   * (non-Javadoc)
   * @see com.isencia.passerelle.actor.Transformer#doFire(com.isencia.passerelle. message.ManagedMessage)
   */
  @Override
  protected void doFire() throws ProcessingException {

    double input1 = 0;
    final Token token = firstOperandHandler.getToken();
    if (token != null && token != Token.NIL) {
      input1 = getDoubleFromMessage(token);
      double input2 = 1.0;
      if (_function == _MODULO) {
        if (secondOperand != null) {
          final Token tokenSec = secondOperandHandler.getToken();
          if (tokenSec != null && token != Token.NIL) {
            input2 = getDoubleFromMessage(tokenSec);
          }
        }
      }
      final ManagedMessage resultMsg = createMessage();
      try {
        resultMsg.setBodyContent(
            new Double(_doFunction(input1, input2)), ManagedMessage.objectContentType);
        output.broadcast(new ObjectToken(resultMsg));
      } catch (final MessageException e) {
        ExceptionUtil.throwProcessingException("Cannot send result to output", output, e);
      } catch (final IllegalActionException e) {
        ExceptionUtil.throwProcessingException("Cannot send result to output", output, e);
      }
    } else {
      requestFinish();
    }
  }
Пример #2
0
 /*
  * (non-Javadoc)
  * @see com.isencia.passerelle.actor.Actor#doInitialize()
  */
 @Override
 protected void doInitialize() throws InitializationException {
   // TODO Auto-generated method stub
   super.doInitialize();
   firstOperandHandler = new PortHandler(firstOperand);
   if (firstOperand.getWidth() > 0) {
     firstOperandHandler.start();
   }
   if (secondOperand != null) {
     secondOperandHandler = new PortHandler(secondOperand);
     if (secondOperand.getWidth() > 0) {
       secondOperandHandler.start();
     }
   }
 }
Пример #3
0
  @Override
  @SuppressWarnings("unchecked")
  protected void doInitialize() throws InitializationException {
    getLogger().trace("{} - doInitialize() - entry", getFullName());
    super.doInitialize();

    blockingInputHandlers.clear();
    blockingInputFinishRequests.clear();

    iterationCount = 0;
    currentProcessRequest = new ProcessRequest();
    currentProcessRequest.setIterationCount(++iterationCount);
    currentProcessResponse = null;

    List<Port> inputPortList = this.inputPortList();
    for (Port _p : inputPortList) {
      if (_p.isInput() && !(_p instanceof ControlPort)) {
        if (_p.isBlocking()) {
          blockingInputHandlers.add(createPortHandler(_p));
          blockingInputFinishRequests.put(_p, Boolean.FALSE);
        }
        isSource = false;
      }
    }
    for (int i = 0; i < blockingInputHandlers.size(); ++i) {
      PortHandler h = blockingInputHandlers.get(i);
      if (h.getWidth() > 0) {
        blockingInputFinishRequests.put(h.getPort(), Boolean.FALSE);
        h.start();
      } else {
        blockingInputFinishRequests.put(h.getPort(), Boolean.TRUE);
      }
    }

    try {
      triggerFirstIteration();
    } catch (IllegalActionException e) {
      throw new InitializationException(
          ErrorCode.FLOW_EXECUTION_FATAL,
          "Error triggering a fire iteration for source actor " + getFullName(),
          this,
          e);
    }

    getLogger().trace("{} - doInitialize() - exit", getFullName());
  }
Пример #4
0
 protected void doInitialize() throws InitializationException {
   super.doInitialize();
   // If something connected to the reset port, install a handler
   if (reset.getWidth() > 0) {
     resetHandler =
         createPortHandler(
             reset,
             new PortListenerAdapter() {
               public void tokenReceived() {
                 Token token = resetHandler.getToken();
                 if (token != null && !token.isNil()) {
                   getLogger().debug("{} Reset Event received", getFullName());
                   isReset = true;
                 }
               }
             });
     resetHandler.start();
   }
   setValue(getStartValue());
 }
Пример #5
0
 @Override
 protected boolean doPreFire() throws ProcessingException {
   getLogger().trace("{} - doPreFire() - entry  ", getFullName());
   boolean readyToFire = super.doPreFire();
   if (readyToFire && !isSource) {
     // first read from all blocking inputs
     for (int i = 0; i < blockingInputHandlers.size(); i++) {
       PortHandler handler = blockingInputHandlers.get(i);
       Port _p = (Port) handler.getPort();
       ManagedMessage msg = null;
       // If a port is exhausted, we just pass a null msg to the request.
       // If not, we try to read another msg from it.
       // A null msg indicates that the port is exhausted.
       if (!blockingInputFinishRequests.get(_p).booleanValue()) {
         // For the moment, we only read at most one msg per PULL input port.
         // Remark that for an event-driven domain, it is possible that preFire()
         // is invoked repetitively before a fire() is possible.
         // Msg streams should be handled via PUSH ports.
         if (currentProcessRequest.getMessage(_p) == null) {
           boolean portHasMsg = false;
           boolean portExhausted = false;
           try {
             Token token = handler.getToken();
             portHasMsg = (token != null) && (token != Token.NIL);
             portExhausted = (token == null);
             if (portHasMsg) {
               msg = MessageHelper.getMessageFromToken(token);
               currentProcessRequest.addInputMessage(0, _p.getName(), msg);
             } else {
               // all blocking/PULL ports must have received a message before we can fire
               readyToFire = false;
             }
           } catch (ProcessingException e) {
             throw e;
           } catch (PasserelleException e) {
             throw new ProcessingException(
                 ErrorCode.FLOW_EXECUTION_ERROR, "Error getting message from input", _p, e);
           }
           if (portExhausted) {
             blockingInputFinishRequests.put(handler.getPort(), Boolean.TRUE);
             getLogger()
                 .debug(
                     "{} - doPreFire() - found exhausted port {} ",
                     getFullName(),
                     handler.getName());
           } else if (msg != null) {
             if (getLogger().isDebugEnabled())
               getLogger()
                   .debug(
                       "{} - doPreFire() - message {} received on port {}",
                       new Object[] {getFullName(), msg.getID(), handler.getName()});
           }
         }
       }
     }
     if (readyToFire && (!getMessageQueue().isEmpty() || !msgProviders.isEmpty())) {
       try {
         // TODO check if it's not nicer to maintain buffer time from 1st preFire() call
         // to when readyToFire, i.o. adding it after the time we've already been waiting
         // for all PULL ports having a message.
         int bufferTime = ((IntToken) bufferTimeParameter.getToken()).intValue();
         if (bufferTime > 0) {
           getLogger()
               .debug("{} - doPreFire() - sleeping for buffer time {}", getFullName(), bufferTime);
           Thread.sleep(bufferTime);
         }
       } catch (Exception e) {
         getLogger().warn(getFullName() + " - Failed to enforce buffer time", e);
       }
       // we've got at least one PUSH port that registered a msg provider
       // so we need to include all pushed msgs in the request as well
       addPushedMessages(currentProcessRequest);
     }
     readyToFire = readyToFire && currentProcessRequest.hasSomethingToProcess();
     // when all ports are exhausted, we can stop this actor
     if (!readyToFire
         && !getDirectorAdapter().isActorBusy(this)
         && areAllInputsFinished()
         && getMessageQueue().isEmpty()) {
       requestFinish();
       readyToFire = true;
     }
   }
   getLogger().trace("{} - doPreFire() - exit : {}", getFullName(), readyToFire);
   return readyToFire;
 }