Connect
virtual void Connect(
virtual void Connect(status_t error,
virtual status_t Connect(const media_format& format);
virtual status_t Connect(const dormant_node_info& dormantInfo,
virtual status_t Connect(const media_node& node,
status_t Connect(const media_source& from,
status_t Connect(const media_source& from,
void Connect(BMidi* toObject);
status_t Connect(BMidiConsumer *cons);
virtual status_t Connect(const BNetworkAddress& peer,
status_t Connect(const BNetworkAddress& peer, int type,
virtual status_t Connect(const BNetworkAddress& peer,
virtual status_t Connect(const BNetAddress& addr);
virtual status_t Connect(const char* addr, int port);
virtual status_t Connect(const BNetworkAddress& peer,
virtual status_t Connect(const BNetworkAddress& peer,
virtual status_t Connect(const BNetworkAddress& peer,
status_t Connect(ip_addr_t address, uint16 port);
virtual status_t Connect(BMediaConnection* ourConnection,
virtual status_t Connect(BMediaConnection* ourConnection,
virtual status_t Connect(BMediaConnection* ourConnection,
status_t Connect(uint32 txLength, uint32 rxLength);
fStatus = Connect(HV_HEARTBEAT_RING_SIZE, HV_HEARTBEAT_RING_SIZE);
fStatus = Connect(HV_TIMESYNC_RING_SIZE, HV_TIMESYNC_RING_SIZE);
result = conn->Connect();
return Connect();
static status_t Connect(Connection **connection,
status_t Connect();
result = Connection::Connect(&conn, address);
status_t Connect(const struct sockaddr* address);
return ((L2capEndpoint*)protocol)->Connect(address);
T(Connect(endpoint));
status_t Connect(const struct sockaddr* address);
return ((TCPEndpoint*)protocol)->Connect(address);
return ((UdpEndpoint *)protocol)->Connect(address);
status_t Connect(const sockaddr* newAddr);
status_t Connect(const struct sockaddr* address) override;
virtual status_t Connect(const struct sockaddr* address) = 0;
status_t Connect(const struct sockaddr* address) override;
return ((UnixEndpoint*)_protocol)->Connect(address);
status_t status = fProtocol.Connect(fSettings.ServerAddress(),
status = fProtocol.Connect(fSettings.ServerAddress(),
status_t Connect(const BNetworkAddress& address,
status_t error = Connect();
status_t error = Connect();
protocol.Connect();
status_t Connect();
status = Connect();
if (fSocket->Connect(addr) != B_OK) {
status_t Connect();
status = itr->Connect(destination,format,io_name,downstreamLatency);
virtual void Connect(
virtual status_t Connect(
virtual void Connect(status_t error, const media_source &source,
virtual void Connect(status_t status,
status_t Connect(const char *host, uint16 port=ESD_DEFAULT_PORT);
if (fDevice->Connect(fHostname.String(), fPort) >= 0) {
if (fDevice->Connect(fHostname.String(), fPort) >= 0) {
err = fDevice->Connect(fHostname.String(), fPort);
virtual void Connect( status_t error,
virtual void Connect(status_t error, const media_source &source,
virtual void Connect(status_t error,
virtual void Connect(status_t error,
virtual void Connect(status_t error,
virtual void Connect(status_t error,
virtual void Connect(status_t error, const media_source &source,
status = roster->Connect(output.source,outputDestination,
virtual void Connect(
void Connect(
virtual void Connect(status_t error, const media_source &source,
virtual void Connect(status_t error, const media_source &source,
virtual void Connect(
virtual void Connect(status_t error, const media_source &source,
virtual void Connect(status_t status,
status = roster->Connect(inputSource,input.destination,
if (fEndpoint->Connect(fHost, fPort) == B_OK) {
if (ep->Connect(fServerAddress->Text(), port) != B_OK) {
status = fMediaRoster->Connect(fProducerOut.source,
virtual bool Connect(const string& server,
if (fControl->Connect(addr) == B_NO_ERROR) {
if (fData->Connect(addr) == B_NO_ERROR)
bool Connect(const string& server,
if (!SpawningUploadClient::Connect(server, login, passwd))
virtual bool Connect(const string& server,
virtual bool Connect(const string& server,
if (ftp->Connect((string)fServerText, (string)fLoginText,
err = roster->Connect(
_inherited::Connect(
virtual void Connect(status_t status, const media_source& source,
virtual void Connect(
err = r->Connect(mConnection.source, mConnection.destination, &format, &soundOutput, &logInput);
virtual void Connect(
fStatus = fMediaRoster->Connect(videoOutput.source, videoInput.destination,
fStatus = fMediaRoster->Connect(videoOutput.source,
fStatus = fMediaRoster->Connect(soundOutput.source, mixerInput.destination,
virtual void Connect(status_t error,
virtual void Connect(status_t error, const media_source& source,
endpoint->Connect(fSynthBridge);
producer->Connect(fCounter);
err = producer->Connect(consumer);
void Connect(int32 consumerID);
Connect(prod, cons);
(*i)->Connect(cons);
void Connect(int32 prod, int32 cons);
virtual status_t Connect();
virtual status_t Connect();
virtual status_t Connect() = 0;
if (ACPIDriverInterface().Connect() != B_OK) {
if (APMDriverInterface().Connect() != B_OK) {
if (fDriverInterface->Connect() != B_OK) {
if (fDriverInterface->Connect() != B_OK) {
fInitStatus = fEndpoint->Connect(remoteHost, remotePort);
err = fRecorder->Connect(input, &audioOutput, &fRecordFormat);
err = gMediaRoster->Connect(output.source, input.destination, &fmt, &audio_output, &audio_input);
err = gMediaRoster->Connect(output.source, input.destination, &fmt, &video_output, &video_input);
err = gMediaRoster->Connect(output.source, input.destination, &fmt, &video_output, &video_input);
if (fConnection.Connect(fServerAddress) == B_OK) {
fMixerControl->Connect(fVolumeWhich, &volume, &errorString);
control.Connect(fWhich);
bool Connect(int32 volumeWhich, float* _value = NULL,
fMixerControl->Connect(fMixerControl->VolumeWhich(), &volume, &errorString);
assert(sConsumer->Connect(input, output) == B_OK);
assert(sProducer->Connect(output, input) == B_OK);
assert(sProducer->Connect(output, filterInput) == B_OK);
assert(sFilter->Connect(filterOutput, input) == B_OK);
assert(sFilter->Connect(output, sConsumers[i]->BeginInput()) == B_OK);
assert(sProducer->Connect(sProducer->BeginOutput(),
assert(sFilter->Connect(input, sConsumers[i]->BeginInput()) == B_OK);
assert(sConsumer->Connect(sConsumer->BeginInput(),
Connect();
void Connect();
void Connect(status_t error,
err = roster->Connect(soundOutput.source, mixerInput.destination, &format,
virtual status_t Connect(media_node * consumer);
err = fSounds[position]->Connect(&systemMixer);
err = fSounds[position]->Connect(&systemMixer);
Connect(request->error, request->source, request->destination,
return BMediaRoster::CurrentRoster()->Connect(ourOutput.source,
return BMediaRoster::Connect(from, to, _format, _output, _input, 0);
virtual void Connect(status_t error,
fInitStatus = roster->Connect(_output.source, _input.destination,
return Connect(ourConnection, theirConnection->Connection());
status_t ret = BMediaRoster::CurrentRoster()->Connect(ourOutput.source,
status_t ret = BMediaRoster::CurrentRoster()->Connect(theirOutput.source,
virtual void Connect(status_t status,
if (fProducer->Connect(toObject->fConsumer) == B_OK) {
return fRemoteSource->Connect(fLocalSink);
fLocalSource->Connect(fRemoteSink);
fStore->Connect(this);
Connect(peer, timeout);
return BAbstractSocket::Connect(peer, SOCK_DGRAM, timeout);
return Connect(addr);
Connect(peer, timeout);
status = BSocket::Connect(fProxyAddress, timeout);
Connect(peer, timeout);
status = BSocket::Connect(peer, timeout);
Connect(peer, timeout);
return BAbstractSocket::Connect(peer, SOCK_STREAM, timeout);
status_t error = fSocket.Connect(address, timeout);
status_t connectError = fSocket->Connect(fRemoteAddr);
status_t connectError = fSocket->Connect(fRemoteAddr);
case Connect:
if (auto status = fSocket->Connect(fRemoteAddress); status != B_OK) {
if (netEndpoint.Connect(netAddress) != B_OK)
Constraint* Connect(Variable* variable);
rv = fRoster->Connect(output.source, input.destination, &format,
status_t status = sProtocol.Connect(address, user, password, useSSL);
virtual void Connect(
rv = roster->Connect(output.source, input.destination, &format, &output, &input);
store->Connect(text);
status = client.Connect(serverAddr);
CPPUNIT_ASSERT_EQUAL(BHttpMethod(BHttpMethod::Connect).Method(), "CONNECT"sv);