util/Global.h

Go to the documentation of this file.

/*------------------------------------------------------------------------------
Name:      Global.h
Project:   xmlBlaster.org
Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file
Comment:   The global object (a stack for all pseudo static stuff).
Version:   $Id: Global.h 14440 2005-12-26 13:13:00Z ruff $
------------------------------------------------------------------------------*/

#ifndef ORG_XMLBLASTER_UTIL_GLOBAL_H
#define ORG_XMLBLASTER_UTIL_GLOBAL_H

#include <util/xmlBlasterDef.h>
#include <util/I_Log.h>
#include <util/LogManager.h>
#include <util/XmlBlasterException.h>
#include <util/Property.h>
#include <util/SessionName.h>
#include <util/ReferenceCounterBase.h>
#include <util/ReferenceHolder.h>

#include <client/protocol/CbServerPluginManager.h>
#include <util/dispatch/DispatchManager.h>
#include <util/Timeout.h>

#include <string>
#include <map>

// for managed objects
#include <util/objman.h>

namespace org { namespace xmlBlaster { namespace util {

Dll_Export std::string waitOnKeyboardHit(const std::string &str);

typedef struct ArgsStruct {
   size_t argc;
   char **argv;
} ArgsStruct_T;

class org::xmlBlaster::util::Global;
typedef org::xmlBlaster::util::ReferenceHolder<org::xmlBlaster::util::Global> GlobalRef;

class Dll_Export Global : public ReferenceCounterBase {

friend Global& getInstance(const std::string &instanceName);

// required for managed objects
template <class TYPE> friend class ManagedObject;
friend class Object_Lifetime_Manager;

typedef std::map<std::string, GlobalRef> GlobalRefMap;
typedef std::map<std::string, Global*> GlobalMap;

private:
   const std::string      ME;
   Property*              property_;
   int                    args_;
   const char * const*    argv_;
   bool                   isInitialized_;
   org::xmlBlaster::util::LogManager logManager_;
   org::xmlBlaster::client::protocol::CbServerPluginManager* cbServerPluginManager_;
   org::xmlBlaster::util::dispatch::DispatchManager* dispatchManager_;
   Timeout*               pingTimer_;
   std::string            id_;
   std::string            immutableId_;
   std::string            instanceName_; 
   mutable std::string    instanceId_;   
   thread::Mutex          pingerMutex_;  
   static thread::Mutex   globalMutex_;  
   org::xmlBlaster::util::SessionNameRef sessionName_;  
   static GlobalRefMap    globalRefMap_; 
   static GlobalMap       globalMap_;    
   static Global*         global_;       
   void copy();

public:
   Global();
   // Global(const Global &global);
   Global& operator =(const Global &);
   ~Global();

   int getArgs();

   const char * const* getArgc();

   void fillArgs(ArgsStruct_T &args);

   void freeArgs(ArgsStruct_T &args);

   static Global& getInstance(std::string name="default");

   GlobalRef createInstance(const std::string& name, const Property::MapType *propertyMapP=NULL, bool holdReferenceCount=false);

   bool containsInstance(const std::string& name);

   bool destroyInstance(const std::string &instanceName);

   const std::string& getInstanceName();

   bool wantsHelp();

   static std::string& getVersion();

   static std::string& getRevisionNumber();

   static std::string& getReleaseId();

   static std::string& getBuildTimestamp();

   static std::string& getCompiler();

   static std::string& getDefaultProtocol();
 
   static std::string usage();

   Global& initialize(int args=0, const char * const argv[]=0);

   Global& initialize(const org::xmlBlaster::util::Property::MapType &propertyMap);

   org::xmlBlaster::util::LogManager& getLogManager();

   org::xmlBlaster::util::I_Log& getLog(const std::string &logName="org.xmlBlaster");

   Property& getProperty() const;

   std::string getLocalIP() const;

   std::string getBootstrapHostname() const;

   std::string getCbHostname() const;

   org::xmlBlaster::client::protocol::CbServerPluginManager& getCbServerPluginManager();

   org::xmlBlaster::util::dispatch::DispatchManager& getDispatchManager();

   Timeout& getPingTimer();

   static const std::string& getBoolAsString(bool val);

   void setSessionName(org::xmlBlaster::util::SessionNameRef sessionName);

   org::xmlBlaster::util::SessionNameRef getSessionName() const;

   std::string getId() const;

   std::string getStrippedId() const;

   std::string getImmutableId() const;

   std::string getStrippedImmutableId() const;

   std::string getStrippedString(const std::string& text) const;

   void setId(const std::string& id);
   
   void setImmutableId(const std::string& id);

   void resetInstanceId();

   std::string getInstanceId() const;
};

}}} // namespace

# endif // ORG_XMLBLASTER_UTIL_GLOBAL_H