JCC
v1.0

jain.application.services.jcc
Interface JccProvider

All Superinterfaces:
JcpProvider

public interface JccProvider
extends JcpProvider

Provider of JAIN Call Control services. Note also that the JccProvider acts as a Factory to create standard EventFilter objects. These standard EventFilter objects should be provided by the JCC platform implementation. It is hoped that these filters will meet the needs of many applications, thus sparing them of the need to implement them explicitly. It is also possible that by implementing these on the JCC platform (rather than on the application platform) that the cost of remote filter queries can be eliminated thereby addressing the performance problems.

Hence, three standard filters and two filter combiners are proposed. The effect of these three standard filters and two filter combiners is to allow for address ranges in combination with event "masks". Using these methods, it is possible to create filters that return a given event disposition for address in specific ranges (with holes and overlaps), or for specific events, or a combination of both. It is also possible to make filters that combine standard and custom filters. This would make it possible to quickly determine the filter disposition in many common cases, using standard filters, and only call a custom filter is unusual cases. We later look at each of these standard filters individually.

Event Snapshots
By default, when a JcpProviderListener is added through JcpProvider.addProviderListener(JcpProviderListener), the first batch of events may be a "snapshot". That is, if the listener was added after state changes in the Provider, the first batch of events will inform the application of the current state of the Provider. Note that these snapshot events do NOT provide a history of all events on the Provider, rather they provide the minimum necessary information to bring the application up-to-date with the current state of the Provider.


Fields inherited from interface jain.application.services.jcp.JcpProvider
IN_SERVICE, OUT_OF_SERVICE, SHUTDOWN
 
Method Summary
 void addCallListener(JccCallListener calllistener, EventFilter filter)
          Add a call listener to all (future and current) call objects within the domain of this provider.
 void addCallListener(JcpCallListener calllistener)
          Add a call listener to all (future and current) call objects within the domain of this provider.
 void addCallLoadControlListener(CallLoadControlListener loadcontrollistener, EventFilter filter)
          Adds a listener to listen to load control related events.
 void addConnectionListener(JccConnectionListener connectionlistener, EventFilter filter)
          Add a connection listener to all connections under this JcpProvider.
 EventFilter createEventFilterAddressRange(java.lang.String lowAddress, java.lang.String highAddress, int matchDisposition, int nomatchDisposition)
          This method returns a standard EventFilter which is implemented by the JCC platform.
 EventFilter createEventFilterAddressRegEx(java.lang.String addressRegex, int matchDisposition, int nomatchDisposition)
          This method returns a standard EventFilter which is implemented by the JCC platform.
 EventFilter createEventFilterAnd(EventFilter[] filters, int nomatchDisposition)
          This method returns a standard EventFilter which is implemented by the JCC platform.
 EventFilter createEventFilterDestAddressRange(java.lang.String lowDestAddress, java.lang.String highDestAddress, int matchDisposition, int nomatchDisposition)
          This method returns a standard EventFilter which is implemented by the JCC platform.
 EventFilter createEventFilterDestAddressRegEx(java.lang.String destAddressRegex, int matchDisposition, int nomatchDisposition)
          This method returns a standard EventFilter which is implemented by the JCC platform.
 EventFilter createEventFilterEventSet(int[] blockEvents, int[] notifyEvents)
          This method returns a standard EventFilter which is implemented by the JCC platform.
 EventFilter createEventFilterOr(EventFilter[] filters, int nomatchDisposition)
          This method returns a standard EventFilter which is implemented by the JCC platform.
 EventFilter createEventFilterOrigAddressRange(java.lang.String lowOrigAddress, java.lang.String highOrigAddress, int matchDisposition, int nomatchDisposition)
          This method returns a standard EventFilter which is implemented by the JCC platform.
 EventFilter createEventFilterOrigAddressRegEx(java.lang.String origAddressRegex, int matchDisposition, int nomatchDisposition)
          This method returns a standard EventFilter which is implemented by the JCC platform.
 void removeCallListener(JcpCallListener calllistener)
          Removes a call listener that was previously registered.
 void removeCallLoadControlListener(CallLoadControlListener loadcontrollistener)
          Deregisters the load control listener.
 void removeConnectionListener(JcpConnectionListener connectionlistener)
          Removes a connection listener that was registered previously.
 void setCallLoadControl(JccAddress[] address, double duration, double[] mechanism, int[] treatment)
          This method imposes or removes load control on calls made to the specified addresses.
 
