<!DOCTYPE HTML>
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (14.0.1) on Tue Jun 15 20:48:08 PDT 2021 -->
<title>RemoteServiceContainer (Eclipse Communication Framework (ECF) 3.14.22 API)</title>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<meta name="dc.created" content="2021-06-15">
<meta name="description" content="declaration: package: org.eclipse.ecf.provider.remoteservice.generic, class: RemoteServiceContainer">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../../script-dir/jquery-ui.css" title="Style">
<script type="text/javascript" src="../../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../../script-dir/jszip/dist/jszip.min.js"></script>
<script type="text/javascript" src="../../../../../../script-dir/jszip-utils/dist/jszip-utils.min.js"></script>
<!--[if IE]>
<script type="text/javascript" src="../../../../../../script-dir/jszip-utils/dist/jszip-utils-ie.min.js"></script>
<![endif]-->
<script type="text/javascript" src="../../../../../../script-dir/jquery-3.4.1.js"></script>
<script type="text/javascript" src="../../../../../../script-dir/jquery-ui.js"></script>
</head>
<body class="class-declaration">
<script type="text/javascript">var data = {"i0":10,"i1":10,"i2":10,"i3":10,"i4":10,"i5":10,"i6":10,"i7":10,"i8":10,"i9":10,"i10":10,"i11":10,"i12":10,"i13":10,"i14":10,"i15":10,"i16":10,"i17":10,"i18":10};
var tabs = {65535:["t0","All Methods"],2:["t2","Instance Methods"],8:["t4","Concrete Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
var pathtoroot = "../../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flexBox">
<header role="banner" class="flexHeader">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a id="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/RemoteServiceContainer.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
<li><a href="../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<div class="navListSearch"><label for="search">SEARCH:</label>
<input type="text" id="search" value="search" disabled="disabled">
<input type="reset" id="reset" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<div class="skipNav"><a id="skip.navbar.top">
<!--   -->
</a></div>
</nav>
</header>
<div class="flexContent">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle"><span class="packageLabelInType">Package</span>&nbsp;<a href="package-summary.html">org.eclipse.ecf.provider.remoteservice.generic</a></div>
<h1 title="Class RemoteServiceContainer" class="title">Class RemoteServiceContainer</h1>
</div>
<div class="contentContainer">
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">java.lang.Object</a>
<div class="inheritance"><a href="../../../core/AbstractContainer.html" title="class in org.eclipse.ecf.core">org.eclipse.ecf.core.AbstractContainer</a>
<div class="inheritance"><a href="../../generic/SOContainer.html" title="class in org.eclipse.ecf.provider.generic">org.eclipse.ecf.provider.generic.SOContainer</a>
<div class="inheritance"><a href="../../generic/ClientSOContainer.html" title="class in org.eclipse.ecf.provider.generic">org.eclipse.ecf.provider.generic.ClientSOContainer</a>
<div class="inheritance"><a href="../../generic/TCPClientSOContainer.html" title="class in org.eclipse.ecf.provider.generic">org.eclipse.ecf.provider.generic.TCPClientSOContainer</a>
<div class="inheritance">org.eclipse.ecf.provider.remoteservice.generic.RemoteServiceContainer</div>
</div>
</div>
</div>
</div>
</div>
<section class="description">
<dl>
<dt>All Implemented Interfaces:</dt>
<dd><code>org.eclipse.core.runtime.IAdaptable</code>, <code><a href="../../../core/IContainer.html" title="interface in org.eclipse.ecf.core">IContainer</a></code>, <code><a href="../../../core/identity/IIdentifiable.html" title="interface in org.eclipse.ecf.core.identity">IIdentifiable</a></code>, <code><a href="../../../core/IReliableContainer.html" title="interface in org.eclipse.ecf.core">IReliableContainer</a></code>, <code><a href="../../../core/sharedobject/ISharedObjectContainer.html" title="interface in org.eclipse.ecf.core.sharedobject">ISharedObjectContainer</a></code>, <code><a href="../../../core/sharedobject/ISharedObjectContainerClient.html" title="interface in org.eclipse.ecf.core.sharedobject">ISharedObjectContainerClient</a></code>, <code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code>, <code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code>, <code><a href="../../../remoteservice/IRemoteServiceHost.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceHost</a></code></dd>
</dl>
<hr>
<pre>public class <span class="typeNameLabel">RemoteServiceContainer</span>
extends <a href="../../generic/TCPClientSOContainer.html" title="class in org.eclipse.ecf.provider.generic">TCPClientSOContainer</a>
implements <a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></pre>
</section>
<section class="summary">
<ul class="blockList">
<!-- =========== FIELD SUMMARY =========== -->
<li class="blockList">
<section class="fieldSummary"><a id="field.summary">
<!--   -->
</a>
<h2>Field Summary</h2>
<div class="memberSummary">
<table>
<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
<thead>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colSecond" scope="col">Field</th>
<th class="colLast" scope="col">Description</th>
</tr>
</thead>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>protected <a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#registry">registry</a></span></code></th>
<td class="colLast">&nbsp;</td>
</tr>
</tbody>
</table>
</div>
<div class="inheritedList">
<h3>Fields inherited from class&nbsp;org.eclipse.ecf.provider.generic.<a href="../../generic/TCPClientSOContainer.html" title="class in org.eclipse.ecf.provider.generic">TCPClientSOContainer</a></h3>
<a id="fields.inherited.from.class.org.eclipse.ecf.provider.generic.TCPClientSOContainer">
<!--   -->
</a><code><a href="../../generic/TCPClientSOContainer.html#DEFAULT_COMM_NAME">DEFAULT_COMM_NAME</a>, <a href="../../generic/TCPClientSOContainer.html#DEFAULT_TCP_CONNECT_TIMEOUT">DEFAULT_TCP_CONNECT_TIMEOUT</a></code></div>
<div class="inheritedList">
<h3>Fields inherited from class&nbsp;org.eclipse.ecf.provider.generic.<a href="../../generic/ClientSOContainer.html" title="class in org.eclipse.ecf.provider.generic">ClientSOContainer</a></h3>
<a id="fields.inherited.from.class.org.eclipse.ecf.provider.generic.ClientSOContainer">
<!--   -->
</a><code><a href="../../generic/ClientSOContainer.html#CONNECTED">CONNECTED</a>, <a href="../../generic/ClientSOContainer.html#CONNECTING">CONNECTING</a>, <a href="../../generic/ClientSOContainer.html#connection">connection</a>, <a href="../../generic/ClientSOContainer.html#connectionState">connectionState</a>, <a href="../../generic/ClientSOContainer.html#connectLock">connectLock</a>, <a href="../../generic/ClientSOContainer.html#connectPolicy">connectPolicy</a>, <a href="../../generic/ClientSOContainer.html#DEFAULT_CONNECT_TIMEOUT">DEFAULT_CONNECT_TIMEOUT</a>, <a href="../../generic/ClientSOContainer.html#DISCONNECTED">DISCONNECTED</a>, <a href="../../generic/ClientSOContainer.html#remoteServerID">remoteServerID</a></code></div>
<div class="inheritedList">
<h3>Fields inherited from class&nbsp;org.eclipse.ecf.provider.generic.<a href="../../generic/SOContainer.html" title="class in org.eclipse.ecf.provider.generic">SOContainer</a></h3>
<a id="fields.inherited.from.class.org.eclipse.ecf.provider.generic.SOContainer">
<!--   -->
</a><code><a href="../../generic/SOContainer.html#config">config</a>, <a href="../../generic/SOContainer.html#DEFAULT_OBJECT_ARG_KEY">DEFAULT_OBJECT_ARG_KEY</a>, <a href="../../generic/SOContainer.html#DEFAULT_OBJECT_ARGTYPES_KEY">DEFAULT_OBJECT_ARGTYPES_KEY</a>, <a href="../../generic/SOContainer.html#groupManager">groupManager</a>, <a href="../../generic/SOContainer.html#isClosing">isClosing</a>, <a href="../../generic/SOContainer.html#loadingThreadGroup">loadingThreadGroup</a>, <a href="../../generic/SOContainer.html#policy">policy</a>, <a href="../../generic/SOContainer.html#receiver">receiver</a>, <a href="../../generic/SOContainer.html#sharedObjectManager">sharedObjectManager</a>, <a href="../../generic/SOContainer.html#sharedObjectMessageSerializer">sharedObjectMessageSerializer</a>, <a href="../../generic/SOContainer.html#sharedObjectThreadGroup">sharedObjectThreadGroup</a></code></div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li class="blockList">
<section class="constructorSummary"><a id="constructor.summary">
<!--   -->
</a>
<h2>Constructor Summary</h2>
<div class="memberSummary">
<table>
<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
<thead>
<tr>
<th class="colFirst" scope="col">Constructor</th>
<th class="colLast" scope="col">Description</th>
</tr>
</thead>
<tbody>
<tr class="altColor">
<th class="colConstructorName" scope="row"><code><span class="memberNameLink"><a href="#%3Cinit%3E(org.eclipse.ecf.core.sharedobject.ISharedObjectContainerConfig)">RemoteServiceContainer</a></span>&#8203;(<a href="../../../core/sharedobject/ISharedObjectContainerConfig.html" title="interface in org.eclipse.ecf.core.sharedobject">ISharedObjectContainerConfig</a>&nbsp;config)</code></th>
<td class="colLast">&nbsp;</td>
</tr>
<tr class="rowColor">
<th class="colConstructorName" scope="row"><code><span class="memberNameLink"><a href="#%3Cinit%3E(org.eclipse.ecf.core.sharedobject.ISharedObjectContainerConfig,int)">RemoteServiceContainer</a></span>&#8203;(<a href="../../../core/sharedobject/ISharedObjectContainerConfig.html" title="interface in org.eclipse.ecf.core.sharedobject">ISharedObjectContainerConfig</a>&nbsp;config,
int&nbsp;ka)</code></th>
<td class="colLast">&nbsp;</td>
</tr>
</tbody>
</table>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li class="blockList">
<section class="methodSummary"><a id="method.summary">
<!--   -->
</a>
<h2>Method Summary</h2>
<div class="memberSummary">
<div role="tablist" aria-orientation="horizontal"><button role="tab" aria-selected="true" aria-controls="memberSummary_tabpanel" tabindex="0" onkeydown="switchTab(event)" id="t0" class="activeTableTab">All Methods</button><button role="tab" aria-selected="false" aria-controls="memberSummary_tabpanel" tabindex="-1" onkeydown="switchTab(event)" id="t2" class="tableTab" onclick="show(2);">Instance Methods</button><button role="tab" aria-selected="false" aria-controls="memberSummary_tabpanel" tabindex="-1" onkeydown="switchTab(event)" id="t4" class="tableTab" onclick="show(8);">Concrete Methods</button></div>
<div id="memberSummary_tabpanel" role="tabpanel">
<table aria-labelledby="t0">
<thead>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colSecond" scope="col">Method</th>
<th class="colLast" scope="col">Description</th>
</tr>
</thead>
<tbody>
<tr class="altColor" id="i0">
<td class="colFirst"><code>void</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#addRemoteServiceListener(org.eclipse.ecf.remoteservice.IRemoteServiceListener)">addRemoteServiceListener</a></span>&#8203;(<a href="../../../remoteservice/IRemoteServiceListener.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceListener</a>&nbsp;listener)</code></th>
<td class="colLast">
<div class="block">Add listener for remote service registration/unregistration for this
 container</div>
</td>
</tr>
<tr class="rowColor" id="i1">
<td class="colFirst"><code>org.eclipse.equinox.concurrent.future.IFuture</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">asyncGetRemoteServiceReferences</a></span>&#8203;(<a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>[]&nbsp;idFilter,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</code></th>
<td class="colLast">
<div class="block">Asynchronously returns an array of <code>IRemoteServiceReference</code> objects.</div>
</td>
</tr>
<tr class="altColor" id="i2">
<td class="colFirst"><code>org.eclipse.equinox.concurrent.future.IFuture</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)">asyncGetRemoteServiceReferences</a></span>&#8203;(<a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>&nbsp;target,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</code></th>
<td class="colLast">
<div class="block">Asynchronously returns an array of <code>IRemoteServiceReference</code> objects.</div>
</td>
</tr>
<tr class="rowColor" id="i3">
<td class="colFirst"><code>org.eclipse.equinox.concurrent.future.IFuture</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">asyncGetRemoteServiceReferences</a></span>&#8203;(<a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>&nbsp;target,
<a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>[]&nbsp;idFilter,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</code></th>
<td class="colLast">
<div class="block">Asynchronously returns an array of <code>IRemoteServiceReference</code> objects.</div>
</td>
</tr>
<tr class="altColor" id="i4">
<td class="colFirst"><code>protected void</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createRegistry()">createRegistry</a></span>()</code></th>
<td class="colLast">&nbsp;</td>
</tr>
<tr class="rowColor" id="i5">
<td class="colFirst"><code><a href="../../../remoteservice/IRemoteFilter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteFilter</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createRemoteFilter(java.lang.String)">createRemoteFilter</a></span>&#8203;(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</code></th>
<td class="colLast">
<div class="block">Creates a <code>IRemoteFilter</code> object.</div>
</td>
</tr>
<tr class="altColor" id="i6">
<td class="colFirst"><code><a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a>[]</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getAllRemoteServiceReferences(java.lang.String,java.lang.String)">getAllRemoteServiceReferences</a></span>&#8203;(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</code></th>
<td class="colLast">
<div class="block">
 Returns an array of <code>IRemoteServiceReference</code> objects.</div>
