ASN1CSeqOfList.h

Go to the documentation of this file.
00001 /*
00002  * Copyright (c) 1997-2017 Objective Systems, Inc.
00003  *
00004  * This software is furnished under a license and may be used and copied
00005  * only in accordance with the terms of such license and with the
00006  * inclusion of the above copyright notice. This software or any other
00007  * copies thereof may not be provided or otherwise made available to any
00008  * other person. No title to and ownership of the software is hereby
00009  * transferred.
00010  *
00011  * The information in this software is subject to change without notice
00012  * and should not be construed as a commitment by Objective Systems, Inc.
00013  *
00014  * PROPRIETARY NOTICE
00015  *
00016  * This software is an unpublished work subject to a confidentiality agreement
00017  * and is protected by copyright and trade secret law.  Unauthorized copying,
00018  * redistribution or other use of this work is prohibited.
00019  *
00020  * The above notice of copyright on this source code product does not indicate
00021  * any actual or intended publication of such source code.
00022  *
00023  *****************************************************************************/
00024 #ifndef _ASN1CSEQOFLIST_H_
00025 #define _ASN1CSEQOFLIST_H_
00026 
00027 #include <stdlib.h>
00028 #include "rtsrc/asn1CppTypes.h"
00038 
00039 //
00040 // ASN1CSeqOfList
00041 //
00042 // Doubly-linked list implementation. This class provides all functionalty
00043 // necessary for linked list. To iterate list use methods iterator,
00044 // iteratorFrom, iteratorFromLast.
00045 //
00046 // Note: this implementation is not thread-safe.
00047 //
00048 // ASN1CSeqOfListIterator
00049 //
00050 // An iterator for lists that allows the programmer to traverse the
00051 // list in either direction and modify the list during iteration.
00052 //
00053 // Author  Artem Bolgar
00054 // version 1.09, 12 Nov, 2003
00055 // version 1.08, 11 Feb, 2003
00056 //
00057 #ifndef _NO_UTILS_CLASSES
00058 
00059 class EXTRTCLASS ASN1CSeqOfList;
00060 
00062 //
00063 // ASN1CSeqOfListIterator
00064 //
00075 class EXTRTCLASS ASN1CSeqOfListIterator {
00076    friend class ASN1CSeqOfList;
00077  protected:
00078    ASN1CSeqOfList* pSeqList; // pointer to the list
00079    OSRTDListNode* nextNode; // next node
00080    OSRTDListNode* lastNode; // last returned node
00081    volatile int expectedModCount; // expect modification counter
00082    int stat;
00083 
00084    EXTRTMETHOD ASN1CSeqOfListIterator(ASN1CSeqOfList* list);
00085    EXTRTMETHOD ASN1CSeqOfListIterator(ASN1CSeqOfList* list, OSRTDListNode* startNode);
00086 
00087  public:
00098    inline OSBOOL hasNext() { return OSBOOL(nextNode != 0); }
00099 
00110    inline OSBOOL hasPrev() { return OSBOOL(nextNode != 0); }
00111 
00121    EXTRTMETHOD void* next();
00122 
00133    EXTRTMETHOD void* prev();
00134 
00146    EXTRTMETHOD int remove();
00147 
00161    EXTRTMETHOD int set(void* data);
00162 
00178    EXTRTMETHOD int insert(void* data);
00179 
00180    /* Returns the state of iterator. 0 if it is OK, RTERR_* value otherwise */
00181    inline int getState () { return stat; }
00182 
00183  protected:
00184    inline void* operator new(size_t, void* data) { return data; }
00185 #if !defined(__xlC__)
00186    inline void operator delete(void*, void*) {}
00187 #endif
00188 #ifndef __BORLANDC__
00189    inline void operator delete(void*, size_t) {}
00190 #endif
00191 } ;
00192 
00193 
00195 //
00196 // ASN1CSeqOfList
00197 //
00204 class EXTRTCLASS ASN1CSeqOfList : public ASN1CType {
00205    friend class ASN1CSeqOfListIterator;
00206  protected:
00207    OSRTDList* pList;           // list
00208    volatile int modCount;  // modification counter
00209    OSBOOL wasAssigned;
00210 
00211    // The following protected ctor could be used to perform lists' operation,
00212    // which do not require the memory allocation.
00213    EXTRTMETHOD ASN1CSeqOfList (OSRTDList& lst);
00214    EXTRTMETHOD ASN1CSeqOfList (ASN1TSeqOfList& lst);
00215    EXTRTMETHOD ASN1CSeqOfList (ASN1TPDUSeqOfList& lst);
00216 
00217  public:
00218 
00232    EXTRTMETHOD ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf, OSRTDList& lst,
00233       OSBOOL initBeforeUse = TRUE);
00234 
00241    EXTRTMETHOD ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf);
00242 
00249    EXTRTMETHOD ASN1CSeqOfList (ASN1CType& ccobj);
00250 
00264    EXTRTMETHOD ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf, ASN1TSeqOfList& lst);
00265 
00279    EXTRTMETHOD ASN1CSeqOfList (ASN1CType& ccobj, ASN1TSeqOfList& lst);
00280 
00294    EXTRTMETHOD ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf, ASN1TPDUSeqOfList& lst);
00295 
00296    EXTRTMETHOD ASN1CSeqOfList (OSRTContext& ctxt, OSRTDList& lst,
00297       OSBOOL initBeforeUse = TRUE);
00298    EXTRTMETHOD ASN1CSeqOfList (OSRTContext& ctxt);
00299    EXTRTMETHOD ASN1CSeqOfList (OSRTContext& ctxt, ASN1TSeqOfList& lst);
00300    EXTRTMETHOD ASN1CSeqOfList (OSRTContext& ctxt, ASN1TPDUSeqOfList& lst);
00301 
00302    EXTRTMETHOD ~ASN1CSeqOfList();
00303 
00304    // Appends new list node with data
00316    EXTRTMETHOD void append(void* data);
00317 
00318    // Appends array to list data. Data won't be copied, just assigned.
00333    EXTRTMETHOD void appendArray
00334       (const void* data, OSSIZE numElems, OSSIZE elemSize);
00335 
00336    // Appends array to list data. Data will be copied.
00351    EXTRTMETHOD void appendArrayCopy
00352       (const void* data, OSSIZE numElems, OSSIZE elemSize);
00353 
00357    inline void init () {
00358       rtxDListInit (pList);
00359    }
00360 
00361    // Inserts new list node at the specified index
00374    EXTRTMETHOD void insert(int index, void* data);
00375 
00376    // Removes list node at specified index from the list
00388    EXTRTMETHOD void remove(int index);
00389 
00390    // Removes  the first occurrence of the specified element in the list.
00401    EXTRTMETHOD void remove(void* data);
00402 
00403    // Removes the first element from the list.
00410    inline void removeFirst() {
00411       remove(pList->head);
00412    }
00413 
00414    // Removes the last element from the list.
00421    inline void removeLast() {
00422       remove(pList->tail);
00423    }
00424 
00425    // Returns index of the list node with specified data
00435    EXTRTMETHOD int indexOf(void* data) const;
00436 
00437    // Returns 'TRUE' if this list contains the specified element.
00446    inline OSBOOL contains (void* data) const {
00447       return indexOf(data) != -1;
00448    }
00449 
00456    EXTRTMETHOD void* getFirst();
00457 
00464    EXTRTMETHOD void* getLast();
00465 
00472    EXTRTMETHOD void* get (int index) const;
00473 
00482    EXTRTMETHOD void* set (int index, void* data);
00483 
00487    EXTRTMETHOD void clear();
00488 
00493    EXTRTMETHOD void freeMemory();
00494 
00500    EXTRTMETHOD OSBOOL isEmpty() const;
00501 
00507    EXTRTMETHOD OSSIZE size() const;
00508 
00515    EXTRTMETHOD ASN1CSeqOfListIterator* iterator();
00516 
00517    // Creates iterator from the tail of the list
00525    EXTRTMETHOD ASN1CSeqOfListIterator* iteratorFromLast();
00526 
00527    // Creates iterator from the node with specified data
00536    EXTRTMETHOD ASN1CSeqOfListIterator* iteratorFrom(void* data);
00537 
00547    EXTRTMETHOD void* toArray (OSSIZE elemSize);
00548 
00549    // Converts to array
00566    EXTRTMETHOD void* toArray
00567       (void* pArray, OSSIZE elemSize, OSSIZE allocatedElems);
00568 
00569    // Returns element at specified index
00577    inline void* operator[](int index) const {
00578       return get(index);
00579    }
00580 
00581    inline operator OSRTDList* () {
00582       return pList;
00583    }
00584  protected:
00585    // Removes specified node from the list
00586    EXTRTMETHOD void remove(OSRTDListNode* node);
00587 
00588    // Inserts new node ('data') before another node ('node')
00589    EXTRTMETHOD void insertBefore(void* data, OSRTDListNode* node);
00590 
00591    // Inserts new node ('data') after another node ('node')
00592    EXTRTMETHOD void insertAfter(void* data, OSRTDListNode* node);
00593 
00594 
00595 } ;
00596 #else
00597 typedef class _ASN1CSeqOfList : public ASN1CType {
00598  public:
00599    _ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf, OSRTDList& lst,
00600       OSBOOL initBeforeUse = TRUE) : ASN1CType (msgBuf) {}
00601    _ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf, ASN1TSeqOfList& lst) :
00602       ASN1CType (msgBuf) {}
00603    _ASN1CSeqOfList (OSRTMessageBufferIF& msgBuf) : ASN1CType (msgBuf) {}
00604 } ASN1CSeqOfList;
00605 
00606 #endif // _NO_UTILS_CLASSES
00607 
00612 #endif // _ASN1CSEQOFLIST_H_