Methods inherited from interface jain.application.services.jcp.JcpProvider
addProviderListener, createCall, getAddress, getName, getState, removeProviderListener, shutdown
 

Method Detail

createEventFilterEventSet

public EventFilter createEventFilterEventSet(int[] blockEvents,
                                             int[] notifyEvents)
                                      throws ResourceUnavailableException,
                                             InvalidArgumentException
This method returns a standard EventFilter which is implemented by the JCC platform. This method takes two arrays of eventID integers (values returned from JcpEvent.getID()). For event IDs in the blockEvents array, the filter returns EventFilter.EVENT_BLOCK. For event IDs in notifyEvents, the filter returns EventFilter.EVENT_NOTIFY. If any event ID is not listed in one of the two arrays, the filter returns EventFilter.EVENT_DISCARD. The application is supposed to ensure that an event ID is not listed in more than one array. If done, the filter may return any one of the listed event dispositions.
Returns:
EventFilter standard EventFilter provided by the JCC platform to enable filtering of events based on the application's requirements.
Throws:
ResourceUnavailableException - An internal resource for completing this call is unavailable.
InvalidArgumentException - One or more of the provided argument is not valid

createEventFilterAddressRange

public EventFilter createEventFilterAddressRange(java.lang.String lowAddress,
                                                 java.lang.String highAddress,
                                                 int matchDisposition,
                                                 int nomatchDisposition)
                                          throws ResourceUnavailableException,
                                                 InvalidArgumentException
This method returns a standard EventFilter which is implemented by the JCC platform. This requires a complete ordering of values in JcpAddress. The ordering is arranged by defining the order to be by JcpAddress.getName()'s string order. For each address in the call obtained by JcpCallEvent.getCall(), apply the following. If the address is between lowAddress and highAddress (inclusive), the filter returns the value matchDisposition. If the address is not in the range specified, then return nomatchDisposition.
Parameters:
lowAddress - denotes the JcpAddress which corresponds to the low end of the range.
highAddress - denotes the JcpAddress which corresponds to the high end of the range.
matchDisposition - indicates the disposition of a JCC related event occurring on a JcpAddress which forms part of the range specified. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
nomatchDisposition - indicates the disposition of a JCC related event occurring on a JcpAddress which DOES not form part of the range specified. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
Returns:
EventFilter standard EventFilter provided by the JCC platform to enable filtering of events based on the application's requirements.
Throws:
ResourceUnavailableException - An internal resource for completing this call is unavailable.
InvalidArgumentException - One or more of the provided argument is not valid

createEventFilterAddressRegEx

public EventFilter createEventFilterAddressRegEx(java.lang.String addressRegex,
                                                 int matchDisposition,
                                                 int nomatchDisposition)
                                          throws ResourceUnavailableException,
                                                 InvalidArgumentException
This method returns a standard EventFilter which is implemented by the JCC platform. This requires a complete ordering of values in JcpAddress. The ordering is arranged by defining the order to be by JcpAddress.getName()'s string order. For each address in the call obtained by JcpCallEvent.getCall(), apply the following. Obtain a string using address.getName(). If this string matches the regular expression addressRegex, the filter returns the value matchDisposition. For the purpose of this specification, the platform will use the Perl5 regular expressions. If no such addresses are matched, then return nomatchDisposition.
Parameters:
addressRegex - denotes the regular expression.
matchDisposition - indicates the disposition of a JCC related event if the name of the JcpAddress matches the regular expression. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
nomatchDisposition - indicates the disposition of a JCC related event if the name of the JcpAddress DOES not match the regular expression. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
Returns:
EventFilter standard EventFilter provided by the JCC platform to enable filtering of events based on the application's requirements.
Throws:
ResourceUnavailableException - An internal resource for completing this call is unavailable.
InvalidArgumentException - One or more of the provided argument is not valid

createEventFilterOr

public EventFilter createEventFilterOr(EventFilter[] filters,
                                       int nomatchDisposition)
                                throws ResourceUnavailableException,
                                       InvalidArgumentException