</td>
</tr>
<tr class="rowColor" id="i7">
<td class="colFirst"><code><a href="../../../remoteservice/IRemoteService.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteService</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)">getRemoteService</a></span>&#8203;(<a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a>&nbsp;ref)</code></th>
<td class="colLast">
<div class="block">Get remote service for given IRemoteServiceReference.</div>
</td>
</tr>
<tr class="altColor" id="i8">
<td class="colFirst"><code><a href="../../../remoteservice/IRemoteServiceID.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceID</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getRemoteServiceID(org.eclipse.ecf.core.identity.ID,long)">getRemoteServiceID</a></span>&#8203;(<a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>&nbsp;containerID,
long&nbsp;containerRelativeID)</code></th>
<td class="colLast">
<div class="block">Get a remote service ID from a containerID and a containerRelative long value.</div>
</td>
</tr>
<tr class="rowColor" id="i9">
<td class="colFirst"><code><a href="../../../core/identity/Namespace.html" title="class in org.eclipse.ecf.core.identity">Namespace</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getRemoteServiceNamespace()">getRemoteServiceNamespace</a></span>()</code></th>
<td class="colLast">
<div class="block">Get namespace to use for this remote service provider.</div>
</td>
</tr>
<tr class="altColor" id="i10">
<td class="colFirst"><code><a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getRemoteServiceReference(org.eclipse.ecf.remoteservice.IRemoteServiceID)">getRemoteServiceReference</a></span>&#8203;(<a href="../../../remoteservice/IRemoteServiceID.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceID</a>&nbsp;serviceID)</code></th>
<td class="colLast">
<div class="block">Get the remote service reference known to this container for the given IRemoteServiceID.</div>
</td>
</tr>
<tr class="rowColor" id="i11">
<td class="colFirst"><code><a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a>[]</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">getRemoteServiceReferences</a></span>&#8203;(<a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>[]&nbsp;idFilter,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</code></th>
<td class="colLast">
<div class="block">Returns an array of <code>IRemoteServiceReference</code> objects.</div>
</td>
</tr>
<tr class="altColor" id="i12">
<td class="colFirst"><code><a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a>[]</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)">getRemoteServiceReferences</a></span>&#8203;(<a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>&nbsp;target,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</code></th>
<td class="colLast">
<div class="block">
 Returns an array of <code>IRemoteServiceReference</code> objects.</div>
</td>
</tr>
<tr class="rowColor" id="i13">
<td class="colFirst"><code><a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a>[]</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">getRemoteServiceReferences</a></span>&#8203;(<a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>&nbsp;target,
<a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>[]&nbsp;idFilter,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</code></th>
<td class="colLast">
<div class="block">Returns an array of <code>IRemoteServiceReference</code> objects.</div>
</td>
</tr>
<tr class="altColor" id="i14">
<td class="colFirst"><code><a href="../../../remoteservice/IRemoteServiceRegistration.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceRegistration</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#registerRemoteService(java.lang.String%5B%5D,java.lang.Object,java.util.Dictionary)">registerRemoteService</a></span>&#8203;(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>[]&nbsp;clazzes,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a>&nbsp;service,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Dictionary.html?is-external=true" title="class or interface in java.util" class="externalLink">Dictionary</a>&nbsp;properties)</code></th>
<td class="colLast">
<div class="block">Register a new remote service.</div>
</td>
</tr>
<tr class="rowColor" id="i15">
<td class="colFirst"><code>void</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#removeRemoteServiceListener(org.eclipse.ecf.remoteservice.IRemoteServiceListener)">removeRemoteServiceListener</a></span>&#8203;(<a href="../../../remoteservice/IRemoteServiceListener.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceListener</a>&nbsp;listener)</code></th>
<td class="colLast">
<div class="block">Remove remote service registration/unregistration listener for this
 container.</div>
