Create a doc notification in the doc stream service.

@param name  The name of notification.
@param endpoint The address to receive notification message.
177684
public CreateNotificationResponse createNotification(String name, String endpoint) {
        CreateNotificationRequest request = new CreateNotificationRequest();
        request.withName(name).withEndpoint(endpoint);
        return createNotification(request);
    }
1232091
function ApiClient(endpoint) {
    if (endpoint.length > 0 && endpoint.slice(-1) != "/") {
        endpoint += "/";
    }
    
    this.endpoint = endpoint;
    this.namespace = null;
}
727271
public static SOAPMessage send(String endpoint, SOAPMessage data) throws SOAPException{
        SOAPConnection soapConnection = null;
        try{
            SOAPConnectionFactory soapConnectionFactory = SOAPConnectionFactory.newInstance();
            soapConnection = soapConnectionFactory.createConnection();

            SOAPMessage soapResponse = soapConnection.call(data, endpoint);

            if(LOG.isTraceEnabled()){
                LOG.trace("Sending soap to endpoint succeed\n" +
                        "                Endpoint: "+endpoint+"\n" +
                        "                SOAP: \n"+(data!=null?SOAPHelper.toString(data):null)+"\n" +
                        "                SOAP Response: \n"+(soapResponse!=null?SOAPHelper.toString(soapResponse):null));
            }else if(LOG.isDebugEnabled()){
                LOG.trace("Sending soap to endpoint succeed\n" +
                        "                        Endpoint: "+endpoint);
            }

            return soapResponse;
        } catch (SOAPException e) {
            if(LOG.isTraceEnabled()){
                LOG.trace("Sending soap to endpoint error: "+e.getClass().getName()+": "+e.getMessage()+"\n" +
                        "                Endpoint: "+endpoint+"\n" +
                        "                SOAP: \n"+(data!=null?SOAPHelper.toString(data):null)+"",e);
            }else if(LOG.isDebugEnabled()){
                LOG.debug("Sending soap to endpoint error: "+e.getClass().getName()+": "+e.getMessage()+"\n" +
                        "                Endpoint: "+endpoint,e);
            }
            throw e;
        } finally {
            try{
                if(soapConnection!=null)
                    soapConnection.close();
            }catch (Throwable e){}
        }
    }
1190477
public void registerEndpoint(RegisterEndpointRequest arg0) {
        String endpointURL = arg0.getEndpointURL();
        QName serviceName = QName.valueOf(arg0.getServiceName());
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("Registering endpoint " + endpointURL + " for service "
                    + serviceName + "...");
        }
        try {
            initLocator();
            BindingType bindingType = arg0.getBinding() == null ? BindingType.OTHER : BindingType
                    .valueOf(arg0.getBinding().value());
            TransportType transportType = arg0.getTransport() == null ? TransportType.OTHER
                    : TransportType.valueOf(arg0.getTransport().value());
            SLPropertiesImpl slProps = null;
            if (!arg0.getEntryType().isEmpty()) {
                slProps = new SLPropertiesImpl();
                List<EntryType> entries = arg0.getEntryType();
                for (EntryType entry : entries) {
                    slProps.addProperty(entry.getKey(), entry.getValue());
                }
            }
            Endpoint simpleEndpoint =
                new SimpleEndpoint(serviceName, endpointURL, bindingType, transportType, slProps);
            locatorClient.register(simpleEndpoint, true);
        } catch (ServiceLocatorException e) {
            // throw new ServiceLocatorFault(e.getMessage(), e);
            throw new WebApplicationException(Response
                    .status(Status.INTERNAL_SERVER_ERROR)
                    .entity(e.getMessage()).build());
        } catch (InterruptedException e) {
            // throw new InterruptedExceptionFault(e.getMessage(), e);
            throw new WebApplicationException(Response
                    .status(Status.INTERNAL_SERVER_ERROR)
                    .entity(e.getMessage()).build());
        }
    }
1050842
public function endpoint($method, $uri, $name)
    {
        return $this->endpoints->add(new Endpoint($method, $uri), $name);
    }
774889
private EndpointActivationServiceInfo createEndpointActivationServiceInfo(String id) {
        EndpointActivationServiceInfo easInfo = endpointActivationServices.get(id);
        if (easInfo == null) {
            easInfo = new EndpointActivationServiceInfo(id);
            endpointActivationServices.put(id, easInfo);
        }
        return easInfo;
    }