This method returns a standard EventFilter which is implemented by the JCC platform. This filter takes as input an array of EventFilters. For a given event, it applies the filters in order. If a filter returns nomatchDisposition, then the next filter is tested. If a filter returns any other disposition, then the filter returns this value and does no further filter evaluation. This would normally be called with nomatchDisposition set to EventFilter.EVENT_DISCARD to process any event (either by notifying or blocking) that any filter wants to process (logical OR).
Parameters:
filters - is an array of EventFilters.
nomatchDisposition - indicates the disposition of a JCC related event. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
Returns:
EventFilter standard EventFilter provided by the JCC platform to enable filtering of events based on the application's requirements.
Throws:
ResourceUnavailableException - An internal resource for completing this call is unavailable.
InvalidArgumentException - One or more of the provided argument is not valid

createEventFilterAnd

public EventFilter createEventFilterAnd(EventFilter[] filters,
                                        int nomatchDisposition)
                                 throws ResourceUnavailableException,
                                        InvalidArgumentException
This method returns a standard EventFilter which is implemented by the JCC platform. This filter takes as input an array of EventFilters. For a given event, it applies the filters in order. If the values returned from all filters are the same, then this value is returned as the filter value. Otherwise, the filter returns nomatchDisposition. This means that as soon as any filter returns nomatchDisposition, or as soon as two filters return different values, the filter can immediately return nomatchDisposition. This would normally be called with nomatchDisposition set to EventFilter.EVENT_DISCARD to discard any events that any filter wants to discard (logical AND).
Parameters:
filters - is an array of EventFilters.
nomatchDisposition - indicates the disposition of a JCC related event. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
Returns:
EventFilter standard EventFilter provided by the JCC platform to enable filtering of events based on the application's requirements.
Throws:
ResourceUnavailableException - An internal resource for completing this call is unavailable.
InvalidArgumentException - One or more of the provided argument is not valid

createEventFilterDestAddressRange

public EventFilter createEventFilterDestAddressRange(java.lang.String lowDestAddress,
                                                     java.lang.String highDestAddress,
                                                     int matchDisposition,
                                                     int nomatchDisposition)
                                              throws ResourceUnavailableException,
                                                     InvalidArgumentException
This method returns a standard EventFilter which is implemented by the JCC platform. This requires a complete ordering of values in JcpAddress. The ordering is arranged by defining the order to be by JcpAddress.getName()'s string order. For each originating connection, apply the following. Obtain a string using getDestinationAddress(). If the destination address is between lowDestAddress and highDestAddress (inclusive), the filter returns the value matchDisposition. If the address is not in the specified range or the filter is not operating on an originating connection, then return nomatchDisposition.
Parameters:
lowDestAddress - denotes the destination JcpAddress which corresponds to the low end of the range.
highDestAddress - denotes the destination JcpAddress which corresponds to the high end of the range.
matchDisposition - indicates the disposition of a JCC related event occurring on a JcpAddress which forms part of the range specified. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
nomatchDisposition - indicates the disposition of a JCC related event occurring on a JcpAddress which DOES not form part of the range specified. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
Returns:
EventFilter standard EventFilter provided by the JCC platform to enable filtering of events based on the application's requirements.
Throws:
ResourceUnavailableException - An internal resource for completing this call is unavailable.
InvalidArgumentException - One or more of the provided argument is not valid

createEventFilterDestAddressRegEx

public EventFilter createEventFilterDestAddressRegEx(java.lang.String destAddressRegex,
                                                     int matchDisposition,
                                                     int nomatchDisposition)
                                              throws ResourceUnavailableException,
                                                     InvalidArgumentException
This method returns a standard EventFilter which is implemented by the JCC platform. This requires a complete ordering of values in JcpAddress. The ordering is arranged by defining the order to be by JcpAddress.getName()'s string order. For each originating connection, apply the following. Obtain a string using getDestinationAddress(): If this string matches the regular expression destAddressRegex, the filter returns the value matchDisposition. For the purpose of this specification, the platform will use the Perl5 regular expressions. If no such addresses are matched or the filter is not operating on an originating connection, then return nomatchDisposition.
Parameters:
destAddressRegex - denotes the regular expression for the destination address.
matchDisposition - indicates the disposition of a JCC related event if the name of the JcpAddress matches the regular expression. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
nomatchDisposition - indicates the disposition of a JCC related event if the name of the JcpAddress DOES not match the regular expression. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
Returns:
EventFilter standard EventFilter provided by the JCC platform to enable filtering of events based on the application's requirements.
Throws:
ResourceUnavailableException - An internal resource for completing this call is unavailable.
InvalidArgumentException - One or more of the provided argument is not valid