</td>
</tr>
<tr class="altColor" id="i16">
<td class="colFirst"><code>void</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#setConnectContextForAuthentication(org.eclipse.ecf.core.security.IConnectContext)">setConnectContextForAuthentication</a></span>&#8203;(<a href="../../../core/security/IConnectContext.html" title="interface in org.eclipse.ecf.core.security">IConnectContext</a>&nbsp;connectContext)</code></th>
<td class="colLast">
<div class="block">Set connect context for authentication upon subsequent calls to
 <a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)"><code>IRemoteServiceContainerAdapter.getRemoteServiceReferences(ID[], String, String)</code></a> or <a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)"><code>IRemoteServiceContainerAdapter.asyncGetRemoteServiceReferences(ID[], String, String)</code></a>.</div>
</td>
</tr>
<tr class="rowColor" id="i17">
<td class="colFirst"><code>boolean</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#setRemoteServiceCallPolicy(org.eclipse.ecf.remoteservice.IRemoteServiceCallPolicy)">setRemoteServiceCallPolicy</a></span>&#8203;(<a href="../../../remoteservice/IRemoteServiceCallPolicy.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceCallPolicy</a>&nbsp;policy)</code></th>
<td class="colLast">
<div class="block">Set the remote service call policy to enable authorization on remote service method calls</div>
</td>
</tr>
<tr class="altColor" id="i18">
<td class="colFirst"><code>boolean</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ungetRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)">ungetRemoteService</a></span>&#8203;(<a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a>&nbsp;ref)</code></th>
<td class="colLast">
<div class="block">Unget IRemoteServiceReference.</div>
</td>
</tr>
</tbody>
</table>
</div>
</div>
<div class="inheritedList">
<h3>Methods inherited from class&nbsp;org.eclipse.ecf.provider.generic.<a href="../../generic/TCPClientSOContainer.html" title="class in org.eclipse.ecf.provider.generic">TCPClientSOContainer</a></h3>
<a id="methods.inherited.from.class.org.eclipse.ecf.provider.generic.TCPClientSOContainer">
<!--   -->
</a><code><a href="../../generic/TCPClientSOContainer.html#createConnection(org.eclipse.ecf.core.identity.ID,java.lang.Object)">createConnection</a>, <a href="../../generic/TCPClientSOContainer.html#getConnectTimeout()">getConnectTimeout</a>, <a href="../../generic/TCPClientSOContainer.html#main(java.lang.String%5B%5D)">main</a></code></div>
<div class="inheritedList">
<h3>Methods inherited from class&nbsp;org.eclipse.ecf.provider.generic.<a href="../../generic/ClientSOContainer.html" title="class in org.eclipse.ecf.provider.generic">ClientSOContainer</a></h3>
<a id="methods.inherited.from.class.org.eclipse.ecf.provider.generic.ClientSOContainer">
<!--   -->
</a><code><a href="../../generic/ClientSOContainer.html#connect(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.security.IConnectContext)">connect</a>, <a href="../../generic/ClientSOContainer.html#createAuthorizationCallbacks()">createAuthorizationCallbacks</a>, <a href="../../generic/ClientSOContainer.html#disconnect()">disconnect</a>, <a href="../../generic/ClientSOContainer.html#disconnect(java.lang.Throwable)">disconnect</a>, <a href="../../generic/ClientSOContainer.html#dispose()">dispose</a>, <a href="../../generic/ClientSOContainer.html#forwardExcluding(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID,byte,java.io.Serializable)">forwardExcluding</a>, <a href="../../generic/ClientSOContainer.html#forwardExcluding(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.provider.generic.ContainerMessage)">forwardExcluding</a>, <a href="../../generic/ClientSOContainer.html#forwardToRemote(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.provider.generic.ContainerMessage)">forwardToRemote</a>, <a href="../../generic/ClientSOContainer.html#getConnectData(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.security.IConnectContext)">getConnectData</a>, <a href="../../generic/ClientSOContainer.html#getConnectedID()">getConnectedID</a>, <a href="../../generic/ClientSOContainer.html#getConnection()">getConnection</a>, <a href="../../generic/ClientSOContainer.html#getConnectLock()">getConnectLock</a>, <a href="../../generic/ClientSOContainer.html#getIDForConnection(org.eclipse.ecf.provider.comm.IAsynchConnection)">getIDForConnection</a>, <a href="../../generic/ClientSOContainer.html#getLeaveData(org.eclipse.ecf.core.identity.ID)">getLeaveData</a>, <a href="../../generic/ClientSOContainer.html#handleConnectResponse(org.eclipse.ecf.core.identity.ID,java.lang.Object)">handleConnectResponse</a>, <a href="../../generic/ClientSOContainer.html#handleLeave(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.provider.comm.IConnection)">handleLeave</a>, <a href="../../generic/ClientSOContainer.html#handleLeaveGroupMessage(org.eclipse.ecf.provider.generic.ContainerMessage)">handleLeaveGroupMessage</a>, <a href="../../generic/ClientSOContainer.html#handleViewChangeMessage(org.eclipse.ecf.provider.generic.ContainerMessage)">handleViewChangeMessage</a>, <a href="../../generic/ClientSOContainer.html#isConnected()">isConnected</a>, <a href="../../generic/ClientSOContainer.html#isConnecting()">isConnecting</a>, <a href="../../generic/ClientSOContainer.html#isGroupManager()">isGroupManager</a>, <a href="../../generic/ClientSOContainer.html#processAsynch(org.eclipse.ecf.provider.comm.AsynchEvent)">processAsynch</a>, <a href="../../generic/ClientSOContainer.html#processDisconnect(org.eclipse.ecf.provider.comm.DisconnectEvent)">processDisconnect</a>, <a href="../../generic/ClientSOContainer.html#processSynch(org.eclipse.ecf.provider.comm.SynchEvent)">processSynch</a>, <a href="../../generic/ClientSOContainer.html#queueContainerMessage(org.eclipse.ecf.provider.generic.ContainerMessage)">queueContainerMessage</a>, <a href="../../generic/ClientSOContainer.html#sendCreate(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.sharedobject.SharedObjectDescription)">sendCreate</a>, <a href="../../generic/ClientSOContainer.html#sendCreateMsg(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.sharedobject.SharedObjectDescription)">sendCreateMsg</a>, <a href="../../generic/ClientSOContainer.html#sendCreateResponse(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID,java.lang.Throwable,long)">sendCreateResponse</a>, <a href="../../generic/ClientSOContainer.html#sendCreateResponseSharedObjectMessage(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID,java.lang.Throwable,long)">sendCreateResponseSharedObjectMessage</a>, <a href="../../generic/ClientSOContainer.html#sendCreateSharedObjectMessage(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.sharedobject.SharedObjectDescription)">sendCreateSharedObjectMessage</a>, <a href="../../generic/ClientSOContainer.html#sendDispose(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID)">sendDispose</a>, <a href="../../generic/ClientSOContainer.html#sendDisposeSharedObjectMessage(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID)">sendDisposeSharedObjectMessage</a>, <a href="../../generic/ClientSOContainer.html#sendMessage(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID,java.lang.Object)">sendMessage</a>, <a href="../../generic/ClientSOContainer.html#sendMessage(org.eclipse.ecf.provider.generic.ContainerMessage)">sendMessage</a>, <a href="../../generic/ClientSOContainer.html#sendSharedObjectMessage(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID,java.io.Serializable)">sendSharedObjectMessage</a>, <a href="../../generic/ClientSOContainer.html#setConnectInitiatorPolicy(org.eclipse.ecf.core.security.IConnectInitiatorPolicy)">setConnectInitiatorPolicy</a></code></div>
<div class="inheritedList">
<h3>Methods inherited from class&nbsp;org.eclipse.ecf.provider.generic.<a href="../../generic/SOContainer.html" title="class in org.eclipse.ecf.provider.generic">SOContainer</a></h3>
<a id="methods.inherited.from.class.org.eclipse.ecf.provider.generic.SOContainer">
<!--   -->
</a><code><a href="../../generic/SOContainer.html#addNewRemoteMember(org.eclipse.ecf.core.identity.ID,java.lang.Object)">addNewRemoteMember</a>, <a href="../../generic/SOContainer.html#addSharedObject0(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.sharedobject.ISharedObject,java.util.Map)">addSharedObject0</a>, <a href="../../generic/SOContainer.html#addSharedObjectAndWait(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.sharedobject.ISharedObject,java.util.Map)">addSharedObjectAndWait</a>, <a href="../../generic/SOContainer.html#addSharedObjectWrapper(org.eclipse.ecf.provider.generic.SOWrapper)">addSharedObjectWrapper</a>, <a href="../../generic/SOContainer.html#addToLoading(org.eclipse.ecf.provider.generic.SOContainer.LoadingSharedObject)">addToLoading</a>, <a href="../../generic/SOContainer.html#checkRemoteCreate(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.sharedobject.ReplicaSharedObjectDescription)">checkRemoteCreate</a>, <a href="../../generic/SOContainer.html#createContainerPropertiesForSharedObject(org.eclipse.ecf.core.identity.ID)">createContainerPropertiesForSharedObject</a>, <a href="../../generic/SOContainer.html#createRemoteSharedObjectConfig(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.sharedobject.ReplicaSharedObjectDescription,org.eclipse.ecf.core.sharedobject.ISharedObject)">createRemoteSharedObjectConfig</a>, <a href="../../generic/SOContainer.html#createRemoteSharedObjectContext(org.eclipse.ecf.provider.generic.SOConfig,org.eclipse.ecf.core.sharedobject.util.IQueueEnqueue)">createRemoteSharedObjectContext</a>, <a href="../../generic/SOContainer.html#createRemoteSharedObjectWrapper(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.sharedobject.ReplicaSharedObjectDescription,org.eclipse.ecf.core.sharedobject.ISharedObject)">createRemoteSharedObjectWrapper</a>, <a href="../../generic/SOContainer.html#createSharedObjectConfig(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.sharedobject.ISharedObject,java.util.Map)">createSharedObjectConfig</a>, <a href="../../generic/SOContainer.html#createSharedObjectContext(org.eclipse.ecf.provider.generic.SOConfig,org.eclipse.ecf.core.sharedobject.util.IQueueEnqueue)">createSharedObjectContext</a>, <a href="../../generic/SOContainer.html#createSharedObjectWrapper(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.sharedobject.ISharedObject,java.util.Map)">createSharedObjectWrapper</a>, <a href="../../generic/SOContainer.html#debug(java.lang.String)">debug</a>, <a href="../../generic/SOContainer.html#defaultDeserializeSharedObjectMessage(byte%5B%5D)">defaultDeserializeSharedObjectMessage</a>, <a href="../../generic/SOContainer.html#defaultSerializeSharedObjectMessage(org.eclipse.ecf.core.identity.ID,java.lang.Object)">defaultSerializeSharedObjectMessage</a>, <a href="../../generic/SOContainer.html#deserializeContainerMessage(byte%5B%5D)">deserializeContainerMessage</a>, <a href="../../generic/SOContainer.html#deserializeSharedObjectMessage(byte%5B%5D)">deserializeSharedObjectMessage</a>, <a href="../../generic/SOContainer.html#destroySharedObject(org.eclipse.ecf.core.identity.ID)">destroySharedObject</a>, <a href="../../generic/SOContainer.html#disconnect(org.eclipse.ecf.provider.comm.IConnection)">disconnect</a>, <a href="../../generic/SOContainer.html#fireDelegateContainerEvent(org.eclipse.ecf.core.events.IContainerEvent)">fireDelegateContainerEvent</a>, <a href="../../generic/SOContainer.html#forward(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.provider.generic.ContainerMessage)">forward</a>, <a href="../../generic/SOContainer.html#getAdapter(java.lang.Class)">getAdapter</a>, <a href="../../generic/SOContainer.html#getArgsFromProperties(org.eclipse.ecf.core.sharedobject.SharedObjectDescription)">getArgsFromProperties</a>, <a href="../../generic/SOContainer.html#getArgTypesFromProperties(org.eclipse.ecf.core.sharedobject.SharedObjectDescription)">getArgTypesFromProperties</a>, <a href="../../generic/SOContainer.html#getClassLoaderForContainer()">getClassLoaderForContainer</a>, <a href="../../generic/SOContainer.html#getClassLoaderForSharedObject(org.eclipse.ecf.core.sharedobject.SharedObjectDescription)">getClassLoaderForSharedObject</a>, <a href="../../generic/SOContainer.html#getConfig()">getConfig</a>, <a href="../../generic/SOContainer.html#getConnectNamespace()">getConnectNamespace</a>, <a href="../../generic/SOContainer.html#getGroupMemberIDs()">getGroupMemberIDs</a>, <a href="../../generic/SOContainer.html#getGroupMembershipLock()">getGroupMembershipLock</a>, <a href="../../generic/SOContainer.html#getID()">getID</a>, <a href="../../generic/SOContainer.html#getMaxGroupMembers()">getMaxGroupMembers</a>, <a href="../../generic/SOContainer.html#getMessageReceiver()">getMessageReceiver</a>, <a href="../../generic/SOContainer.html#getNewSharedObjectThread(org.eclipse.ecf.core.identity.ID,java.lang.Runnable)">getNewSharedObjectThread</a>, <a href="../../generic/SOContainer.html#getNextSequenceNumber()">getNextSequenceNumber</a>, <a href="../../generic/SOContainer.html#getOtherMemberIDs()">getOtherMemberIDs</a>, <a href="../../generic/SOContainer.html#getReceiver()">getReceiver</a>, <a href="../../generic/SOContainer.html#getSharedObject(org.eclipse.ecf.core.identity.ID)">getSharedObject</a>, <a href="../../generic/SOContainer.html#getSharedObjectIDs()">getSharedObjectIDs</a>, <a href="../../generic/SOContainer.html#getSharedObjectManager()">getSharedObjectManager</a>, <a href="../../generic/SOContainer.html#getSharedObjectMessageSerializer()">getSharedObjectMessageSerializer</a>, <a href="../../generic/SOContainer.html#getSharedObjectWrapper(org.eclipse.ecf.core.identity.ID)">getSharedObjectWrapper</a>, <a href="../../generic/SOContainer.html#handleAsynchIOException(java.io.IOException,org.eclipse.ecf.provider.comm.AsynchEvent)">handleAsynchIOException</a>, <a href="../../generic/SOContainer.html#handleCreateMessage(org.eclipse.ecf.provider.generic.ContainerMessage)">handleCreateMessage</a>, <a href="../../generic/SOContainer.html#handleCreateResponseMessage(org.eclipse.ecf.provider.generic.ContainerMessage)">handleCreateResponseMessage</a>, <a href="../../generic/SOContainer.html#handleSharedObjectDisposeMessage(org.eclipse.ecf.provider.generic.ContainerMessage)">handleSharedObjectDisposeMessage</a>, <a href="../../generic/SOContainer.html#handleSharedObjectMessage(org.eclipse.ecf.provider.generic.ContainerMessage)">handleSharedObjectMessage</a>, <a href="../../generic/SOContainer.html#handleUndeliveredSharedObjectMessage(org.eclipse.ecf.provider.generic.ContainerMessage.SharedObjectMessage)">handleUndeliveredSharedObjectMessage</a>, <a href="../../generic/SOContainer.html#handleUnidentifiedMessage(org.eclipse.ecf.provider.generic.ContainerMessage)">handleUnidentifiedMessage</a>, <a href="../../generic/SOContainer.html#isClosing()">isClosing</a>, <a href="../../generic/SOContainer.html#load(org.eclipse.ecf.core.sharedobject.SharedObjectDescription)">load</a>, <a href="../../generic/SOContainer.html#moveFromLoadingToActive(org.eclipse.ecf.provider.generic.SOWrapper)">moveFromLoadingToActive</a>, <a href="../../generic/SOContainer.html#notifySharedObjectActivated(org.eclipse.ecf.core.identity.ID)">notifySharedObjectActivated</a>, <a href="../../generic/SOContainer.html#notifySharedObjectDeactivated(org.eclipse.ecf.core.identity.ID)">notifySharedObjectDeactivated</a>, <a href="../../generic/SOContainer.html#printToSystemError(java.lang.String,java.lang.Throwable)">printToSystemError</a>, <a href="../../generic/SOContainer.html#removeFromLoading(org.eclipse.ecf.core.identity.ID)">removeFromLoading</a>, <a href="../../generic/SOContainer.html#removeRemoteMember(org.eclipse.ecf.core.identity.ID)">removeRemoteMember</a>, <a href="../../generic/SOContainer.html#removeSharedObject(org.eclipse.ecf.core.identity.ID)">removeSharedObject</a>, <a href="../../generic/SOContainer.html#serialize(java.io.Serializable)">serialize</a>, <a href="../../generic/SOContainer.html#serializeSharedObjectMessage(org.eclipse.ecf.core.identity.ID,java.lang.Object)">serializeSharedObjectMessage</a>, <a href="../../generic/SOContainer.html#setMaxGroupMembers(int)">setMaxGroupMembers</a>, <a href="../../generic/SOContainer.html#setRemoteAddPolicy(org.eclipse.ecf.core.sharedobject.security.ISharedObjectPolicy)">setRemoteAddPolicy</a>, <a href="../../generic/SOContainer.html#setSharedObjectMessageSerializer(org.eclipse.ecf.core.sharedobject.util.ISharedObjectMessageSerializer)">setSharedObjectMessageSerializer</a>, <a href="../../generic/SOContainer.html#traceStack(java.lang.String,java.lang.Throwable)">traceStack</a>, <a href="../../generic/SOContainer.html#validateContainerMessage(java.lang.Object)">validateContainerMessage</a>, <a href="../../generic/SOContainer.html#verifySharedObjectMessageTarget(org.eclipse.ecf.core.identity.ID)">verifySharedObjectMessageTarget</a>, <a href="../../generic/SOContainer.html#verifyToIDForSharedObjectMessage(org.eclipse.ecf.core.identity.ID)">verifyToIDForSharedObjectMessage</a></code></div>
<div class="inheritedList">
<h3>Methods inherited from class&nbsp;org.eclipse.ecf.core.<a href="../../../core/AbstractContainer.html" title="class in org.eclipse.ecf.core">AbstractContainer</a></h3>
<a id="methods.inherited.from.class.org.eclipse.ecf.core.AbstractContainer">
<!--   -->
</a><code><a href="../../../core/AbstractContainer.html#addListener(org.eclipse.ecf.core.IContainerListener)">addListener</a>, <a href="../../../core/AbstractContainer.html#fireContainerEvent(org.eclipse.ecf.core.events.IContainerEvent)">fireContainerEvent</a>, <a href="../../../core/AbstractContainer.html#getPasswordFromConnectContext(org.eclipse.ecf.core.security.IConnectContext)">getPasswordFromConnectContext</a>, <a href="../../../core/AbstractContainer.html#removeListener(org.eclipse.ecf.core.IContainerListener)">removeListener</a></code></div>
<div class="inheritedList">
<h3>Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></h3>
<a id="methods.inherited.from.class.java.lang.Object">
<!--   -->
</a><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true#clone()" title="class or interface in java.lang" class="externalLink">clone</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true#equals(java.lang.Object)" title="class or interface in java.lang" class="externalLink">equals</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true#finalize()" title="class or interface in java.lang" class="externalLink">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true#getClass()" title="class or interface in java.lang" class="externalLink">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true#hashCode()" title="class or interface in java.lang" class="externalLink">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true#notify()" title="class or interface in java.lang" class="externalLink">notify</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true#notifyAll()" title="class or interface in java.lang" class="externalLink">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true#toString()" title="class or interface in java.lang" class="externalLink">toString</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true#wait()" title="class or interface in java.lang" class="externalLink">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true#wait(long)" title="class or interface in java.lang" class="externalLink">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true#wait(long,int)" title="class or interface in java.lang" class="externalLink">wait</a></code></div>
<div class="inheritedList">
<h3>Methods inherited from interface&nbsp;org.eclipse.ecf.core.<a href="../../../core/IContainer.html" title="interface in org.eclipse.ecf.core">IContainer</a></h3>
<a id="methods.inherited.from.class.org.eclipse.ecf.core.IContainer">
<!--   -->
</a><code><a href="../../../core/IContainer.html#addListener(org.eclipse.ecf.core.IContainerListener)">addListener</a>, <a href="../../../core/IContainer.html#removeListener(org.eclipse.ecf.core.IContainerListener)">removeListener</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="blockList">
<!-- ============ FIELD DETAIL =========== -->
<li class="blockList">
<section class="fieldDetails"><a id="field.detail">
<!--   -->
</a>
<h2>Field Details</h2>
<ul class="blockList">
<li class="blockList">
<section class="detail">
<h3><a id="registry">registry</a></h3>
<div class="memberSignature"><span class="modifiers">protected</span>&nbsp;<span class="returnType"><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></span>&nbsp;<span class="memberName">registry</span></div>
</section>
</li>
</ul>
</section>
</li>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li class="blockList">
<section class="constructorDetails"><a id="constructor.detail">
<!--   -->
</a>
<h2>Constructor Details</h2>
<ul class="blockList">
<li class="blockList">
<section class="detail">
<h3><a id="&lt;init&gt;(org.eclipse.ecf.core.sharedobject.ISharedObjectContainerConfig)">RemoteServiceContainer</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="memberName">RemoteServiceContainer</span>&#8203;(<span class="arguments"><a href="../../../core/sharedobject/ISharedObjectContainerConfig.html" title="interface in org.eclipse.ecf.core.sharedobject">ISharedObjectContainerConfig</a>&nbsp;config)</span></div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="&lt;init&gt;(org.eclipse.ecf.core.sharedobject.ISharedObjectContainerConfig,int)">RemoteServiceContainer</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="memberName">RemoteServiceContainer</span>&#8203;(<span class="arguments"><a href="../../../core/sharedobject/ISharedObjectContainerConfig.html" title="interface in org.eclipse.ecf.core.sharedobject">ISharedObjectContainerConfig</a>&nbsp;config,
int&nbsp;ka)</span></div>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li class="blockList">
<section class="methodDetails"><a id="method.detail">
<!--   -->
</a>
<h2>Method Details</h2>
<ul class="blockList">
<li class="blockList">
<section class="detail">
<h3><a id="createRegistry()">createRegistry</a></h3>
<div class="memberSignature"><span class="modifiers">protected</span>&nbsp;<span class="returnType">void</span>&nbsp;<span class="memberName">createRegistry</span>()</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="addRemoteServiceListener(org.eclipse.ecf.remoteservice.IRemoteServiceListener)">addRemoteServiceListener</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType">void</span>&nbsp;<span class="memberName">addRemoteServiceListener</span>&#8203;(<span class="arguments"><a href="../../../remoteservice/IRemoteServiceListener.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceListener</a>&nbsp;listener)</span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#addRemoteServiceListener(org.eclipse.ecf.remoteservice.IRemoteServiceListener)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Add listener for remote service registration/unregistration for this
 container</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#addRemoteServiceListener(org.eclipse.ecf.remoteservice.IRemoteServiceListener)">addRemoteServiceListener</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#addRemoteServiceListener(org.eclipse.ecf.remoteservice.IRemoteServiceListener)">addRemoteServiceListener</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceHost.html#addRemoteServiceListener(org.eclipse.ecf.remoteservice.IRemoteServiceListener)">addRemoteServiceListener</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceHost.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceHost</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>listener</code> - notified of service registration/unregistration events. Must
            not be <code>null</code> .</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="getRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)">getRemoteService</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType"><a href="../../../remoteservice/IRemoteService.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteService</a></span>&nbsp;<span class="memberName">getRemoteService</span>&#8203;(<span class="arguments"><a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a>&nbsp;ref)</span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Get remote service for given IRemoteServiceReference. Note that clients
 that call this method successfully should later call
 <a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#ungetRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)"><code>IRemoteServiceContainerAdapter.ungetRemoteService(IRemoteServiceReference)</code></a>
 when the IRemoteService will no longer be used.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#getRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)">getRemoteService</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)">getRemoteService</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>ref</code> - the IRemoteServiceReference for the desired service. Must not
            be <code>null</code> .</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>IRemoteService representing the remote service. If remote service
         no longer exists for reference, then <code>null</code> is
         returned.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#ungetRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)"><code>IRemoteServiceContainerAdapter.ungetRemoteService(IRemoteServiceReference)</code></a></dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID[],java.lang.String,java.lang.String)">getRemoteServiceReferences</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType"><a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a>[]</span>&nbsp;<span class="memberName">getRemoteServiceReferences</span>&#8203;(<span class="arguments"><a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>[]&nbsp;idFilter,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</span>
                                                     throws <span class="exceptions"><a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink">InvalidSyntaxException</a></span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Returns an array of <code>IRemoteServiceReference</code> objects. The
 returned array of <code>IRemoteServiceReference</code> objects contains
 services that were registered under the specified class and match the
 specified idFilter, and filter criteria.
 <p>
 Note this method assumes that the enclosing container has previously
 been connected, and uses the idFilter to filter among targets within the
 previously connected set of container IDs.  To request connection as 
 part of reference lookup, see <a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)"><code>IRemoteServiceContainerAdapter.getRemoteServiceReferences(ID, String, String)</code></a>.
 </p>
 
 <p>
 The list is valid at the time of the call to this method, however since
 the Framework is a very dynamic environment, services can be modified or
 unregistered at anytime.
 
 <p>
 <code>idFilter</code> is used to select a registered services that were
 registered by a given set of containers with id in idFilter. Only
 services exposed by a container with id in idFilter will be returned.
 
 <p>
 If <code>idFilter</code> is <code>null</code>, all containers are
 considered to match the filter.
 
 <p>
 <code>filter</code> is used to select the registered service whose
 properties objects contain keys and values which satisfy the filter. See
 <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/Filter.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>Filter</code></a> for a description of the filter string syntax.
 
 <p>
 If <code>filter</code> is <code>null</code>, all registered services
 are considered to match the filter. If <code>filter</code> cannot be
 parsed, an <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>InvalidSyntaxException</code></a> will be thrown with a human
 readable message where the filter became unparsable.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">getRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">getRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>idFilter</code> - an array of ID instances that will restrict the search for
            matching container ids If null, all remote containers will be
            considered in search for matching IRemoteServiceReference
            instances. May be <code>null</code>.</dd>
