This method should only be called when the PtoPOutputHandler was created
for a Link. It is called every time a message is sent
491750
public void updateRoutingCellule( SIBUuid8 routingME ) 
   {
     if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
       SibTr.entry(tc, "updateRoutingCellule", routingME);
     
     this.routingMEUuid = routingME;
    
     if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
       SibTr.exit(tc, "updateRoutingCellule");
  }
224023
public void notifyReceiveAllowedRCD(DestinationHandler destinationHandler)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "notifyReceiveAllowedRCD", new Object[] {destinationHandler});

    // For PtoP iterate over anycastInputHandlers
    synchronized (_anycastInputHandlers) 
    { 
      for(Iterator i=_anycastInputHandlers.keySet().iterator(); i.hasNext();) 
      { 
        String key = (String) i.next(); 
        AnycastInputHandler aih = _anycastInputHandlers.get(key); 
        if (aih != null) 
        { 
          RemoteConsumerDispatcher rcd = aih.getRCD();
          rcd.notifyReceiveAllowed(destinationHandler);
        }
      }
    }
        
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "notifyReceiveAllowedRCD");
  }
1054140
@Override
	protected void notifyHandler(ServerHandlerClass handler) {
	    Object instance = handler.newInstance();
	    assignDataToHandler(handler, instance);
	    ReflectMethodUtil.invokeHandleMethod(handler.getHandleMethod(), 
                instance, context);
	}
841938
public void notifyReceiveAllowed(boolean isAllowed, DestinationHandler destinationBeingModified)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "notifyReceiveAllowed", Boolean.valueOf(isAllowed));

    if (consumerPoint.destinationMatches(destinationBeingModified, consumerDispatcher))
    {
      consumerPoint.notifyReceiveAllowed(isAllowed);
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "notifyReceiveAllowed");
  }
985615
@Override
    protected void onWrite(@NotNull WireOut outWire) {
        SubHandler handler = handler();
        if (handler != null)
            handler.onWrite(outWire);

        WriteMarshallable w;
        for (int i = 0; i < writers.size(); i++) {
            try {
                w = writers.get(i);
                if (null == w)
                    continue;

                if (isClosing.get())
                    return;

                w.writeMarshallable(outWire);
            } catch (Exception e) {
                Jvm.fatal().on(getClass(), e);
            }
        }
    }
734470
public void prepareUpdateStep5bOutput(JspWriter out) throws IOException {

        if ((m_workplaceUpdateThread == null) || (m_workplaceUpdateThread.getLoggingThread() == null)) {
            return;
        }
        m_oldLoggingOffset = m_newLoggingOffset;
        m_newLoggingOffset = m_workplaceUpdateThread.getLoggingThread().getMessages().size();
        if (isInitialized()) {
            for (int i = m_oldLoggingOffset; i < m_newLoggingOffset; i++) {
                String str = m_workplaceUpdateThread.getLoggingThread().getMessages().get(i).toString();
                str = CmsEncoder.escapeWBlanks(str, CmsEncoder.ENCODING_UTF_8);
                out.println("output[" + (i - m_oldLoggingOffset) + "] = \"" + str + "\";");
            }
        } else {
            out.println("output[0] = 'ERROR';");
        }

        boolean threadFinished = m_workplaceUpdateThread.isFinished();
        boolean allWritten = m_oldLoggingOffset >= m_workplaceUpdateThread.getLoggingThread().getMessages().size();

        out.println("function initThread() {");
        if (isInitialized()) {
            out.print("send();");
            if (threadFinished && allWritten) {
                out.println("setTimeout('top.display.finish()', 500);");
            } else {
                int timeout = 5000;
                if (getWorkplaceUpdateThread().getLoggingThread().getMessages().size() < 20) {
                    timeout = 1000;
                }
                out.println("setTimeout('location.reload()', " + timeout + ");");
            }
        }
        out.println("}");
    }
890584
@Override
	protected void onFirstOutput() throws IOException
	{
		if(prefix != null && prefix.length() > 0)
		{
			print(prefix);
			prefix = null;	// no need to keep a ref
		}
	}
671500
@Override
  protected void onMethodEnter() {
    if (withPreconditions || withPostconditions || withInvariants) {
      enterContractedMethod();

      if (withPostconditions) {
        allocateOldValues(ContractKind.OLD, oldValueLocals);
        allocateOldValues(ContractKind.SIGNAL_OLD, signalOldValueLocals);
      }

      mark(methodStart);

      Label skip = enterBusySection();

      if (withInvariants && !statik && !isConstructor && !isStaticInit) {
        invokeInvariants();
      }

      if (withPreconditions) {
        invokePreconditions();
      }

      if (withPostconditions) {
        invokeOldValues(ContractKind.OLD, oldValueLocals);
        invokeOldValues(ContractKind.SIGNAL_OLD, signalOldValueLocals);
      }

      leaveBusySection(skip);
    }
  }
1193850
void notifyAcceptOutbind(Outbind outbind) throws IllegalStateException {
    this.lock.lock();
    try {
      if (this.request == null) {
        this.request = new OutbindRequest(outbind);
        this.requestCondition.signal();
      }
      else {
        throw new IllegalStateException("Already waiting for acceptance outbind");
      }
    }
    finally {
      this.lock.unlock();
    }
  }
596046
def stop_capture(self):
        

        self._capturing = False
        self._project.controller.notification.emit("link.updated", self.__json__())