createEventFilterOrigAddressRange

public EventFilter createEventFilterOrigAddressRange(java.lang.String lowOrigAddress,
                                                     java.lang.String highOrigAddress,
                                                     int matchDisposition,
                                                     int nomatchDisposition)
                                              throws ResourceUnavailableException,
                                                     InvalidArgumentException
This method returns a standard EventFilter which is implemented by the JCC platform. This requires a complete ordering of values in JcpAddress. The ordering is arranged by defining the order to be by JcpAddress.getName()'s string order. For each destination connection, apply the following. Obtain a string using getOriginatingAddress().getName(). If the destination address is between lowOrigAddress and highOrigAddress (inclusive), the filter returns the value matchDisposition. If the address is not in the specified range or the filter is not operating on a terminating connection, then return nomatchDisposition.
Parameters:
lowOrigAddress - denotes the originating JcpAddress which corresponds to the low end of the range.
highOrigAddress - denotes the originating JcpAddress which corresponds to the high end of the range.
matchDisposition - indicates the disposition of a JCC related event occurring on a JcpAddress which forms part of the range specified. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
nomatchDisposition - indicates the disposition of a JCC related event occurring on a JcpAddress which DOES not form part of the range specified. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
Returns:
EventFilter standard EventFilter provided by the JCC platform to enable filtering of events based on the application's requirements.
Throws:
ResourceUnavailableException - An internal resource for completing this call is unavailable.
InvalidArgumentException - One or more of the provided argument is not valid

createEventFilterOrigAddressRegEx

public EventFilter createEventFilterOrigAddressRegEx(java.lang.String origAddressRegex,
                                                     int matchDisposition,
                                                     int nomatchDisposition)
                                              throws ResourceUnavailableException,
                                                     InvalidArgumentException
This method returns a standard EventFilter which is implemented by the JCC platform. This requires a complete ordering of values in JcpAddress. The ordering is arranged by defining the order to be by JcpAddress.getName()'s string order. For each originating connection, apply the following. Obtain a string using getOriginatingAddress().getName(): If this string matches the regular expression origAddressRegex, the filter returns the value matchDisposition. For the purpose of this specification, the platform will use the Perl5 regular expressions. If no such addresses are matched or the filter is not operating on a terminating connection, then return nomatchDisposition.
Parameters:
origAddressRegex - denotes the regular expression for the originating address.
matchDisposition - indicates the disposition of a JCC related event if the name of the JcpAddress matches the regular expression. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
nomatchDisposition - indicates the disposition of a JCC related event if the name of the JcpAddress DOES not match the regular expression. This should be one of the legal dispositions namely, EventFilter.EVENT_BLOCK, EventFilter.EVENT_DISCARD or EventFilter.EVENT_NOTIFY.
Returns:
EventFilter standard EventFilter provided by the JCC platform to enable filtering of events based on the application's requirements.
Throws:
ResourceUnavailableException - An internal resource for completing this call is unavailable.
InvalidArgumentException - One or more of the provided argument is not valid

addCallListener

public void addCallListener(JcpCallListener calllistener)
                     throws MethodNotSupportedException,
                            ResourceUnavailableException
Add a call listener to all (future and current) call objects within the domain of this provider. If the listener is added to existing calls, the listener will receive event snapshots. The listener added with this method will receive events on the call for as long as the implementation can listen to the Call. In the case that the implementation can no longer observe the JcpCall, the listeners receives a JcpCallEvent.CALL_EVENT_TRANSMISSION_ENDED. The listener receives no more events after it receives the JcpCallEvent.CALL_EVENT_TRANSMISSION_ENDED.
Listener Lifetime
The JcpCallListener will receive events until one of the following occurs, whereupon the listener receives a JcpCallEvent.CALL_EVENT_TRANSMISSION_ENDED.
  1. The listener is removed by the application.
  2. The implementation can no longer monitor the call.
  3. The JcpCall has completed and moved into the JcpCall.INVALID state.
