bmqa_abstractsession.h

Go to the documentation of this file.

// Copyright 2016-2023 Bloomberg Finance L.P.
// SPDX-License-Identifier: Apache-2.0
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
// bmqa_abstractsession.h                                             -*-C++-*-
#ifndef INCLUDED_BMQA_ABSTRACTSESSION
#define INCLUDED_BMQA_ABSTRACTSESSION
 
 
#include <bmqa_closequeuestatus.h>
#include <bmqa_configurequeuestatus.h>
#include <bmqa_confirmeventbuilder.h>
#include <bmqa_event.h>
#include <bmqa_messageeventbuilder.h>
#include <bmqa_messageproperties.h>
#include <bmqa_openqueuestatus.h>
#include <bmqa_queueid.h>
#include <bmqt_queueoptions.h>
#include <bmqt_uri.h>
 
// BDE
#include <bsl_functional.h>
#include <bsls_timeinterval.h>
#include <bsls_types.h>
 
namespace BloombergLP {
namespace bmqa {
 
// =====================
// class AbstractSession
// =====================
 
class AbstractSession {
  public:
    // TYPES
 
    typedef bsl::function<void(const bmqa::OpenQueueStatus& result)>
        OpenQueueCallback;
 
    typedef bsl::function<void(const bmqa::ConfigureQueueStatus& result)>
        ConfigureQueueCallback;
 
    typedef bsl::function<void(const bmqa::CloseQueueStatus& result)>
        CloseQueueCallback;
 
  public:
    // CREATORS
 
    virtual ~AbstractSession();
 
    // MANIPULATORS
 
 
    virtual int
    start(const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual int
    startAsync(const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual void stop();
 
    virtual void stopAsync();
 
    virtual void finalizeStop();
 
    virtual void loadMessageEventBuilder(MessageEventBuilder* builder);
 
    virtual void loadConfirmEventBuilder(ConfirmEventBuilder* builder);
 
    virtual void loadMessageProperties(MessageProperties* buffer);
 
 
    virtual int getQueueId(QueueId* queueId, const bmqt::Uri& uri);
 
    virtual int getQueueId(QueueId*                   queueId,
                           const bmqt::CorrelationId& correlationId);
 
    virtual int
    openQueue(QueueId*                  queueId,
              const bmqt::Uri&          uri,
              bsls::Types::Uint64       flags,
              const bmqt::QueueOptions& options = bmqt::QueueOptions(),
              const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual OpenQueueStatus
    openQueueSync(QueueId*                  queueId,
                  const bmqt::Uri&          uri,
                  bsls::Types::Uint64       flags,
                  const bmqt::QueueOptions& options = bmqt::QueueOptions(),
                  const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual int
    openQueueAsync(QueueId*                  queueId,
                   const bmqt::Uri&          uri,
                   bsls::Types::Uint64       flags,
                   const bmqt::QueueOptions& options = bmqt::QueueOptions(),
                   const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual void
    openQueueAsync(bmqa::QueueId*            queueId,
                   const bmqt::Uri&          uri,
                   bsls::Types::Uint64       flags,
                   const OpenQueueCallback&  callback,
                   const bmqt::QueueOptions& options = bmqt::QueueOptions(),
                   const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual int
    configureQueue(QueueId*                  queueId,
                   const bmqt::QueueOptions& options,
                   const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual ConfigureQueueStatus configureQueueSync(
        QueueId*                  queueId,
        const bmqt::QueueOptions& options,
        const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual int configureQueueAsync(
        QueueId*                  queueId,
        const bmqt::QueueOptions& options,
        const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual void configureQueueAsync(
        QueueId*                      queueId,
        const bmqt::QueueOptions&     options,
        const ConfigureQueueCallback& callback,
        const bsls::TimeInterval&     timeout = bsls::TimeInterval());
 
    // Asynchronously configure the queue identified by the specified
    // 'queueId' using the specified 'options' to configure some advanced
    // settings.  The result of the operation is communicated to the
    // specified 'callback' via a 'bmqa::ConfigureQueueStatus', providing
    // the status and context of the requested operation.  If the
    // optionally specified 'timeout' is not populated, use the one defined
    // in the session options.
    //
    // THREAD: The 'callback' will *ALWAYS* be invoked from the
    //         EventHandler thread(s) (or if a SessionEventHandler was not
    //         specified, from the thread invoking 'nextEvent').
 
    virtual int
    closeQueue(QueueId*                  queueId,
               const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual CloseQueueStatus
    closeQueueSync(QueueId*                  queueId,
                   const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual int
    closeQueueAsync(QueueId*                  queueId,
                    const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual void
    closeQueueAsync(QueueId*                  queueId,
                    const CloseQueueCallback& callback,
                    const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
 
    virtual Event
    nextEvent(const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    virtual int post(const MessageEvent& event);
 
    virtual int confirmMessage(const Message& message);
 
    virtual int confirmMessage(const MessageConfirmationCookie& cookie);
 
    virtual int confirmMessages(ConfirmEventBuilder* builder);
 
 
    virtual int configureMessageDumping(const bslstl::StringRef& command);
};
class AbstractSession {…};
 
}  // close package namespace
namespace bmqa {…}
}  // close enterprise namespace
namespace BloombergLP {…}
 
#endif