Returns the accept listener associated with this listener port.

@see ListenerPort#getAcceptListener()
482924
public AcceptListener getAcceptListener() {
        if (tc.isEntryEnabled())
            SibTr.entry(this, tc, "getAcceptListener");
        if (tc.isEntryEnabled())
            SibTr.exit(this, tc, "getAcceptListener", acceptListener);
        return acceptListener;
    }
1043805
@Override
  public void onAccept()
  {
    if (_request != null) {
      System.out.println("OLD_REQUEST: " + _request);
    }
    
    _sequenceClose.set(-1);
    /*
    _request = protocol().newRequest(this);
    _request.onAccept();
    */
  }
266413
@Override
    public boolean contextListenerStart() {
		boolean ok = super.contextListenerStart();
		//the web listeners couldn't be started so we don't even try to load the sip ones
		if(!ok) {
			return ok;
		}

		if (logger.isDebugEnabled())
            logger.debug("Configuring sip listeners");

        // Instantiate the required listeners
        ClassLoader loader = getLoader().getClassLoader();
        ok = sipListeners.loadListeners(findSipApplicationListeners(), loader);
        if(!ok) {
			return ok;
		}

        List<ServletContextListener> servletContextListeners = sipListeners.getServletContextListeners();
        if (servletContextListeners != null) {
            ServletContextEvent event =
                new ServletContextEvent(getServletContext());
            for (ServletContextListener servletContextListener : servletContextListeners) {
                if (servletContextListener == null)
                    continue;

                try {
                    fireContainerEvent("beforeContextInitialized", servletContextListener);
                    servletContextListener.contextInitialized(event);
                    fireContainerEvent("afterContextInitialized", servletContextListener);
                } catch (Throwable t) {
                    fireContainerEvent("afterContextInitialized", servletContextListener);
//                    getLogger().error
//                        (sm.getString("standardContext.listenerStart",
//                        		servletContextListener.getClass().getName()), t);
                    getLogger().error
                    	(MESSAGES.errorSendingContextInitializedEvent(servletContextListener.getClass().getName()), t);
                    ok = false;
                }

                // TODO Annotation processing
            }
        }

        return (ok);

    }
485412
public static <T extends RunListener> Optional<T> getAttachedListener(Class<T> listenerType) {
        return Run.getAttachedListener(listenerType);
    }
562338
@Override
    public int checkAbleToAcceptMessage(JsDestinationAddress addr)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "checkAbleToAcceptMessage", addr);

        int blockingReason = DestinationHandler.OUTPUT_HANDLER_FOUND;
        //we check the remoteQueueHighLimit in this case. 
        //See defect 281311
        boolean canAccept = !_itemStream.isRemoteQueueHighLimit();

        if (!canAccept)
        {
            blockingReason = DestinationHandler.OUTPUT_HANDLER_ALL_HIGH_LIMIT;
            //117505
            long destHighMsg = _itemStream.getDestHighMsgs();
            SibTr.info(tc, "NOTIFY_DEPTH_THRESHOLD_REACHED_CWSIP0553",
                       new Object[] { _destination.getName(), _messageProcessor.getMessagingEngineName(), destHighMsg });
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "checkAbleToAcceptMessage", Integer.valueOf(blockingReason));
        return blockingReason;
    }
518816
private void doAccept() throws IOException{
      Socket s;
      long startTime = System.currentTimeMillis();

      while(true){
         s = ss.accept();
         if(s.getInetAddress().equals(msg.ip)){
            //got the connection from the right host
            //Close listenning socket.
            ss.close();
            break;
         }else if(ss instanceof SocksServerSocket){
            //We can't accept more then one connection
            s.close();
            ss.close();
            throw new SocksException(Proxy.SOCKS_FAILURE);
         }else{
            if(acceptTimeout!=0){ //If timeout is not infinit
               int newTimeout = acceptTimeout-(int)(System.currentTimeMillis()-
                                                           startTime);
               if(newTimeout <= 0) throw new InterruptedIOException(
                                "In doAccept()");
               ss.setSoTimeout(newTimeout);
            }
            s.close(); //Drop all connections from other hosts
         }
      }

      //Accepted connection
      remote_sock = s;
      remote_in = s.getInputStream();
      remote_out = s.getOutputStream();

      //Set timeout
      remote_sock.setSoTimeout(iddleTimeout);

      log("Accepted from "+s.getInetAddress()+":"+s.getPort());

      ProxyMessage response;

      if(msg.version == 5)
         response = new Socks5Message(Proxy.SOCKS_SUCCESS, s.getInetAddress(),
                                                           s.getPort());
      else
         response = new Socks4Message(Socks4Message.REPLY_OK,
                                      s.getInetAddress(), s.getPort());
      response.write(out);
   }
