Returns the send listener (if any) of this transmission.
@return Returns the send listener (if any) of this transmission.
778249
protected SendListener getSendListener()
   {
      if (tc.isEntryEnabled()) SibTr.entry(this, tc, "getSendListener");
      if (tc.isEntryEnabled()) SibTr.exit(this, tc, "getSendListener", sendListener);
      return sendListener;
   }
92036
@Override
    public String getListeningHost(String chainName) throws ChainException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "getListeningHost: " + chainName);
        }

        String listeningHost = null;
        // Search the runtime chain list for the specified chain.
        Chain chain = this.chainRunningMap.get(chainName);
        if (chain != null) {
            ChainData chainData = chain.getChainData();
            if (chainData.getType().equals(FlowType.INBOUND)) {
                // Extract the first channel in the chain. The device side channel.
                ChannelData channelData = chainData.getChannelList()[0];
                Map<Object, Object> channelProperties = channelData.getPropertyBag();
                if (channelProperties != null) {
                    // Extract the host string from the chain properties.
                    listeningHost = (String) channelProperties.get(ChannelFrameworkConstants.HOST_NAME);
                    if (listeningHost == null) {
                        throw new ChainException("Chain " + chainName + " has no host in the device channel properties.");
                    }
                } else {
                    throw new ChainException("Chain " + chainName + " has no properties.");
                }
            } else {
                throw new ChainException("Chain " + chainName + " is not inbound.");
            }
        } else {
            throw new ChainException("Chain " + chainName + " not found in runtime.");
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "getListeningHost: " + listeningHost);
        }
        return listeningHost;
    }
101693
Collection<T> getAllListeners() {
        final Collection<T> toReturn = new ArrayList<>();
        for (ListenerHolder<T> listener : listeners) {
            toReturn.add(listener.delegate);
        }
        return toReturn;
    }
1170347
public final AbstractOutput[] getListener() {
        final AbstractOutput[] returnVal = new AbstractOutput[listeners.length];
        System.arraycopy(listeners, 0, returnVal, 0, returnVal.length);
        return returnVal;
    }
1213185
public MessagelistenerType<MessageadapterType<T>> getOrCreateMessagelistener()
   {
      List<Node> nodeList = childNode.get("messagelistener");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new MessagelistenerTypeImpl<MessageadapterType<T>>(this, "messagelistener", childNode, nodeList.get(0));
      }
      return createMessagelistener();
   }
1366706
public List<RegistryListener<K, V>> getListeners() {
        return new LinkedList<RegistryListener<K, V>>(listeners);
    }
1190616
public synchronized Iterator receiveListenerIterator()
	{
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "receiveListenerIterator");
		
      final LinkedList<ReceiveListener>linkedList = new LinkedList<ReceiveListener>();
		final Iterator iterator = table.values().iterator();

		while(iterator.hasNext())
		{
			final RequestIdTableEntry tableEntry = (RequestIdTableEntry)iterator.next();
         if (tableEntry.receiveListener != null) linkedList.add(tableEntry.receiveListener);
		}

      final Iterator result = linkedList.iterator();
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "receiveListenerIterator", result);   	
		return result;
	}
776590
public final ErrorListener getErrorListener()
  {

    if (null != m_errorListener)
        return m_errorListener;

    ErrorListener retval = null;

    try {
      if (null != m_ownerGetErrorListener)
        retval = (ErrorListener) m_ownerGetErrorListener.invoke(m_owner, new Object[] {});
    }
    catch (Exception e) {}

    if (null == retval)
    {
      if (null == m_defaultErrorListener) 
        m_defaultErrorListener = new org.apache.xml.utils.DefaultErrorHandler();
      retval = m_defaultErrorListener;
    }

    return retval;
  }
331162
public synchronized boolean sendError(Throwable cause) {
		if (cause == null) {
			throw new IllegalArgumentException("Unable to send \"null\" as Exception!");
		}
		if (closed.compareAndSet(false, true)) {
			this.cause = cause;
			if (listeners != null) {
				try {
					if (listeners.length == 1) {
						listeners[0].onPacket(null, cause, true);
					} else {
						for (PacketListener listener : listeners) {
							listener.onPacket(null, cause, true);
						}
					}
				} catch (MoleculerError moleculerError) {
					throw moleculerError;
				} catch (Throwable error) {
					throw new MoleculerClientError("Unable to send error to stream listener!", error, nodeID, null);
				}
			}
			return true;
		}
		return false;
	}
956485
private static CopyStreamListener createListener() {
        return new CopyStreamListener() {
            private long megsTotal = 0;

            // @Override
            @Override
            public void bytesTransferred(CopyStreamEvent event) {
                bytesTransferred(event.getTotalBytesTransferred(), event.getBytesTransferred(), event.getStreamSize());
            }

            // @Override
            @Override
            public void bytesTransferred(long totalBytesTransferred, int bytesTransferred, long streamSize) {
                long megs = totalBytesTransferred / 1000000;
                for (long l = megsTotal; l < megs; l++) {
                    System.err.print("#");
                }
                megsTotal = megs;
            }
        };
    }
676345
public BaseListener getNextEnabledListener()
    {
        if (m_listener != null)
        {
            if (m_listener.isEnabled())
                return m_listener;
            else
                return m_listener.getNextEnabledListener();
        }
        else
            return null;
    }
949068
def receive(self):
        '''
        
        '''
        try:
            msg, addr = self.skt.recvfrom(self.buffer_size)
        except socket.error as error:
            log.error('Received listener socket error: %s', error, exc_info=True)
            raise ListenerException(error)
        log.debug('[%s] Received %s from %s', msg, addr, time.time())
        return msg, addr[0]
38277
@Override
    public Layer setListening(final boolean listening)
    {
        super.setListening(listening);

        if (listening)
        {
            if (isShowSelectionLayer())
            {
                if (null != getSelectionLayer())
                {
                    doShowSelectionLayer(true);
                }
            }
        }
        else
        {
            if (isShowSelectionLayer())
            {
                doShowSelectionLayer(false);
            }
            m_select = null;
        }
        return this;
    }
785477
public synchronized SendListener getSendListener(int requestId)
   {
		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getSendListener", ""+requestId);
		
      if (!containsId(requestId))
      {
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) debugTraceTable("id ("+requestId+") not in table");
         throw new SIErrorException(nls.getFormattedMessage("REQIDTABLE_INTERNAL_SICJ0058", null, "REQIDTABLE_INTERNAL_SICJ0058")); // D226223
      }

      testReqIdTableEntry.requestId = requestId;
      RequestIdTableEntry entry = table.get(testReqIdTableEntry);

		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getSendListener", entry.sendListener);
      return entry.sendListener;
   }
1236509
public ListenerType<WebAppDescriptor> getOrCreateListener()
   {
      List<Node> nodeList = model.get("listener");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ListenerTypeImpl<WebAppDescriptor>(this, "listener", model, nodeList.get(0));
      }
      return createListener();
   }
1084516
public static OutboxAmp getOutboxCurrent()
  {
    OutboxAmp outbox = OutboxAmp.current();
    
    if (outbox != null) {
      // OutboxAmp outbox = (OutboxAmp) outboxDeliver;
    
      return outbox;
    }
    else {
      return OutboxAmpNull.NULL;
    }
  }
1120744
public Object getListener(Class<?> listenerClass) {
    Object listener = listeners.get(listenerClass);
    if (listener == null) {
      listener = loadListener(listenerClass);
    }
    return listener;
  }