bmqa_session.h

Go to the documentation of this file.

// Copyright 2014-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_session.h                                                     -*-C++-*-
#ifndef INCLUDED_BMQA_SESSION
#define INCLUDED_BMQA_SESSION
 
 
// BMQ
 
#include <bmqa_abstractsession.h>
#include <bmqa_closequeuestatus.h>
#include <bmqa_configurequeuestatus.h>
#include <bmqa_confirmeventbuilder.h>
#include <bmqa_messageeventbuilder.h>
#include <bmqa_openqueuestatus.h>
#include <bmqt_queueoptions.h>
#include <bmqt_sessionoptions.h>
#include <bmqt_uri.h>
 
// BDE
#include <ball_log.h>
#include <bsl_memory.h>
#include <bsl_string.h>
#include <bslma_allocator.h>
#include <bslma_managedptr.h>
#include <bslma_usesbslmaallocator.h>
#include <bslmf_nestedtraitdeclaration.h>
#include <bsls_keyword.h>
#include <bsls_timeinterval.h>
#include <bsls_types.h>
 
namespace BloombergLP {
 
// FORWARD DECLARATION
namespace bmqimp {
class Application;
}
namespace bmqimp {
class Event;
}
namespace bmqp {
class MessageGUIDGenerator;
}
namespace bslmt {
class Semaphore;
}
 
namespace bmqa {
 
// FORWARD DECLARATION
class Event;
class Message;
class MessageEvent;
class MessageProperties;
class QueueId;
class SessionEvent;
 
// =========================
// class SessionEventHandler
// =========================
 
class SessionEventHandler {
  public:
    // CREATORS
 
    virtual ~SessionEventHandler();
 
    // MANIPULATORS
 
    virtual void onSessionEvent(const SessionEvent& event) = 0;
 
    virtual void onMessageEvent(const MessageEvent& event) = 0;
};
 
// ==================
// struct SessionImpl
// ==================
 
struct SessionImpl {
    // PUBLIC DATA
 
    bslma::Allocator* d_allocator_p;
 
    bmqt::SessionOptions d_sessionOptions;
 
    bslma::ManagedPtr<SessionEventHandler> d_eventHandler_mp;
 
    bsl::shared_ptr<bmqp::MessageGUIDGenerator> d_guidGenerator_sp;
 
    bslma::ManagedPtr<bmqimp::Application> d_application_mp;
 
  private:
    // NOT IMPLEMENTED
    SessionImpl(const SessionImpl&) BSLS_KEYWORD_DELETED;
    SessionImpl& operator=(const SessionImpl&) BSLS_KEYWORD_DELETED;
 
  public:
    // TRAITS
    BSLMF_NESTED_TRAIT_DECLARATION(SessionImpl, bslma::UsesBslmaAllocator)
 
    // CREATORS
 
    
    SessionImpl(const bmqt::SessionOptions&            options,
                bslma::ManagedPtr<SessionEventHandler> eventHandler,
                bslma::Allocator*                      allocator = 0);
};
 
// =============
// class Session
// =============
 
class Session : public AbstractSession {
  public:
    // TYPES
 
    typedef AbstractSession::OpenQueueCallback OpenQueueCallback;
 
    typedef AbstractSession::ConfigureQueueCallback ConfigureQueueCallback;
 
    typedef AbstractSession::CloseQueueCallback CloseQueueCallback;
 
  private:
    // CLASS-SCOPE CATEGORY
    BALL_LOG_SET_CLASS_CATEGORY("BMQA.SESSION");
 
  private:
    // DATA
    SessionImpl d_impl;  // Sole data member of this object.
 
  private:
    // NOT IMPLEMENTED
    Session(const Session&) BSLS_KEYWORD_DELETED;
 
    Session& operator=(const Session&) BSLS_KEYWORD_DELETED;
 
  public:
    // TRAITS
    BSLMF_NESTED_TRAIT_DECLARATION(Session, bslma::UsesBslmaAllocator)
 
    // CREATORS
 
    
    explicit Session(
        const bmqt::SessionOptions& options   = bmqt::SessionOptions(),
        bslma::Allocator*           allocator = 0);
 
    explicit Session(
        bslma::ManagedPtr<SessionEventHandler> eventHandler,
        const bmqt::SessionOptions& options   = bmqt::SessionOptions(),
        bslma::Allocator*           allocator = 0);
 
    ~Session() BSLS_KEYWORD_OVERRIDE;
 
    // MANIPULATORS
    //   (virtual bmqa::AbstractSession)
 
 
    int start(const bsls::TimeInterval& timeout = bsls::TimeInterval())
        BSLS_KEYWORD_OVERRIDE;
 
    int startAsync(const bsls::TimeInterval& timeout = bsls::TimeInterval())
        BSLS_KEYWORD_OVERRIDE;
 
    void stop() BSLS_KEYWORD_OVERRIDE;
 
    void stopAsync() BSLS_KEYWORD_OVERRIDE;
 