<dd><code>clazz</code> - the fully qualified name of the interface class that describes
            the desired service. Must not be <code>null</code>.</dd>
<dd><code>filter</code> - The filter criteria. May be <code>null</code>.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Array of IRemoteServiceReferences matching given search criteria or 
            <code>null</code> if no services are found that match the search.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink">InvalidSyntaxException</a></code> - If filter contains an invalid filter string that cannot be parsed.</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="registerRemoteService(java.lang.String[],java.lang.Object,java.util.Dictionary)">registerRemoteService</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType"><a href="../../../remoteservice/IRemoteServiceRegistration.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceRegistration</a></span>&nbsp;<span class="memberName">registerRemoteService</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>[]&nbsp;clazzes,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a>&nbsp;service,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Dictionary.html?is-external=true" title="class or interface in java.util" class="externalLink">Dictionary</a>&nbsp;properties)</span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#registerRemoteService(java.lang.String%5B%5D,java.lang.Object,java.util.Dictionary)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Register a new remote service. This method is to be called by the service
 server...i.e. the client that wishes to make available a service to other
 client within this container.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#registerRemoteService(java.lang.String%5B%5D,java.lang.Object,java.util.Dictionary)">registerRemoteService</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceHost.html#registerRemoteService(java.lang.String%5B%5D,java.lang.Object,java.util.Dictionary)">registerRemoteService</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceHost.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceHost</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>clazzes</code> - the interface classes that the service exposes to remote
            clients. Must not be <code>null</code> and must not be an
            empty array.</dd>
