Add a new transport candidate

@param cand The candidate to add
@throws NotConnectedException
@throws InterruptedException
421674
protected void addCandidate(TransportCandidate cand) throws NotConnectedException, InterruptedException {
        synchronized (candidates) {
            if (!candidates.contains(cand))
                candidates.add(cand);
        }

        // Notify the listeners
        triggerCandidateAdded(cand);
    }
1321284
@Override
    public void addConnectionListener(SICoreConnectionListener listener)
                    throws SIConnectionDroppedException,
                    SIConnectionUnavailableException {

        checkValid();

        _delegateConnection.addConnectionListener(listener);

    }
1243155
def add(self, personID, edgeID, pos, depart=DEPART_NOW, typeID="DEFAULT_PEDTYPE"):
        
        if depart > 0:
            depart *= 1000
        self._connection._beginMessage(tc.CMD_SET_PERSON_VARIABLE, tc.ADD, personID,
                                       1 + 4 + 1 + 4 + len(typeID) + 1 + 4 + len(edgeID) + 1 + 4 + 1 + 8)
        self._connection._string += struct.pack("!Bi", tc.TYPE_COMPOUND, 4)
        self._connection._packString(typeID)
        self._connection._packString(edgeID)
        self._connection._string += struct.pack("!Bi", tc.TYPE_INTEGER, depart)
        self._connection._string += struct.pack("!Bd", tc.TYPE_DOUBLE, pos)
        self._connection._sendExact()
544909
public void addHandler(final Handler handler, final boolean wait) throws InterruptedException, CouldNotPerformException {
        try {
            listener.addHandler(handler, wait);
        } catch (CouldNotPerformException ex) {
            throw new CouldNotPerformException("Could not register Handler!", ex);
        }
    }
707673
def add(self, ipaddr=None, proto=None, port=None, fields=None):
        
        return self.send.service_add(ipaddr, proto, port, fields)
274490
function PubNubConnection(transport, id, receive) {
  this.id = id;
  this.transport = transport;

  // ready state
  var me = this;
  this.ready = new Promise(function (resolve, reject) {
    transport.pubnub.subscribe({
      channel: id,
      message: function (message) {
        receive(message.from, message.message);
      },
      connect: function () {
        resolve(me);
      }
    });
  });
}
1367180
function(){
				if(data.modules.can) {
					canRoute = data.modules.can.route;
					routeData = canRoute.data;
					canReflect.onKeyValue(routeData, "statusCode", noop);
				}
			}
832922
public void setCCOWEnabled(boolean ccowEnabled) {
        this.ccowEnabled = ccowEnabled;

        if (!ccowEnabled && ccowContextManager != null) {
            ccowContextManager.suspend();
            ccowContextManager = null;
        }

        updateCCOWStatus();
    }
269132
private void addRemoteCandidate(TransportCandidate rc) {
        // Add the candidate to the list
        if (rc != null) {
            if (acceptableTransportCandidate(rc, offeredCandidates)) {
                synchronized (remoteCandidates) {
                    remoteCandidates.add(rc);
                }

                // Check if the new candidate can be used.
                checkRemoteCandidate(rc);
            }
        }
    }
818988
@Override
    public boolean add(RedisClusterNode redisClusterNode) {

        synchronized (partitions) {
            LettuceAssert.notNull(redisClusterNode, "RedisClusterNode must not be null");

            boolean add = getPartitions().add(redisClusterNode);
            updateCache();
            return add;
        }
    }
802930
@Override
	public void addSipConnector(String ipAddress, int port, String transport) throws LifecycleException
	{
		SipConnector sipConnector = mssContainer.createSipConnector(ipAddress, port, transport);
		mssContainer.addSipConnector(sipConnector);
	}
1368200
public void add(Featurable featurable)
    {
        featurables.put(featurable.getFeature(Identifiable.class).getId(), featurable);

        for (final Class<?> type : featurable.getClass().getInterfaces())
        {
            addType(type, featurable);
        }

        for (final Class<? extends Feature> feature : featurable.getFeaturesType())
        {
            final Feature object = featurable.getFeature(feature);
            addType(feature, object);
            for (final Class<?> other : UtilReflection.getInterfaces(feature, Feature.class))
            {
                addType(other, object);
            }
        }
        addType(featurable.getClass(), featurable);
        addSuperClass(featurable, featurable.getClass());
    }
885257
public void addTrait(String guid, Struct traitDefinition) throws AtlasServiceException {
        String traitJson = InstanceSerialization.toJson(traitDefinition, true);
        LOG.debug("Adding trait to entity with id {} {}", guid, traitJson);
        callAPIWithBodyAndParams(API.ADD_TRAITS, traitJson, guid, URI_TRAITS);
    }
417122
public void put(PondLife pl)
        throws InterruptedException
    {
        int id=pl.getID();
        
        synchronized(this)
        {
            if (_running==0)
                stopPondLife(id);
            else if (_pondLife[id]!=null)
            {
                _index[_available++]=id;
                notify();
            }
        }
        
    }
715034
private void addConnectionRequest() {
    if (totalConnection.get() < options.maxPoolSize && poolState.get() == POOL_STATE_OK) {

      //ensure to have one worker if was timeout
      connectionAppender.prestartCoreThread();
      connectionAppenderQueue.offer(() -> {

        if ((totalConnection.get() < options.minPoolSize || pendingRequestNumber.get() > 0)
            && totalConnection.get() < options.maxPoolSize) {
          try {
            addConnection();
          } catch (SQLException sqle) {
            //eat
          }
        }
      });
    }
  }
552964
public static base_response add(nitro_service client, lbroute6 resource) throws Exception {
		lbroute6 addresource = new lbroute6();
		addresource.network = resource.network;
		addresource.gatewayname = resource.gatewayname;
		return addresource.add_resource(client);
	}
682020
public void sendCancelledNotification(Jid to, String packetID) throws NotConnectedException, InterruptedException {
        // Create the message to send
        Message msg = new Message(to);
        // Create a MessageEvent Package and add it to the message
        MessageEvent messageEvent = new MessageEvent();
        messageEvent.setCancelled(true);
        messageEvent.setStanzaId(packetID);
        msg.addExtension(messageEvent);
        // Send the packet
        connection().sendStanza(msg);
    }