926583
private void serializeEPR(EndpointReferenceType wsAddr, Node parent) throws ServiceLocatorException {
        try {
            JAXBElement<EndpointReferenceType> ep =
                WSA_OBJECT_FACTORY.createEndpointReference(wsAddr);
            createMarshaller().marshal(ep, parent);
        } catch (JAXBException e) {
            if (LOG.isLoggable(Level.SEVERE)) {
                LOG.log(Level.SEVERE,
                        "Failed to serialize endpoint data", e);
            }
            throw new ServiceLocatorException("Failed to serialize endpoint data", e);
        }
    }
883501
public void setEndpoints(java.util.Collection<Endpoint> endpoints) {
        if (endpoints == null) {
            this.endpoints = null;
            return;
        }

        this.endpoints = new java.util.ArrayList<Endpoint>(endpoints);
    }
66552
static void buildEjbWebServiceEndpointInfos(EndpointInfoBuilder endpointInfoBuilder, EndpointInfoBuilderContext ctx, JaxWsServerMetaData jaxWsServerMetaData,
                                                   List<EJBEndpoint> ejbEndpoints, JaxWsModuleInfo jaxWsModuleInfo) throws UnableToAdaptException {
        Set<String> presentedServices = jaxWsModuleInfo.getEndpointImplBeanClassNames();

        for (EJBEndpoint ejbEndpoint : ejbEndpoints) {
            if (!ejbEndpoint.isWebService()) {
                continue;
            }
            if (presentedServices.contains(ejbEndpoint.getClassName())) {
                continue;
            }

            String ejbName = ejbEndpoint.getJ2EEName().getComponent();
            ctx.addContextEnv(JaxWsConstants.ENV_ATTRIBUTE_ENDPOINT_BEAN_NAME, ejbName);
            EndpointInfo endpointInfo = endpointInfoBuilder.build(ctx, ejbEndpoint.getClassName(), EndpointType.EJB);
            if (endpointInfo != null) {
                jaxWsModuleInfo.addEndpointInfo(ejbEndpoint.getName(), endpointInfo);
                jaxWsServerMetaData.putEndpointNameAndJ2EENameEntry(ejbName, ejbEndpoint.getJ2EEName());
            }
        }
    }
340792
public void setEndpointAddress(javax.xml.namespace.QName portName, java.lang.String address) throws javax.xml.rpc.ServiceException {
        setEndpointAddress(portName.getLocalPart(), address);
    }
635448
public void setEndpointAddress(java.lang.String portName, java.lang.String address) throws javax.xml.rpc.ServiceException {
        
if ("AdGroupAdServiceInterfacePort".equals(portName)) {
            setAdGroupAdServiceInterfacePortEndpointAddress(address);
        }
        else 
{ // Unknown Port Name
            throw new javax.xml.rpc.ServiceException(" Cannot set Endpoint Address for Unknown Port" + portName);
        }
    }
45576
final protected MessageEndpoint createEndpoint()
            throws UnavailableException {

        final String methodName = "createEndpoint";
        if (TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName);
        }

        final MessageEndpoint endpoint = _endpointFactory.createEndpoint(null);

        if (TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName, endpoint);
        }
        return endpoint;

    }
317110
public synchronized void postNotification(final String name, final Map<String, Object> userInfo) {
		ApptentiveLog.v(NOTIFICATIONS, "Post notification: name=%s userInfo={%s}", name, StringUtils.toString(userInfo));

		final ApptentiveNotificationObserverList list = findObserverList(name);
		if (list != null) {
			list.notifyObservers(new ApptentiveNotification(name, userInfo));
		}
	}
1351297
public void connect(URI endpoint) {
        if (endpoint.equals(this.getEndpoint()) && isListening) {
            return;
        }

        OkHttpClient client = new OkHttpClient.Builder()
                .readTimeout(0, TimeUnit.MILLISECONDS)
                .build();
        Request request = new Request.Builder()
                .url(endpoint.toString())
                .build();
        client.newWebSocket(request, this);
        client.dispatcher().executorService().shutdown();

        setEndpoint(endpoint);
    }
1125630
public DeleteNotificationResponse deleteNotification(String name) {
        DeleteNotificationRequest request = new DeleteNotificationRequest();
        request.setName(name);
        return deleteNotification(request);
    }
1290277
public static synchronized void websocket(String url, AbstractReceiveListener endpoint) {
        checkStarted();
        instance().endpoints.add(HandlerUtil.websocket(url, endpoint));
    }
559991
@Override
    public java.util.concurrent.Future<CreateTopicResult> createTopicAsync(String name) {

        return createTopicAsync(new CreateTopicRequest().withName(name));
    }