<dd><code>service</code> - the service object.  Under normal conditions this object must
            <ul><li>not be <code>null</code></li>
            <li>implement all of the classes specified by the first parameter</li>
            </ul>
            The only situation when the service object may be <code>null</code> is if
            the service property <a href="../../../remoteservice/Constants.html#SERVICE_REGISTER_PROXY"><code>Constants.SERVICE_REGISTER_PROXY</code></a> is set
            in the properties.  If <a href="../../../remoteservice/Constants.html#SERVICE_REGISTER_PROXY"><code>Constants.SERVICE_REGISTER_PROXY</code></a> is set
            in the properties parameter (to an arbitrary value), then the service
            object may then be <code>null</code>.</dd>
<dd><code>properties</code> - to be associated with service</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>IRemoteServiceRegistration the service registration. Will not
         return <code>null</code> .</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="removeRemoteServiceListener(org.eclipse.ecf.remoteservice.IRemoteServiceListener)">removeRemoteServiceListener</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType">void</span>&nbsp;<span class="memberName">removeRemoteServiceListener</span>&#8203;(<span class="arguments"><a href="../../../remoteservice/IRemoteServiceListener.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceListener</a>&nbsp;listener)</span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#removeRemoteServiceListener(org.eclipse.ecf.remoteservice.IRemoteServiceListener)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Remove remote service registration/unregistration listener for this
 container.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#removeRemoteServiceListener(org.eclipse.ecf.remoteservice.IRemoteServiceListener)">removeRemoteServiceListener</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#removeRemoteServiceListener(org.eclipse.ecf.remoteservice.IRemoteServiceListener)">removeRemoteServiceListener</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceHost.html#removeRemoteServiceListener(org.eclipse.ecf.remoteservice.IRemoteServiceListener)">removeRemoteServiceListener</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceHost.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceHost</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>listener</code> - to remove. Must not be <code>null</code> .</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="ungetRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)">ungetRemoteService</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType">boolean</span>&nbsp;<span class="memberName">ungetRemoteService</span>&#8203;(<span class="arguments"><a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a>&nbsp;ref)</span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#ungetRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Unget IRemoteServiceReference. Release all resources associated with the
 given IRemoteServiceReference. This method should be called by users of
 the IRemoteServiceReference that have previously called
 <a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)"><code>IRemoteServiceContainerAdapter.getRemoteService(IRemoteServiceReference)</code></a>.
 If this method returns true, then the previously used IRemoteService will
 no longer be usable.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#ungetRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)">ungetRemoteService</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#ungetRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)">ungetRemoteService</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>ref</code> - the IRemoteServiceReference to unget</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>true if unget successful, false if not. If this method returns
         true, then the IRemoteService instance previously retrieved via
         the given IRemoteServiceReference instance provided will no
         longer be usable.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteService(org.eclipse.ecf.remoteservice.IRemoteServiceReference)"><code>IRemoteServiceContainerAdapter.getRemoteService(IRemoteServiceReference)</code></a></dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID[],java.lang.String,java.lang.String)">asyncGetRemoteServiceReferences</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType">org.eclipse.equinox.concurrent.future.IFuture</span>&nbsp;<span class="memberName">asyncGetRemoteServiceReferences</span>&#8203;(<span class="arguments"><a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>[]&nbsp;idFilter,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Asynchronously returns an array of <code>IRemoteServiceReference</code> objects. The
 returned array of <code>IRemoteServiceReference</code> objects contains
 services that were registered under the specified class and match the
 specified idFilter, and filter criteria.
 <p>
 Note this method assumes that the enclosing container has previously
 been connected, and uses the idFilter to filter among targets within the
 previously connected set of container IDs.  To request connection as 
 part of reference lookup, see <a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)"><code>IRemoteServiceContainerAdapter.getRemoteServiceReferences(ID, String, String)</code></a>.
 </p>
 <p>
 The IFuture is returned immediately, and subsequent calls to <code>IFuture.get()</code>
 or <code>IFuture.get(long)</code> will return the actual results received.  The type of
 the Object returned from <code>IFuture.get()</code> will be IRemoteServiceReference [].
 
 <p>
 The list is valid at the time of the call to this method, however since
 the Framework is a very dynamic environment, services can be modified or
 unregistered at anytime.
 
 <p>
 <code>idFilter</code> is used to select a registered services that were
 registered by a given set of containers with id in idFilter. Only
 services exposed by a container with id in idFilter will be returned.
 
 <p>
 If <code>idFilter</code> is <code>null</code>, all containers are
 considered to match the filter.
 
 <p>
 <code>filter</code> is used to select the registered service whose
 properties objects contain keys and values which satisfy the filter. See
 <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/Filter.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>Filter</code></a> for a description of the filter string syntax.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">asyncGetRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">asyncGetRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>idFilter</code> - an array of ID instances that will restrict the search for
            matching container ids If null, all remote containers will be
            considered in search for matching IRemoteServiceReference
            instances. May be <code>null</code>.</dd>
