OSRTContext.h

Go to the documentation of this file.

/*
 * Copyright (c) 2003-2023 Objective Systems, Inc.
 *
 * This software is furnished under a license and may be used and copied
 * only in accordance with the terms of such license and with the
 * inclusion of the above copyright notice. This software or any other
 * copies thereof may not be provided or otherwise made available to any
 * other person. No title to and ownership of the software is hereby
 * transferred.
 *
 * The information in this software is subject to change without notice
 * and should not be construed as a commitment by Objective Systems, Inc.
 *
 * PROPRIETARY NOTICE
 *
 * This software is an unpublished work subject to a confidentiality agreement
 * and is protected by copyright and trade secret law.  Unauthorized copying,
 * redistribution or other use of this work is prohibited.
 *
 * The above notice of copyright on this source code product does not indicate
 * any actual or intended publication of such source code.
 *
 *****************************************************************************/
/*The following is the text for the main C++ Runtime index page.*/
#ifndef _OSRTCONTEXT_H_
#define _OSRTCONTEXT_H_

#include "rtxsrc/rtxContext.h"
#include "rtxsrc/rtxDiag.h"
#include "rtxsrc/rtxError.h"
#include "rtxsrc/rtxMemory.h"

#if defined(_MSC_VER)
// this disables 'unreferenced inline function has been removed' warning
#pragma warning(disable: 4514)
#endif

class EXTRTCLASS OSRTContext {
 private:
   EXTRTMETHOD OSRTContext (OSCTXT*);

 protected:
   OSCTXT mCtxt;

   OSUINT32 mCount;

   OSBOOL mbInitialized;

   int mStatus;

 public:
   EXTRTMETHOD OSRTContext ();

   virtual EXTRTMETHOD ~OSRTContext ();

   inline OSCTXT* getPtr () { return &mCtxt; }

   inline const OSCTXT* getPtr () const { return &mCtxt; }

   EXTRTMETHOD OSUINT32 getRefCount();

   inline int getStatus () const {
      return (0 == mStatus) ? rtxErrGetLastError (&mCtxt) : mStatus;
   }

   inline OSBOOL isInitialized () { return mbInitialized; }

   EXTRTMETHOD void _ref();

   EXTRTMETHOD void _unref();

   EXTRTMETHOD char* getErrorInfo ();

   EXTRTMETHOD char* getErrorInfo (size_t* pBufSize);

   EXTRTMETHOD char* getErrorInfo (char* pBuf, size_t& bufSize);

   inline void* memAlloc (size_t numocts) {
      return rtxMemAlloc (&mCtxt, numocts);
   }

   inline void* memAllocZ (size_t numocts) {
      return rtxMemAllocZ (&mCtxt, numocts);
   }

   inline void memFreeAll () {
      rtxMemFree (&mCtxt);
   }

   inline void memFreePtr (void* ptr) {
      rtxMemFreePtr (&mCtxt, ptr);
   }

   inline void* memRealloc (void* ptr, size_t numocts) {
      return rtxMemRealloc (&mCtxt, ptr, numocts);
   }

   inline void memReset () {
      rtxMemReset (&mCtxt);
   }

   inline void printErrorInfo () {
      rtxErrPrint (&mCtxt);
   }

   inline void resetErrorInfo () {
      mStatus = 0;
      rtxErrReset (&mCtxt);
   }

   inline OSBOOL setDiag (OSBOOL value=TRUE) {
      return rtxSetDiag (&mCtxt, value);
   }

   virtual EXTRTMETHOD int setRunTimeKey (const OSOCTET* key, size_t keylen);

   int setStatus (int stat);

};

class EXTRTCLASS OSRTCtxtPtr {
 protected:
   OSRTContext* mPointer;

 public:
   OSRTCtxtPtr (OSRTContext* rf = 0) : mPointer(rf) {
      if (mPointer != 0) mPointer->_ref();
   }

   OSRTCtxtPtr (const OSRTCtxtPtr& o) : mPointer(o.mPointer) {
      if (mPointer != 0) mPointer->_ref();
   }

   virtual ~OSRTCtxtPtr() { if (mPointer != 0) mPointer->_unref(); }

   OSRTCtxtPtr& operator= (const OSRTCtxtPtr& rf) {
      if (mPointer != 0) mPointer->_unref();
      mPointer = rf.mPointer;
      if (mPointer != 0) mPointer->_ref();
      return *this;
   }

   OSRTCtxtPtr& operator= (OSRTContext* rf) {
      if (mPointer != 0) mPointer->_unref();
      mPointer = rf;
      if (mPointer != 0) mPointer->_ref();
      return *this;
   }

   operator OSRTContext* () { return mPointer; }
   operator const OSRTContext* () const { return mPointer; }

   OSRTContext* operator -> () { return mPointer; }
   const OSRTContext* operator -> () const { return mPointer; }

   OSBOOL operator == (const OSRTContext* o) const {
      return (mPointer == o);
   }

   inline OSBOOL isNull() const { return (mPointer == 0); }

   inline OSCTXT* getCtxtPtr() { return isNull() ? 0 : mPointer->getPtr(); }

};

EXTERNRT void* operator new (size_t nbytes, OSCTXT* pctxt);

EXTERNRT void operator delete (void* pmem, OSCTXT* pctxt);

class EXTRTCLASS OSRTElemNameGuard {
protected:
   OSCTXT* mpCtxt;

public:
   OSRTElemNameGuard (OSCTXT* pctxt, const char* elemName) : mpCtxt(pctxt)
   {
      rtxCtxtPushElemName (mpCtxt, OSUTF8(elemName));
   }
   ~OSRTElemNameGuard()
   {
      rtxCtxtPopElemName (mpCtxt);
   }
} ;

#endif // _OSRTCONTEXT_H_