404373
public ListenerContainer<NodeCacheListener> getListenable()
    {
        Preconditions.checkState(state.get() != State.CLOSED, "Closed");

        return listeners;
    }
878984
public java.lang.String getAccept() {
        return (java.lang.String) getStateHelper().eval(PropertyKeys.accept);

    }
1109521
private void doBind() throws Exception {
        LOG.debug("Creating listener socket");
        try {
            m_selector = Selector.open();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        ServerSocketChannel listenerSocket = ServerSocketChannel.open();
        InetSocketAddress inetsockaddr;
        if ((m_internalInterface == null) || (m_internalInterface.length() == 0)) {
            inetsockaddr = new InetSocketAddress(m_internalPort);
        }
        else {
            inetsockaddr = new InetSocketAddress(m_internalInterface, m_internalPort);
        }
        try {
            hostLog.info("Attempting to bind to internal ip " + inetsockaddr);
            listenerSocket.socket().bind(inetsockaddr);
            listenerSocket.configureBlocking(false);
            m_listenerSockets.add(listenerSocket);
        } catch (Exception e) {
            /*
             * If we bound to the leader address, the internal interface address  might not
             * bind if it is all interfaces
             */
            if (m_listenerSockets.isEmpty()) {
                LOG.fatal("Failed to bind to " + inetsockaddr);
                CoreUtils.printPortsInUse(hostLog);
                throw e;
            }
        }

        for (ServerSocketChannel ssc : m_listenerSockets) {
            ssc.register(m_selector, SelectionKey.OP_ACCEPT);
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Non-Primary Listening on:" + inetsockaddr.toString());
        }
    }
1213122
public boolean bind ()
    {
        // open our TCP listening ports
        int successes = 0;
        for (int port : _ports) {
            try {
                acceptConnections(port);
                successes++;
            } catch (IOException ioe) {
                log.warning("Failure listening to socket", "hostname", _bindHostname,
                            "port", port, ioe);
            }
        }
        return successes > 0;
    }
1255098
public View.OnClickListener getOnClickListener(boolean adapterHasListener) {
        if (isClickable() && adapterHasListener) {
            if (mViewHolderClickListener == null) {
                mViewHolderClickListener = new ViewHolderClickListener<>(this);
            }
        } else {
            mViewHolderClickListener = null;
        }
        return mViewHolderClickListener;
    }
1153329
public ListenerType<WebFragmentType<T>> getOrCreateListener()
   {
      List<Node> nodeList = childNode.get("listener");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ListenerTypeImpl<WebFragmentType<T>>(this, "listener", childNode, nodeList.get(0));
      }
      return createListener();
   }
347272
public boolean accept(XVisitor visitor) {
		/*
		 * Check whether the visitor may run.
		 */
		if (visitor.precondition()) {
			/*
			 * Yes, it may. Now initialize.
			 */
			visitor.init(this);
			/*
			 * First call.
			 */
			visitor.visitLogPre(this);
			/*
			 * Visit the extensions.
			 */
			for (XExtension extension: extensions) {
				extension.accept(visitor, this);
			}
			/*
			 * Visit the classifiers.
			 */
			for (XEventClassifier classifier: classifiers) {
				classifier.accept(visitor, this);
			}
			/*
			 * Visit the attributes.
			 */
			for (XAttribute attribute: attributes.values()) {
				attribute.accept(visitor, this);
			}
			/*
			 * Visit the traces.
			 */
			for (XTrace trace: this) {
				trace.accept(visitor, this);
			}
			/*
			 * Last call.
			 */
			visitor.visitLogPost(this);
			return true;
		}
		return false;
	}
156757
public List<SystemEventListener> getListenersForEventClass(Class<? extends SystemEvent> facesEventClass) {

        if (null == listener) {
            List<SystemEventListener> list = new ArrayList<SystemEventListener>(1);
            list.add(context.getExceptionHandler());
            listener = Collections.unmodifiableList(list);
        }
        return listener;

    }
1214235
@Override
	public <P, E extends Exception> void accept(ComponentVisitor<P, E> visitor, P parameter) throws E
	{
		visitor.visit(this, parameter);
		
		for (Component component : components)
		{
			component.accept(visitor, parameter);
		}
		
		visitor.endVisit(this, parameter);
	}
356312
public java.lang.String getAcceptcharset() {
        return (java.lang.String) getStateHelper().eval(PropertyKeys.acceptcharset);

    }
1170347
public final AbstractOutput[] getListener() {
        final AbstractOutput[] returnVal = new AbstractOutput[listeners.length];
        System.arraycopy(listeners, 0, returnVal, 0, returnVal.length);
        return returnVal;
    }