<dd><code>clazz</code> - the fully qualified name of the interface class that describes
            the desired service. Must not be <code>null</code>.</dd>
<dd><code>filter</code> - The filter criteria. May be <code>null</code>.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>IFuture that through subsequent calls to IFuture#get() will return
         IRemoteServiceReference [] with IRemoteServiceReferences matching given search criteria. 
         Will not return <code>null</code>.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>3.0</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="getRemoteServiceNamespace()">getRemoteServiceNamespace</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType"><a href="../../../core/identity/Namespace.html" title="class in org.eclipse.ecf.core.identity">Namespace</a></span>&nbsp;<span class="memberName">getRemoteServiceNamespace</span>()</div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceNamespace()">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Get namespace to use for this remote service provider.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#getRemoteServiceNamespace()">getRemoteServiceNamespace</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceNamespace()">getRemoteServiceNamespace</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceHost.html#getRemoteServiceNamespace()">getRemoteServiceNamespace</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceHost.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceHost</a></code></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Namespace to use for creating IRemoteServiceID for this remote service provider.  Will
 not return <code>null</code>.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>3.0</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="createRemoteFilter(java.lang.String)">createRemoteFilter</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType"><a href="../../../remoteservice/IRemoteFilter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteFilter</a></span>&nbsp;<span class="memberName">createRemoteFilter</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</span>
                                 throws <span class="exceptions"><a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink">InvalidSyntaxException</a></span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#createRemoteFilter(java.lang.String)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Creates a <code>IRemoteFilter</code> object. This <code>IRemoteFilter</code> object may
 be used to match a <code>IRemoteServiceReference</code> object or a
 <code>Dictionary</code> object.
 
 <p>
 If the filter cannot be parsed, an <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>InvalidSyntaxException</code></a> will be
 thrown with a human readable message where the filter became unparsable.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#createRemoteFilter(java.lang.String)">createRemoteFilter</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#createRemoteFilter(java.lang.String)">createRemoteFilter</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>filter</code> - The filter string.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>A <code>IRemoteFilter</code> object encapsulating the filter string.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink">InvalidSyntaxException</a></code> - If <code>filter</code> contains an invalid
         filter string that cannot be parsed.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>3.0</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd>"Framework specification for a description of the filter string syntax.", 
