client/XmlBlasterAccess.h

Go to the documentation of this file.

/*------------------------------------------------------------------------------
Name:      XmlBlasterAccess.h
Project:   xmlBlaster.org
Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file
------------------------------------------------------------------------------*/
#ifndef _CLIENT_XMLBLASTERACCESS_H
#define _CLIENT_XMLBLASTERACCESS_H

#include <util/xmlBlasterDef.h>
#include <util/Global.h>
#include <util/qos/ConnectQos.h>
#include <client/I_ConnectionProblems.h>
#include <client/I_Callback.h>
#include <util/thread/ThreadImpl.h>
#include <util/dispatch/I_PostSendListener.h>
#include <util/ReferenceCounterBase.h>
#include <util/ReferenceHolder.h>
#include <string>
#include <vector>
#include <map>

/* The following comment is used by doxygen for the main html page: */
// Note: I_ConnectionProblems.h includes I_ConnectionsHandler.h includes I_XmlBlasterConnection.h
//       which includes all EraseQos, SubscribeKey etc.
//       -> We could try to avoid this by forward declaration, but all cpp files must
//          then include them thereselves.

// Declare classes without the need to include them in this header file
namespace org { namespace xmlBlaster { namespace util {
   class MessageUnit;
}}}
namespace org { namespace xmlBlaster { namespace util { namespace dispatch {
   class DispatchManager;
   class ConnectionsHandler;
}}}}
namespace org { namespace xmlBlaster { namespace client { namespace protocol {
   class I_CallbackServer;
}}}}