ConnectionListeners
Since JcpConnectionListener inherits from the JcpCallListener, it is also possible to add a JcpConnectionListener using this method. In such a case, connection events would also have to be reported to the registered listener in addition to the call events. Hence, it is expected that the JCC implementation uses instanceof checks in order to decide if only call events or both call and connection events have to be delivered to the listener. Note that a listener added by this method is expecting all the events without any filtering involved.
Multiple Invocations
If an application attempts to add an instance of an listener already present on this Call, then a repeated invocation will silently fail, i.e. multiple instances of an listener are not added and no exception will be thrown.
Parameters:
calllistener - JcpCallListener object that receives the specified events.
Throws:
MethodNotSupportedException - The method is not supported.
ResourceUnavailableException - The resource limit for the number of listeners has been exceeded.

addCallListener

public void addCallListener(JccCallListener calllistener,
                            EventFilter filter)
                     throws ResourceUnavailableException,
                            MethodNotSupportedException
Add a call listener to all (future and current) call objects within the domain of this provider. The listener added with this method will report events on the call for as long as the implementation can listen to the Call. In the case that the implementation can no longer observe the Call, the applications receive a JcpCallEvent.CALL_EVENT_TRANSMISSION_ENDED. The listener receives no more events after it receives the JcpCallEvent.CALL_EVENT_TRANSMISSION_ENDED. This method behaves identically to the method addCallListener( JcpCallListener) when the filter returns a EventFilter.EVENT_NOTIFY for all the events of interest.
Connection Events
A JccConnectionEvent extends JccCallEvent and a JccConnectionListener extends JccCallListener. Hence, a JccConnectionListener can also be added using this method. In such a case, events on the JccConnection objects associated with this JccCall object might have to be reported to the registered listener after consulting with the EventFilter. In summary the implementation must distinguish between JccCallListener and JccConnectionListener in order to determine the events for which the implementation must consult the corresponding EventFilter.
Listener Lifetime
The CallListener will receive events until one of the following occurs, whereupon the listener receives a JcpCallEvent.CALL_EVENT_TRANSMISSION_ENDED.

  1. The listener is removed by the application.
  2. The implementation can no longer monitor the call.
  3. The Call has completed and moved into the JcpCall.INVALID state.
Multiple Invocations
If an application attempts to add an instance of an listener already present on this Call, then a repeated invocation will silently fail, i.e. multiple instances of an listener are not added and no exception will be thrown. This though results in the filter being added in the last invocation being used by the implementation to filter events.
Parameters:
calllistener - JccCallListener object that receives the specified events.
filter - EventFilter that determines if an event should be delivered to the registered JcpCallListener.
Throws:
MethodNotSupportedException - The method is not supported.
ResourceUnavailableException - The resource limit for the number of listeners has been exceeded.

removeCallListener

public void removeCallListener(JcpCallListener calllistener)
Removes a call listener that was previously registered. The given listener will no longer receive events generated by the Call objects on this Provider. A JcpConnectionListener can also be removed using this method. Note that the listeners will stop receiving events for existing calls also. Also, if the listener is not currently registered with the Provider, then this method fails silently, i.e. no listener is removed and no exception is thrown.

Post-Conditions:

  1. CALL_EVENT_TRANSMISSION_ENDED is delivered to the application.
Parameters:
calllistener - JcpCallListener object to be removed.

addConnectionListener

public void addConnectionListener(JccConnectionListener connectionlistener,
                                  EventFilter filter)
                           throws ResourceUnavailableException,
                                  MethodNotSupportedException
Add a connection listener to all connections under this JcpProvider. This method behaves similar to the addCallListener(conListener, filter) method on this interface where conListener is in fact a JccConnectionListener. When conListener is not a JccConnectionListener but is only a JccCallListener, a similar behavior as addCallListener(conListener, newfilter) can be obtained with this method using a JccConnectionListener and a different EventFilter which filters all the JccConnection related events in addition to the events being filtered by newfilter. Note though that using this method only JccConnectionListeners can be added.

Note that registering for the same event multiple times should not result in multiple notifications being sent to an application for the same event. Rather, this will result in the last event filter being used to determine if events have to be delivered to the specified ConnectionListener.