<a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/FrameworkUtil.html?is-external=true#createFilter(java.lang.String)" title="class or interface in org.osgi.framework" class="externalLink"><code>FrameworkUtil.createFilter(String)</code></a></dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="getRemoteServiceReference(org.eclipse.ecf.remoteservice.IRemoteServiceID)">getRemoteServiceReference</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType"><a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a></span>&nbsp;<span class="memberName">getRemoteServiceReference</span>&#8203;(<span class="arguments"><a href="../../../remoteservice/IRemoteServiceID.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceID</a>&nbsp;serviceID)</span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReference(org.eclipse.ecf.remoteservice.IRemoteServiceID)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Get the remote service reference known to this container for the given IRemoteServiceID.  Note that
 this method must be guaranteed not to block by the provider implementation.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#getRemoteServiceReference(org.eclipse.ecf.remoteservice.IRemoteServiceID)">getRemoteServiceReference</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReference(org.eclipse.ecf.remoteservice.IRemoteServiceID)">getRemoteServiceReference</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>serviceID</code> - the serviceID to retrieve the IRemoteServiceReference for.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>IRemoteServiceReference the remote service reference associated with the given serviceID.
 Will return <code>null</code> if no IRemoteServiceReference found for the given serviceID.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>3.0</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="getRemoteServiceID(org.eclipse.ecf.core.identity.ID,long)">getRemoteServiceID</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType"><a href="../../../remoteservice/IRemoteServiceID.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceID</a></span>&nbsp;<span class="memberName">getRemoteServiceID</span>&#8203;(<span class="arguments"><a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>&nbsp;containerID,
long&nbsp;containerRelativeID)</span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceID(org.eclipse.ecf.core.identity.ID,long)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Get a remote service ID from a containerID and a containerRelative long value.  Will return a non-null value
 if the IRemoteServiceRegistration/Reference is currently 'known' to this container adapter.  <code>null</code> 
 if not.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#getRemoteServiceID(org.eclipse.ecf.core.identity.ID,long)">getRemoteServiceID</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceID(org.eclipse.ecf.core.identity.ID,long)">getRemoteServiceID</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceHost.html#getRemoteServiceID(org.eclipse.ecf.core.identity.ID,long)">getRemoteServiceID</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceHost.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceHost</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>containerID</code> - the containerID that is the server/host for the remote service.  Must not be <code>null</code>.  This 
 must be the containerID for the <b>server</b>/host of the remote service.</dd>
<dd><code>containerRelativeID</code> - the long value identifying the remote service relative to the container ID.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>IRemoteServiceID instance if the associated IRemoteServiceRegistration/Reference is known to this container
 adapter, <code>null</code> if it is not.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>3.0</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="setConnectContextForAuthentication(org.eclipse.ecf.core.security.IConnectContext)">setConnectContextForAuthentication</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType">void</span>&nbsp;<span class="memberName">setConnectContextForAuthentication</span>&#8203;(<span class="arguments"><a href="../../../core/security/IConnectContext.html" title="interface in org.eclipse.ecf.core.security">IConnectContext</a>&nbsp;connectContext)</span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#setConnectContextForAuthentication(org.eclipse.ecf.core.security.IConnectContext)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Set connect context for authentication upon subsequent calls to
 <a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)"><code>IRemoteServiceContainerAdapter.getRemoteServiceReferences(ID[], String, String)</code></a> or <a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)"><code>IRemoteServiceContainerAdapter.asyncGetRemoteServiceReferences(ID[], String, String)</code></a>. This
 method should be called with a non-null connectContext in order to allow
 authentication to occur during.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#setConnectContextForAuthentication(org.eclipse.ecf.core.security.IConnectContext)">setConnectContextForAuthentication</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#setConnectContextForAuthentication(org.eclipse.ecf.core.security.IConnectContext)">setConnectContextForAuthentication</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>connectContext</code> - the connect context to use for authenticating.
            If <code>null</code>, then no authentication will be
            attempted.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>3.0</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)">getRemoteServiceReferences</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType"><a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a>[]</span>&nbsp;<span class="memberName">getRemoteServiceReferences</span>&#8203;(<span class="arguments"><a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>&nbsp;target,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</span>
                                                     throws <span class="exceptions"><a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink">InvalidSyntaxException</a>,
<a href="../../../core/ContainerConnectException.html" title="class in org.eclipse.ecf.core">ContainerConnectException</a></span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block"><p>
 Returns an array of <code>IRemoteServiceReference</code> objects. The
 returned array of <code>IRemoteServiceReference</code> objects contains
 services that were registered under the specified class and match the
 specified idFilter, and filter criteria.
 </p>
 <p>
 The list is valid at the time of the call to this method, however since
 the Framework is a very dynamic environment, services can be modified or
 unregistered at anytime.
 </p>
 <p>target is a remote container to connect to.</p>
 <p>
 <code>filter</code> is used to select the registered service whose
 properties objects contain keys and values which satisfy the filter. See
 <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/Filter.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>Filter</code></a> for a description of the filter string syntax.
 
 <p>
 If <code>filter</code> is <code>null</code>, all registered services
 are considered to match the filter. If <code>filter</code> cannot be
 parsed, an <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>InvalidSyntaxException</code></a> will be thrown with a human
 readable message where the filter became unparsable.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)">getRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)">getRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>target</code> - an target to connect to if enclosing container is not already 
            connected.  May be <code>null</code>.</dd>
<dd><code>clazz</code> - the fully qualified name of the interface class that describes
            the desired service. Must not be <code>null</code>.</dd>
<dd><code>filter</code> - The filter criteria. May be <code>null</code>.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Array of IRemoteServiceReferences matching given search criteria or 
            <code>null</code> if no services are found that match the search.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink">InvalidSyntaxException</a></code> - If filter contains an invalid filter string that cannot be parsed.</dd>
<dd><code><a href="../../../core/ContainerConnectException.html" title="class in org.eclipse.ecf.core">ContainerConnectException</a></code> - if container cannot connect</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>3.0</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)">asyncGetRemoteServiceReferences</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType">org.eclipse.equinox.concurrent.future.IFuture</span>&nbsp;<span class="memberName">asyncGetRemoteServiceReferences</span>&#8203;(<span class="arguments"><a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>&nbsp;target,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Asynchronously returns an array of <code>IRemoteServiceReference</code> objects. The
 returned array of <code>IRemoteServiceReference</code> objects contains
 services that were registered under the specified class and match the
 specified idFilter, and filter criteria.
 <p>
 The IFuture is returned immediately, and subsequent calls to <code>IFuture.get()</code>
 or <code>IFuture.get(long)</code> will return the actual results received.  The type of
 the Object returned from <code>IFuture.get()</code> will be IRemoteServiceReference [].
 
 <p>
 The list is valid at the time of the call to this method, however since
 the Framework is a very dynamic environment, services can be modified or
 unregistered at anytime.
 
 <p>
 <code>idFilter</code> is used to select a registered services that were
 registered by a given set of containers with id in idFilter. Only
 services exposed by a container with id in idFilter will be returned.
 
 <p>target is a remote container to connect to.</p>
 
 <p>
 <code>filter</code> is used to select the registered service whose
 properties objects contain keys and values which satisfy the filter. See
 <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/Filter.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>Filter</code></a> for a description of the filter string syntax.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)">asyncGetRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)">asyncGetRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>target</code> - an target to connect to if enclosing container is not already 
            connected.  May be <code>null</code>.</dd>
<dd><code>clazz</code> - the fully qualified name of the interface class that describes
            the desired service. Must not be <code>null</code>.</dd>
<dd><code>filter</code> - The filter criteria. May be <code>null</code>.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>IFuture that through subsequent calls to IFuture#get() will return
         IRemoteServiceReference [] with IRemoteServiceReferences matching given search criteria. 
         Will not return <code>null</code>.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>3.0</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="getAllRemoteServiceReferences(java.lang.String,java.lang.String)">getAllRemoteServiceReferences</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType"><a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a>[]</span>&nbsp;<span class="memberName">getAllRemoteServiceReferences</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</span>
                                                        throws <span class="exceptions"><a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink">InvalidSyntaxException</a></span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getAllRemoteServiceReferences(java.lang.String,java.lang.String)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block"><p>
 Returns an array of <code>IRemoteServiceReference</code> objects. The
 returned array of <code>IRemoteServiceReference</code> objects contains
 services that were registered under the specified class, or if the clazz
 parameter is <code>null</code> all services registered.
 </p>
 <p>
 The list is valid at the time of the call to this method, however since
 the remote service container is a very dynamic environment, services can be modified or
 unregistered at anytime.
 </p>
 <p>
 <code>filter</code> is used to select the registered service whose
 properties objects contain keys and values which satisfy the filter. See
 <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/Filter.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>Filter</code></a> for a description of the filter string syntax.
 </p>
 <p>
 If <code>filter</code> is <code>null</code>, all registered services
 are considered to match the filter. If <code>filter</code> cannot be
 parsed, an <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>InvalidSyntaxException</code></a> will be thrown with a human
 readable message where the filter became unparsable.
 </p></div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#getAllRemoteServiceReferences(java.lang.String,java.lang.String)">getAllRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getAllRemoteServiceReferences(java.lang.String,java.lang.String)">getAllRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>clazz</code> - the fully qualified name of the interface class that describes
            the desired service. May be <code>null</code>.</dd>
