asn1CppEvtHndlr.h

Go to the documentation of this file.

/*
 * Copyright (c) 1997-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.
 *
 *****************************************************************************/

// rtsrc/asn1CppEvtHndlr.h - this .h file defines the object that is registered
// for the C++ version of the event handler feature.

#ifndef _ASN1CPPEVTHNDLR_H_
#define _ASN1CPPEVTHNDLR_H_

#include "rtsrc/asn1type.h"

#ifndef OS_UNUSED_ARG

#define OS_UNUSED_ARG(arg) (void)arg
#endif

// The following pure abstract class defines the event handler interface
// callback functions that are invoked as a message is parsed..
class EXTRTCLASS Asn1NamedEventHandler {
 public:
   Asn1NamedEventHandler() {}
   virtual ~Asn1NamedEventHandler() {}

   // Start element callback function.  This is invoked upon entry into
   // an element in a constructed type (SEQUENCE, SET, SEQUENCE OF,
   // SET OF, or CHOICE).  A single char* argument (name) is passed.
   virtual void startElement (const char* name, int index) = 0;

   // End element callback function.  This is invoked upon exit from
   // a constructed type.  A single char* argument (name) is passed.
   virtual void endElement (const char* name, int index) = 0;

   // Data callback functions.  These are invoked when data contents
   // are parsed from a field.  A separate callback is invoked for
   // each of the ASN.1 primitive data types..

   virtual void boolValue (OSBOOL value) { OS_UNUSED_ARG(value); }

   virtual void intValue (OSINT32 value) { OS_UNUSED_ARG(value); }

   virtual void uIntValue (OSUINT32 value) { OS_UNUSED_ARG(value); }

   virtual void int64Value (OSINT64 value) {
      intValue ((OSINT32)value);
   }

   virtual void uInt64Value (OSUINT64 value) {
      uIntValue ((OSUINT32)value);
   }

   virtual void bitStrValue (OSUINT32 numbits, const OSOCTET* data) {
      OS_UNUSED_ARG(numbits);  OS_UNUSED_ARG(data);
   }

   virtual void octStrValue (OSUINT32 numocts, const OSOCTET* data) {
      OS_UNUSED_ARG(numocts);  OS_UNUSED_ARG(data);
   }

   virtual void charStrValue (const char* value) { OS_UNUSED_ARG(value); }

   virtual void charStrValue (OSUINT32 nchars, const OSUTF8CHAR* value) {
      OS_UNUSED_ARG(nchars);  OS_UNUSED_ARG(value);
   }

   virtual void charStrValue (OSUINT32 nchars, OSUNICHAR* data) {
      OS_UNUSED_ARG(nchars);  OS_UNUSED_ARG(data);
   }

   virtual void charStrValue (OSUINT32 nchars, OS32BITCHAR* data) {
      OS_UNUSED_ARG(nchars);  OS_UNUSED_ARG(data);
   }

   virtual void nullValue () {}

   virtual void oidValue (OSUINT32 numSubIds, OSUINT32* pSubIds) {
      OS_UNUSED_ARG(numSubIds);  OS_UNUSED_ARG(pSubIds);
   }

   virtual void realValue (double value) { OS_UNUSED_ARG(value); }

   virtual void enumValue (OSUINT32 value, const OSUTF8CHAR* text) {
      OS_UNUSED_ARG(value);  OS_UNUSED_ARG(text);
   }

   virtual void openTypeValue (OSUINT32 numocts, const OSOCTET* data) {
      OS_UNUSED_ARG(numocts);  OS_UNUSED_ARG(data);
   }

   // The following static function is called to add a new event handler
   // to the context event handler list..

   EXTRTMETHOD static void addEventHandler
      (OSCTXT* pCtxt, Asn1NamedEventHandler* pHandler);

   // The following static function is called to remove an event handler
   // from the context event handler list.  Note that it does not delete
   // the event handler object.

   EXTRTMETHOD static void removeEventHandler
      (OSCTXT* pCtxt, Asn1NamedEventHandler* pHandler);

   // The following static methods are invoked from within the generated
   // code to call the various user-defined event handler methods ..

   EXTRTMETHOD static void invokeStartElement
      (OSCTXT* pCtxt, const char* name, int index);

   EXTRTMETHOD static void invokeEndElement
      (OSCTXT* pCtxt, const char* name, int index);

   EXTRTMETHOD static void invokeBoolValue (OSCTXT* pCtxt, OSBOOL value);

   EXTRTMETHOD static void invokeIntValue (OSCTXT* pCtxt, OSINT32 value);

   EXTRTMETHOD static void invokeUIntValue (OSCTXT* pCtxt, OSUINT32 value);

   EXTRTMETHOD static void invokeInt64Value (OSCTXT* pCtxt, OSINT64 value);

   EXTRTMETHOD static void invokeUInt64Value (OSCTXT* pCtxt, OSUINT64 value);

   EXTRTMETHOD static void invokeBitStrValue
      (OSCTXT* pCtxt, OSUINT32 numbits, const OSOCTET* data);

   EXTRTMETHOD static void invokeOctStrValue
      (OSCTXT* pCtxt, OSUINT32 numocts, const OSOCTET* data);

   EXTRTMETHOD static void invokeCharStrValue
      (OSCTXT* pCtxt, const char* value);

   EXTRTMETHOD static void invokeCharStrValue
      (OSCTXT* pCtxt, OSUINT32 nchars, OSUNICHAR* data);

   EXTRTMETHOD static void invokeCharStrValue
      (OSCTXT* pCtxt, OSUINT32 nchars, OS32BITCHAR* data);

   EXTRTMETHOD static void invokeCharStrValue
      (OSCTXT* pCtxt, OSUINT32 nchars, const OSUTF8CHAR* data);

   EXTRTMETHOD static void invokeNullValue (OSCTXT* pCtxt);

   EXTRTMETHOD static void invokeOidValue
      (OSCTXT* pCtxt, OSUINT32 numSubIds, OSUINT32* pSubIds);

   EXTRTMETHOD static void invokeRealValue (OSCTXT* pCtxt, double value);

   EXTRTMETHOD static void invokeEnumValue
      (OSCTXT* pCtxt, OSUINT32 value, const OSUTF8CHAR* text);

   EXTRTMETHOD static void invokeOpenTypeValue
      (OSCTXT* pCtxt, OSUINT32 numocts, const OSOCTET* data);

} ;

// Null event handler class.  This class contains an empty implementation
// of all user methods..

class EXTRTCLASS Asn1NullEventHandler : public Asn1NamedEventHandler {
 public:
   virtual void startElement (const char* , int ) {}
   virtual void endElement (const char* , int ) {}
} ;

// The following pure abstract class defines the error handler interface
// callback functions that are invoked when a parsing error occurs..

class EXTRTCLASS ASN1MessageBuffer ;

class EXTRTCLASS Asn1ErrorHandler {
 public:
   Asn1ErrorHandler() {}
   virtual ~Asn1ErrorHandler() {}

   virtual int error (OSCTXT* pCtxt, ASN1CCB* pCCB, int stat) = 0;

   // The following static method is called from within the generated
   // code to call the virtual error callback method..

   EXTRTMETHOD static int invoke (OSCTXT* pCtxt, ASN1CCB* pCCB, int stat);

   // The following static method is called from within the generated
   // code to call the virtual error callback method..

   EXTRTMETHOD static int invoke
      (OSCTXT* pCtxt, OSOCTET* ptr, int len, int stat);

   EXTRTMETHOD static void setErrorHandler
      (OSCTXT* pCtxt, Asn1ErrorHandler* pHandler);

} ;
#endif