namespace org { namespace xmlBlaster { namespace client {

/*
 * The interface org::xmlBlaster::client::I_CallbackRaw/I_Callback/I_CallbackExtended are enforced by AbstractCallbackExtended
 * is for the protocol drivers.
 */
typedef std::map<std::string, I_Callback*> CallbackMapType;
typedef std::map<std::string, std::string> StringMap;

class Dll_Export XmlBlasterAccess : public org::xmlBlaster::client::I_Callback,
                                    public org::xmlBlaster::util::ReferenceCounterBase,
                                    public org::xmlBlaster::util::dispatch::I_PostSendListener
{
private:
   std::string ME;

   org::xmlBlaster::util::Global&   global_;
   org::xmlBlaster::util::GlobalRef globalRef_;
   org::xmlBlaster::util::I_Log&    log_;
   std::string  instanceName_;

   std::string serverNodeId_;
   org::xmlBlaster::util::qos::ConnectQosRef connectQos_;
   org::xmlBlaster::util::qos::ConnectReturnQosRef connectReturnQos_;
   org::xmlBlaster::util::dispatch::DispatchManager* dispatchManager_;
   org::xmlBlaster::client::protocol::I_CallbackServer* cbServer_;
   org::xmlBlaster::util::dispatch::ConnectionsHandler* connection_;

   org::xmlBlaster::client::I_Callback* updateClient_;
   
   org::xmlBlaster::client::I_ConnectionProblems* connectionProblems_;
   CallbackMapType subscriptionCallbackMap_;
   org::xmlBlaster::util::thread::Mutex updateMutex_;
   org::xmlBlaster::util::thread::Mutex invocationMutex_;
   
   org::xmlBlaster::util::dispatch::I_PostSendListener* postSendListener_; 

   XmlBlasterAccess(const XmlBlasterAccess &global);

   XmlBlasterAccess& operator =(const XmlBlasterAccess &);

   void cleanup(bool doLock);
   
public:
   XmlBlasterAccess(org::xmlBlaster::util::Global& global);

   XmlBlasterAccess(org::xmlBlaster::util::GlobalRef global);

   virtual ~XmlBlasterAccess();

   org::xmlBlaster::util::Global& getGlobal();

   org::xmlBlaster::util::queue::I_Queue* getQueue();

   org::xmlBlaster::util::qos::ConnectReturnQos connect(const org::xmlBlaster::util::qos::ConnectQos& qos, org::xmlBlaster::client::I_Callback *clientCb);

   org::xmlBlaster::util::qos::ConnectQosRef getConnectQos();
   org::xmlBlaster::util::qos::ConnectReturnQosRef getConnectReturnQos();

   org::xmlBlaster::client::I_Callback* getCallback();

   void createDefaultCbServer();

   org::xmlBlaster::client::protocol::I_CallbackServer* initCbServer(const std::string& loginName, const std::string& type, const std::string& version);

   org::xmlBlaster::util::dispatch::I_PostSendListener* registerPostSendListener(org::xmlBlaster::util::dispatch::I_PostSendListener *listener);

   org::xmlBlaster::client::protocol::I_ProgressListener* registerProgressListener(org::xmlBlaster::client::protocol::I_ProgressListener *listener);

   void initSecuritySettings(const std::string& secMechanism, const std::string& secVersion);

   bool disconnect(const org::xmlBlaster::util::qos::DisconnectQos& qos, bool flush=true, bool shutdown=true, bool shutdownCb=true);

   void postSend(const org::xmlBlaster::util::queue::MsgQueueEntry &msgQueueEntry);

   std::string getId();

   std::string getSessionName();

   org::xmlBlaster::util::SessionNameRef getSessionNameRef();

   std::string getLoginName();

   void setServerNodeId(const std::string& nodeId);

   std::string getServerNodeId() const;

   // org::xmlBlaster::util::queue::MsgQueueEntry queueMessage(const org::xmlBlaster::util::queue::MsgQueueEntry& entry);

   // std::vector<MsgQueueEntry*> queueMessage(const std::vector<MsgQueueEntry*>& entries);

   // org::xmlBlaster::client::qos::SubscribeReturnQos
//   std::string subscribe(const std::string& xmlKey, const std::string& qos);
   org::xmlBlaster::client::qos::SubscribeReturnQos subscribe(const org::xmlBlaster::client::key::SubscribeKey& key, const org::xmlBlaster::client::qos::SubscribeQos& qos, I_Callback *callback=0);

//   std::vector<org::xmlBlaster::util::MessageUnit> get(const std::string&  xmlKey, const std::string& qos);
   std::vector<org::xmlBlaster::util::MessageUnit> get(const org::xmlBlaster::client::key::GetKey& key, const org::xmlBlaster::client::qos::GetQos& qos);

   std::vector<org::xmlBlaster::util::MessageUnit> receive(std::string oid, int maxEntries, long timeout, bool consumable);


   // org::xmlBlaster::client::qos::UnSubscribeReturnQos[]
//   std::vector<std::string> unSubscribe(const std::string&  xmlKey, const std::string&  qos);
   std::vector<org::xmlBlaster::client::qos::UnSubscribeReturnQos> unSubscribe(const org::xmlBlaster::client::key::UnSubscribeKey& key, const org::xmlBlaster::client::qos::UnSubscribeQos& qos);

   // org::xmlBlaster::client::qos::PublishReturnQos
//   std::string publish(const org::xmlBlaster::util::MessageUnit& msgUnit);
   org::xmlBlaster::client::qos::PublishReturnQos publish(const org::xmlBlaster::util::MessageUnit& msgUnit);

   void publishOneway(const std::vector<org::xmlBlaster::util::MessageUnit>& msgUnitArr);

//   std::vector<std::string> publishArr(const std::vector<org::xmlBlaster::util::MessageUnit>& msgUnitArr);
   std::vector<org::xmlBlaster::client::qos::PublishReturnQos> publishArr(const std::vector<org::xmlBlaster::util::MessageUnit> &msgUnitArr);

   // org::xmlBlaster::client::qos::EraseReturnQos[]
//   std::vector<std::string> erase(const std::string& xmlKey, const std::string& qos);
   std::vector<org::xmlBlaster::client::qos::EraseReturnQos> erase(const org::xmlBlaster::client::key::EraseKey& key, const org::xmlBlaster::client::qos::EraseQos& qos);

   void setCallbackDispatcherActive(bool isActive);

   std::string sendAdministrativeCommand(const std::string &command);

   std::string update(const std::string &sessionId, org::xmlBlaster::client::key::UpdateKey &updateKey, const unsigned char *content, long contentSize, org::xmlBlaster::client::qos::UpdateQos &updateQos);

   static std::string usage();

    void initFailsafe(I_ConnectionProblems* connectionProblems=NULL);

    std::string ping();

   long flushQueue();

   bool isConnected() const;

   bool isAlive() const;

   bool isPolling() const;

   bool isDead() const;

   std::string getStatusString() const;

   void leaveServer(const StringMap &map);
};

typedef org::xmlBlaster::util::ReferenceHolder<org::xmlBlaster::client::XmlBlasterAccess> XmlBlasterAccessRef;

}}} // namespaces

#endif