<dd><code>filter</code> - The filter criteria. May be <code>null</code>.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Array of IRemoteServiceReferences matching given search criteria or 
            <code>null</code> if no services are found that match the search.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink">InvalidSyntaxException</a></code> - If filter contains an invalid filter string that cannot be parsed.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>3.0</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID[],java.lang.String,java.lang.String)">getRemoteServiceReferences</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType"><a href="../../../remoteservice/IRemoteServiceReference.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceReference</a>[]</span>&nbsp;<span class="memberName">getRemoteServiceReferences</span>&#8203;(<span class="arguments"><a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>&nbsp;target,
<a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>[]&nbsp;idFilter,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</span>
                                                     throws <span class="exceptions"><a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink">InvalidSyntaxException</a>,
<a href="../../../core/ContainerConnectException.html" title="class in org.eclipse.ecf.core">ContainerConnectException</a></span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Returns an array of <code>IRemoteServiceReference</code> objects. The
 returned array of <code>IRemoteServiceReference</code> objects contains
 services that were registered under the specified class and match the
 specified idFilter, and filter criteria.
 <p>
 Note this method assumes that the enclosing container has previously
 been connected, and uses the idFilter to filter among targets within the
 previously connected set of container IDs.  To request connection as 
 part of reference lookup, see <a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,java.lang.String,java.lang.String)"><code>IRemoteServiceContainerAdapter.getRemoteServiceReferences(ID, String, String)</code></a>.
 </p>
 
 <p>
 The list is valid at the time of the call to this method, however since
 the Framework is a very dynamic environment, services can be modified or
 unregistered at anytime.
 
 <p><code>target</code> is a remote container to connect to.  If <code>null</code>, no connection attempt is made.</p>
 <p>
 <code>idFilter</code> is used to select a registered services that were
 registered by a given set of containers with id in idFilter. Only
 services exposed by a container with id in idFilter will be returned.  If <code>idFilter</code> is <code>null</code>, all containers are
 considered to match the filter.
 
 <p>
 <code>filter</code> is used to select the registered service whose
 properties objects contain keys and values which satisfy the filter. See
 <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/Filter.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>Filter</code></a> for a description of the filter string syntax.
 If <code>filter</code> is <code>null</code>, all registered services
 are considered to match the filter. If <code>filter</code> cannot be
 parsed, an <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>InvalidSyntaxException</code></a> will be thrown with a human
 readable message where the filter became unparsable.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">getRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#getRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">getRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>target</code> - a target container to connect to if enclosing container is not already 
            connected.  May be <code>null</code>.</dd>
<dd><code>idFilter</code> - an array of ID instances that will restrict the search for
            matching container ids If null, all remote containers will be
            considered in search for matching IRemoteServiceReference
            instances. May be <code>null</code>.</dd>
<dd><code>clazz</code> - the fully qualified name of the interface class that describes
            the desired service. Must not be <code>null</code>.</dd>
<dd><code>filter</code> - The filter criteria. May be <code>null</code>.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Array of IRemoteServiceReferences matching given search criteria or 
            <code>null</code> if no services are found that match the search.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink">InvalidSyntaxException</a></code> - If filter contains an invalid filter string that cannot be parsed.</dd>
<dd><code><a href="../../../core/ContainerConnectException.html" title="class in org.eclipse.ecf.core">ContainerConnectException</a></code> - if container cannot connect</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>3.4</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID[],java.lang.String,java.lang.String)">asyncGetRemoteServiceReferences</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType">org.eclipse.equinox.concurrent.future.IFuture</span>&nbsp;<span class="memberName">asyncGetRemoteServiceReferences</span>&#8203;(<span class="arguments"><a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>&nbsp;target,
<a href="../../../core/identity/ID.html" title="interface in org.eclipse.ecf.core.identity">ID</a>[]&nbsp;idFilter,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;clazz,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filter)</span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Asynchronously returns an array of <code>IRemoteServiceReference</code> objects. The
 returned array of <code>IRemoteServiceReference</code> objects contains
 services that were registered under the specified class and match the
 specified idFilter, and filter criteria.
 <p>
 The IFuture is returned immediately, and subsequent calls to <code>IFuture.get()</code>
 or <code>IFuture.get(long)</code> will return the actual results received.  The type of
 the Object returned from <code>IFuture.get()</code> will be IRemoteServiceReference [].
 
 <p>
 The list is valid at the time of the call to this method, however since
 the Framework is a very dynamic environment, services can be modified or
 unregistered at anytime.
 
 <p><code>target</code> is a remote container to connect to.  If <code>null</code>, no connection attempt is made.</p>
 <p>
 <code>idFilter</code> is used to select a registered services that were
 registered by a given set of containers with id in idFilter. Only
 services exposed by a container with id in idFilter will be returned.  If <code>idFilter</code> is <code>null</code>, all containers are
 considered to match the filter.
 
 <p>
 <code>filter</code> is used to select the registered service whose
 properties objects contain keys and values which satisfy the filter. See
 <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/Filter.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>Filter</code></a> for a description of the filter string syntax.
 If <code>filter</code> is <code>null</code>, all registered services
 are considered to match the filter. If <code>filter</code> cannot be
 parsed, an <a href="https://docs.osgi.org/javadoc/osgi.core/7.0.0/org/osgi/framework/InvalidSyntaxException.html?is-external=true" title="class or interface in org.osgi.framework" class="externalLink"><code>InvalidSyntaxException</code></a> will be thrown with a human
 readable message where the filter became unparsable.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceConsumer.html#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">asyncGetRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceConsumer.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceConsumer</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#asyncGetRemoteServiceReferences(org.eclipse.ecf.core.identity.ID,org.eclipse.ecf.core.identity.ID%5B%5D,java.lang.String,java.lang.String)">asyncGetRemoteServiceReferences</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>target</code> - an target to connect to if enclosing container is not already 
            connected.  May be <code>null</code>.</dd>
<dd><code>idFilter</code> - an array of ID instances that will restrict the search for
            matching container ids If null, all remote containers will be
            considered in search for matching IRemoteServiceReference
            instances. May be <code>null</code>.</dd>
<dd><code>clazz</code> - the fully qualified name of the interface class that describes
            the desired service. Must not be <code>null</code>.</dd>
<dd><code>filter</code> - The filter criteria. May be <code>null</code>.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>IFuture that through subsequent calls to IFuture#get() will return
         IRemoteServiceReference [] with IRemoteServiceReferences matching given search criteria. 
         Will not return <code>null</code>.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>3.4</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="setRemoteServiceCallPolicy(org.eclipse.ecf.remoteservice.IRemoteServiceCallPolicy)">setRemoteServiceCallPolicy</a></h3>
<div class="memberSignature"><span class="modifiers">public</span>&nbsp;<span class="returnType">boolean</span>&nbsp;<span class="memberName">setRemoteServiceCallPolicy</span>&#8203;(<span class="arguments"><a href="../../../remoteservice/IRemoteServiceCallPolicy.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceCallPolicy</a>&nbsp;policy)</span></div>
<div class="block"><span class="descfrmTypeLabel">Description copied from interface:&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#setRemoteServiceCallPolicy(org.eclipse.ecf.remoteservice.IRemoteServiceCallPolicy)">IRemoteServiceContainerAdapter</a></code></span></div>
<div class="block">Set the remote service call policy to enable authorization on remote service method calls</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html#setRemoteServiceCallPolicy(org.eclipse.ecf.remoteservice.IRemoteServiceCallPolicy)">setRemoteServiceCallPolicy</a></code>&nbsp;in interface&nbsp;<code><a href="../../../remoteservice/IRemoteServiceContainerAdapter.html" title="interface in org.eclipse.ecf.remoteservice">IRemoteServiceContainerAdapter</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>policy</code> - Implementation of <code>IRemoteServiceCallPolicy</code> containing authorization specific code</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd><code>true</code> if the underlying provider supports using the policy, <code>false</code> if
 it does not support using the policy.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>4.0</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
</div>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<nav role="navigation">
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a id="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/RemoteServiceContainer.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
<li><a href="../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
</div>
<a id="skip.navbar.bottom">
<!--   -->
</a>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</nav>
<p class="legalCopy"><small>Copyright &#169; 2004&#x2013;2020 <a href="https://www.eclipse.org/">Eclipse Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