Note that this method is also equivalent to addCallListener(JccConnectionListener,EventFilter). since parameter JcpConnectionListener is also a JcpCallListener. However note that JcpCallListeners which are not JcpConnectionListeners cannot be used as a parameter to this method.

Parameters:
connectionlistener - JccConnectionListener object that receives the specified events.
filter - EventFilter determines if the ConnectionEvent is to be delivered to the specified listener.
Throws:
MethodNotSupportedException - The listener cannot be added at this time.
ResourceUnavailableException - The resource limit for the number of listeners has been exceeded.

removeConnectionListener

public void removeConnectionListener(JcpConnectionListener connectionlistener)
Removes a connection listener that was registered previously. The given listener will no longer receive events generated by the JcpConnection objects related to this JcpProvider object through a JcpCall object. Also, if the listener is not currently registered with the JcpProvider, then this method fails silently, i.e. no listener is removed and no exception is thrown.

Post-Conditions:

  1. CALL_EVENT_TRANSMISSION_ENDED is delivered to the application.
Parameters:
connectionlistener - JcpConnectionListener object used in the call to addConnectionListener method.

setCallLoadControl

public void setCallLoadControl(JccAddress[] address,
                               double duration,
                               double[] mechanism,
                               int[] treatment)
                        throws MethodNotSupportedException
This method imposes or removes load control on calls made to the specified addresses.

The implementation can throw the MethodNotSupportedException if the platform does not support the load control functionality. Note that a policy object may be designed to define the policy to be implemented by the platform as a result of this method instead of defining the policy through the given parameters. This might be designed in the future specifications.

Parameters:
address - An array of size at most 2. a1[0] denotes the lower address of the range while a1[1] denotes the uper address of the range. Specifying only one element of the array implies that only an individual address is no longer to be the subject of the listener's attention. This constrains the range of addresses added to be numerical addresses. For addresses containing non-numerals such as email addresses, we expect that the application would have to add each address individually. Note that it is expected that adding a range of non-numerical addresses efficiently will be addressed in a future version of this specification.
duration - specifies the duration in milliseconds for which the load control should be set. Duration of 0 indicates that the load control should be removed. Duration of -1 indicates an infinite duration (i.e until disabled by the application). Duration of -2 indicates network default duration.
mechanism - specifies the load control mechanism to use (such as admitting one call per interval) and any necessary parameters. The contents of this parameter are ignored if the load control duration is set to zero.mech[0] symbolises the call admission rate of the call load control mechanism used. mech[1] symbolises the type of call load control mechanism to use. Thus, mech[0] gives the number of calls to be admitted per interval and mech[1] denotes the interval (in milliseconds) between calls that are admitted.
treatment - specifies the treatment of the calls that are not admitted.The contents of this parameter are ignored if the load control duration is set to zero.
Throws:
MethodNotSupportedException - If the implementation does not have load control functionality.

addCallLoadControlListener

public void addCallLoadControlListener(CallLoadControlListener loadcontrollistener,
                                       EventFilter filter)
                                throws MethodNotSupportedException,
                                       ResourceUnavailableException
Adds a listener to listen to load control related events. Note that the load control functionality has to have been specified separately using setCallLoadControl(JccAddress[],double,double[],int[]) method.
Parameters:
loadcontrollistener - The listener implementing the CallLoadControlListener interface which will receive all load control related events.
filter - EventFilter which specifies if the CallLoadControlEvent is to be delivered to the specified CallLoadControlListener.
Throws:
MethodNotSupportedException - The listener cannot be added at this time.
ResourceUnavailableException - The resource limit for the number of listeners has been exceeded.

removeCallLoadControlListener

public void removeCallLoadControlListener(CallLoadControlListener loadcontrollistener)
Deregisters the load control listener. This results in the listener not receiving any load control related events in the future. Note that if loadcontrollistener is not already registered using the setCallLoadControl(JccAddress[],double,double[],int[]) method then this method fails silently.
Parameters:
loadcontrollistener - The listener implementing the CallLoadControlListener interface which will receive all load control related events

JCC
v1.0

January 19, 2001
If you have any comments or queries, please mail them to m-JAIN-JCC@notes.cc.telcordia.com

Copyright - 2001 Sun Microsystems