659916
private void processHooks(Set<ExecutableElement> hookMethodsFromInterfaces) {
    ElementFilter
        .methodsIn(component.getEnclosedElements())
        .stream()
        .filter(method -> isHookMethod(component, method, hookMethodsFromInterfaces))
        // Created hook is already added by createCreatedHook
        .filter(method -> !"created".equals(method.getSimpleName().toString()))
        .forEach(method -> {
          String exposedMethodName = exposeExistingJavaMethodToJs(method);
          String methodName = method.getSimpleName().toString();
          optionsBuilder
              .addStatement("options.addHookMethod($S, p.$L)", methodName, exposedMethodName);
        });
  }
203762
@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        graphMonitor = new Graph.Monitor() {
            @Override
            public void onInject(Object target) {
                if (controller != null && target == MvcFragment.this) {
                    controller.view = MvcFragment.this;
                }
            }

            @Override
            public void onRelease(Object target) {
            }
        };
        Mvc.graph().registerMonitor(graphMonitor);

        eventRegister = new EventRegister(this);

        if (savedInstanceState == null) {
            lastOrientation = getResources().getConfiguration().orientation;
        } else {
            lastOrientation = savedInstanceState.getInt(STATE_LAST_ORIENTATION);
        }

        if (getParentFragment() == null) {
            setRetainInstance(true);
        }

        injectDependencies();
    }
840557
public void methodErrorHook(String hookedClassQualifiedName,
            String hookedMethodSimpleName, Throwable e) {
        if (currentRunResult == null) {
            return; // maybe called outside of the root method
        }
        TestMethod rootMethod = currentRunResult.getRootMethod();
        if (!rootMethod.getTestClassKey().equals(hookedClassQualifiedName)
                || !rootMethod.getSimpleName().equals(hookedMethodSimpleName)) {
            return; // hooked method is not current root method
        }

        RunFailure runFailure = new RunFailure();
        runFailure.setMessage(e.getClass().getCanonicalName() + ": " + e.getLocalizedMessage());
        runFailure.setStackTrace(ExceptionUtils.getStackTrace(e));
        LineReplacer replacer = new LineReplacer() {

            @Override
            public void replace(String classQualifiedName, String methodSimpleName, int line) {
                super.replace(classQualifiedName, methodSimpleName, line);
                if (StringUtils.equals(methodSimpleName, currentActualRootMethodSimpleName)) {
                    replaceMethodSimpleName(currentRunResult.getRootMethod().getSimpleName());
                }
            }
        };
        List<StackLine> stackLines = StackLineUtils.getStackLines(srcTree, e.getStackTrace(), replacer);
        for (StackLine stackLine : stackLines) {
            runFailure.addStackLine(stackLine);
        }
        currentRunResult.addRunFailure(runFailure);

        captureScreenForStackLines(rootMethod, Arrays.asList(stackLines), Arrays.asList(-1));
    }
844690
public void createControlAdapter()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(this, tc, "createControlAdapter");

    if(type == Type.SOURCE)
      controlAdapter = new SourceStreamSetControl(remoteMEUuid, this);  
    else if (type == Type.LINK_SOURCE)
        controlAdapter = new LinkTransmitterControl(remoteMEUuid, this, true);
    else if (type == Type.LINK_REMOTE_SOURCE)
      controlAdapter = new LinkTransmitterControl(remoteMEUuid, this, false);
    else if(type == Type.TARGET)
      controlAdapter = new TargetStreamSetControl(this);
    else if (type == Type.LINK_TARGET)
      controlAdapter = new LinkReceiverControl(this, linkTarget);
    else if(type == Type.INTERNAL_OUTPUT)
      controlAdapter = new InternalOutputStreamSetControl(this);
    else if(type == Type.LINK_INTERNAL_OUTPUT)
      controlAdapter = new LinkPublicationPointControl(this);
    else if(type == Type.INTERNAL_INPUT)
    {
      // Nothing to do for an InternalInputStream set, we don't display those
    }
      
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "createControlAdapter");
  }
138279
@Override
    public void notifyHandlableAdded(Featurable featurable)
    {
        if (featurable.hasFeature(Displayable.class))
        {
            final Displayable displayable = featurable.getFeature(Displayable.class);
            final Integer layer = getLayer(featurable);
            final Collection<Displayable> displayables = getLayer(layer);
            displayables.add(displayable);
            indexs.add(layer);
        }
    }
528969
public void notifyRCDReceiveExclusiveChange(boolean isReceiveExclusive)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "notifyRCDReceiveExclusiveChange", new Object[] {Boolean.valueOf(isReceiveExclusive)});

    // Only do this for ptp as it does not seem to make sense for p/s
    synchronized (_anycastInputHandlers) 
    { 
      for(Iterator i=_anycastInputHandlers.keySet().iterator(); i.hasNext();) 
      { 
        AnycastInputHandler aih = _anycastInputHandlers.get(i.next()); 
        if (aih != null) 
        { 
          RemoteConsumerDispatcher rcd = aih.getRCD();

          rcd.notifyReceiveExclusiveChange(isReceiveExclusive);
        }
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "notifyRCDReceiveExclusiveChange");
  }
173410
private void handleTextWebSocketFrameInternal(TextWebSocketFrame frame, ChannelHandlerContext ctx) {
		if (logger.isTraceEnabled()) {
			logger.trace(String.format("%s received %s", ctx.channel(), frame.text()));
		}

		addTraceForFrame(frame, "text");
		ctx.channel().write(new TextWebSocketFrame("Echo: " + frame.text()));
	}