ASN1CSeqOfList.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.
 *
 *****************************************************************************/
#ifndef _ASN1CSEQOFLIST_H_
#define _ASN1CSEQOFLIST_H_

#include <stdlib.h>
#include "rtsrc/asn1CppTypes.h"
//
// ASN1CSeqOfList
//
// Doubly-linked list implementation. This class provides all functionalty
// necessary for linked list. To iterate list use methods iterator,
// iteratorFrom, iteratorFromLast.
//
// Note: this implementation is not thread-safe.
//
// ASN1CSeqOfListIterator
//
// An iterator for lists that allows the programmer to traverse the
// list in either direction and modify the list during iteration.
//
// Author  Artem Bolgar
// version 1.09, 12 Nov, 2003
// version 1.08, 11 Feb, 2003
//
#ifndef _NO_UTILS_CLASSES

class EXTRTCLASS ASN1CSeqOfList;

//
// ASN1CSeqOfListIterator
//
class EXTRTCLASS ASN1CSeqOfListIterator {
   friend class ASN1CSeqOfList;
 protected:
   ASN1CSeqOfList* pSeqList; // pointer to the list
   OSRTDListNode* nextNode; // next node
   OSRTDListNode* lastNode; // last returned node
   volatile int expectedModCount; // expect modification counter
   int stat;

   EXTRTMETHOD ASN1CSeqOfListIterator(ASN1CSeqOfList* list);
   EXTRTMETHOD ASN1CSeqOfListIterator(ASN1CSeqOfList* list, OSRTDListNode* startNode);

 public:
   inline OSBOOL hasNext() { return OSBOOL(nextNode != 0); }

   inline OSBOOL hasPrev() { return OSBOOL(nextNode != 0); }

   EXTRTMETHOD void* next();

   EXTRTMETHOD void* prev();

   EXTRTMETHOD int remove();

   EXTRTMETHOD int set(void* data);

   EXTRTMETHOD int insert(void* data);

   /* Returns the state of iterator. 0 if it is OK, RTERR_* value otherwise */
   inline int getState () { return stat; }

 protected:
   inline void* operator new(size_t, void* data) { return data; }
#if !defined(__xlC__)
   inline void operator delete(void*, void*) {}
#endif
#ifndef __BORLANDC__
   inline void operator delete(void*, size_t) {}
#endif
} ;


//
// ASN1CSeqOfList
//
class EXTRTCLASS ASN1CSeqOfList : public ASN1CType {
   friend class ASN1CSeqOfListIterator;
 protected:
   OSRTDList* pList;           // list
   volatile int modCount;  // modification counter
   OSBOOL wasAssigned;

   // The following protected ctor could be used to perform lists' operation,
   // which do not require the memory allocation.
   EXTRTMETHOD ASN1CSeqOfList (OSRTDList& lst);
   EXTRTMETHOD ASN1CSeqOfList (ASN1TSeqOfList& lst);
   EXTRTMETHOD ASN1CSeqOfList (ASN1TPDUSeqOfList& lst);

 public:

   EXTRTMETHOD ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf, OSRTDList& lst,
      OSBOOL initBeforeUse = TRUE);

   EXTRTMETHOD ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf);

   EXTRTMETHOD ASN1CSeqOfList (ASN1CType& ccobj);

   EXTRTMETHOD ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf, ASN1TSeqOfList& lst);

   EXTRTMETHOD ASN1CSeqOfList (ASN1CType& ccobj, ASN1TSeqOfList& lst);

   EXTRTMETHOD ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf, ASN1TPDUSeqOfList& lst);

   EXTRTMETHOD ASN1CSeqOfList (OSRTContext& ctxt, OSRTDList& lst,
      OSBOOL initBeforeUse = TRUE);
   EXTRTMETHOD ASN1CSeqOfList (OSRTContext& ctxt);
   EXTRTMETHOD ASN1CSeqOfList (OSRTContext& ctxt, ASN1TSeqOfList& lst);
   EXTRTMETHOD ASN1CSeqOfList (OSRTContext& ctxt, ASN1TPDUSeqOfList& lst);

   EXTRTMETHOD ~ASN1CSeqOfList();

   // Appends new list node with data
   EXTRTMETHOD void append(void* data);

   // Appends array to list data. Data won't be copied, just assigned.
   EXTRTMETHOD void appendArray
      (const void* data, OSSIZE numElems, OSSIZE elemSize);

   // Appends array to list data. Data will be copied.
   EXTRTMETHOD void appendArrayCopy
      (const void* data, OSSIZE numElems, OSSIZE elemSize);

   inline void init () {
      rtxDListInit (pList);
   }

   // Inserts new list node at the specified index
   EXTRTMETHOD void insert(int index, void* data);

   // Removes list node at specified index from the list
   EXTRTMETHOD void remove(int index);

   // Removes  the first occurrence of the specified element in the list.
   EXTRTMETHOD void remove(void* data);

   // Removes the first element from the list.
   inline void removeFirst() {
      remove(pList->head);
   }

   // Removes the last element from the list.
   inline void removeLast() {
      remove(pList->tail);
   }

   // Returns index of the list node with specified data
   EXTRTMETHOD int indexOf(void* data) const;

   // Returns 'TRUE' if this list contains the specified element.
   inline OSBOOL contains (void* data) const {
      return indexOf(data) != -1;
   }

   EXTRTMETHOD void* getFirst();

   EXTRTMETHOD void* getLast();

   EXTRTMETHOD void* get (int index) const;

   EXTRTMETHOD void* set (int index, void* data);

   EXTRTMETHOD void clear();

   virtual void freeMemory();

   EXTRTMETHOD OSBOOL isEmpty() const;

   EXTRTMETHOD OSSIZE size() const;

   EXTRTMETHOD ASN1CSeqOfListIterator* iterator();

   // Creates iterator from the tail of the list
   EXTRTMETHOD ASN1CSeqOfListIterator* iteratorFromLast();

   // Creates iterator from the node with specified data
   EXTRTMETHOD ASN1CSeqOfListIterator* iteratorFrom(void* data);

   EXTRTMETHOD void* toArray (OSSIZE elemSize);

   // Converts to array
   EXTRTMETHOD void* toArray
      (void* pArray, OSSIZE elemSize, OSSIZE allocatedElems);

   // Returns element at specified index
   inline void* operator[](int index) const {
      return get(index);
   }

   inline operator OSRTDList* () {
      return pList;
   }
 protected:
   // Removes specified node from the list
   EXTRTMETHOD void remove(OSRTDListNode* node);

   // Inserts new node ('data') before another node ('node')
   EXTRTMETHOD void insertBefore(void* data, OSRTDListNode* node);

   // Inserts new node ('data') after another node ('node')
   EXTRTMETHOD void insertAfter(void* data, OSRTDListNode* node);


} ;
#else
typedef class _ASN1CSeqOfList : public ASN1CType {
 public:
   _ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf, OSRTDList& lst,
      OSBOOL initBeforeUse = TRUE) : ASN1CType (msgBuf) {}
   _ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf, ASN1TSeqOfList& lst) :
      ASN1CType (msgBuf) {}
   _ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf) : ASN1CType (msgBuf) {}
} ASN1CSeqOfList;

#endif // _NO_UTILS_CLASSES

#endif // _ASN1CSEQOFLIST_H_