    void finalizeStop() BSLS_KEYWORD_OVERRIDE;
 
    virtual MessageEventBuilder createMessageEventBuilder();
 
    void loadMessageEventBuilder(MessageEventBuilder* builder)
        BSLS_KEYWORD_OVERRIDE;
 
    void loadConfirmEventBuilder(ConfirmEventBuilder* builder)
        BSLS_KEYWORD_OVERRIDE;
 
    void
    loadMessageProperties(MessageProperties* buffer) BSLS_KEYWORD_OVERRIDE;
 
 
    int getQueueId(QueueId*         queueId,
                   const bmqt::Uri& uri) BSLS_KEYWORD_OVERRIDE;
 
    int getQueueId(QueueId* queueId, const bmqt::CorrelationId& correlationId)
        BSLS_KEYWORD_OVERRIDE;
 
    int openQueue(QueueId*                  queueId,
                  const bmqt::Uri&          uri,
                  bsls::Types::Uint64       flags,
                  const bmqt::QueueOptions& options = bmqt::QueueOptions(),
                  const bsls::TimeInterval& timeout = bsls::TimeInterval())
        BSLS_KEYWORD_OVERRIDE;
 
    OpenQueueStatus
    openQueueSync(QueueId*                  queueId,
                  const bmqt::Uri&          uri,
                  bsls::Types::Uint64       flags,
                  const bmqt::QueueOptions& options = bmqt::QueueOptions(),
                  const bsls::TimeInterval& timeout = bsls::TimeInterval())
        BSLS_KEYWORD_OVERRIDE;
 
    virtual int
    openQueue(const QueueId&            queueId,
              const bmqt::Uri&          uri,
              bsls::Types::Uint64       flags,
              const bmqt::QueueOptions& options = bmqt::QueueOptions(),
              const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    int
    openQueueAsync(QueueId*                  queueId,
                   const bmqt::Uri&          uri,
                   bsls::Types::Uint64       flags,
                   const bmqt::QueueOptions& options = bmqt::QueueOptions(),
                   const bsls::TimeInterval& timeout = bsls::TimeInterval())
        BSLS_KEYWORD_OVERRIDE;
 
    void
    openQueueAsync(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())
        BSLS_KEYWORD_OVERRIDE;
 
    int configureQueue(QueueId*                  queueId,
                       const bmqt::QueueOptions& options,
                       const bsls::TimeInterval& timeout =
                           bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE;
 
    ConfigureQueueStatus
    configureQueueSync(QueueId*                  queueId,
                       const bmqt::QueueOptions& options,
                       const bsls::TimeInterval& timeout =
                           bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE;
 
    int configureQueueAsync(QueueId*                  queueId,
                            const bmqt::QueueOptions& options,
                            const bsls::TimeInterval& timeout =
                                bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE;
 
    void configureQueueAsync(QueueId*                      queueId,
                             const bmqt::QueueOptions&     options,
                             const ConfigureQueueCallback& callback,
                             const bsls::TimeInterval&     timeout =
                                 bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE;
 
    int closeQueue(QueueId*                  queueId,
                   const bsls::TimeInterval& timeout = bsls::TimeInterval())
        BSLS_KEYWORD_OVERRIDE;
 
    CloseQueueStatus
    closeQueueSync(QueueId*                  queueId,
                   const bsls::TimeInterval& timeout = bsls::TimeInterval())
        BSLS_KEYWORD_OVERRIDE;
 
    virtual int
    closeQueue(const QueueId&            queueId,
               const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
    int closeQueueAsync(QueueId*                  queueId,
                        const bsls::TimeInterval& timeout =
                            bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE;
 
    void closeQueueAsync(QueueId*                  queueId,
                         const CloseQueueCallback& callback,
                         const bsls::TimeInterval& timeout =
                             bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE;
 
    virtual int
    closeQueueAsync(const QueueId&            queueId,
                    const bsls::TimeInterval& timeout = bsls::TimeInterval());
 
 
    Event nextEvent(const bsls::TimeInterval& timeout = bsls::TimeInterval())
        BSLS_KEYWORD_OVERRIDE;
 
    int post(const MessageEvent& event) BSLS_KEYWORD_OVERRIDE;
 
    int confirmMessage(const Message& message) BSLS_KEYWORD_OVERRIDE;
 
    int confirmMessage(const MessageConfirmationCookie& cookie)
        BSLS_KEYWORD_OVERRIDE;
 
    int confirmMessages(ConfirmEventBuilder* builder) BSLS_KEYWORD_OVERRIDE;
 
 
    int configureMessageDumping(const bslstl::StringRef& command)
        BSLS_KEYWORD_OVERRIDE;
};
 
// ============================================================================
//                             INLINE DEFINITIONS
// ============================================================================
 
// -------------
// class Session
// -------------
 
inline int Session::confirmMessage(const Message& message)
{
    return confirmMessage(message.confirmationCookie());
}
 
}  // close package namespace
}  // close enterprise namespace
 
#endif