Array.h

/*
 * Copyright 2003 Michael A. Marsh, Cornell University. All rights reserved.
 * This software is released under the modified BSD license.
 * See the file LICENSE in the top-level directory for details.
 */
//
// $Id: Array.h,v 1.4 2005/01/21 19:44:15 mmarsh Exp $
//
// $Log: Array.h,v $
// Revision 1.4  2005/01/21 19:44:15  mmarsh
// Updated for compatibility with Doxygen 1.4.1
//
// Revision 1.3  2004/05/19 15:56:37  mmarsh
// Added copyright and license statements.
//
// Revision 1.2  2003/11/04 22:05:44  mmarsh
// General code cleanup.
//
//

#ifndef __CODEX_ASN1_ARRAY_H__
#define __CODEX_ASN1_ARRAY_H__

#include <vector>
#include "Base.h"
#include "Integer.h"

namespace CODEX_ASN1
{
   template< class T >
   class Array : public Base
   {
      public :
         typedef T                                   ValueType;
         typedef vector< T* >                        ArrayType;
         typedef typename ArrayType::const_iterator  ArrayItr;

         Array() : Base( false ) {}
         Array( const Array& aArr ) :
            Base( aArr.m_initialized )
         {
            if ( &aArr == this )
            {
               return;
            }
            while( m_array.size() )
            {
               delete m_array.back();
               m_array.pop_back();
            }
            ArrayItr itr = aArr.m_array.begin();
            ArrayItr end = aArr.m_array.end();
            for ( ; itr != end ; ++itr )
            {
               m_array.push_back( new T( **itr ) );
            }
         }

         virtual ~Array()
         {
            while( m_array.size() )
            {
               delete m_array.back();
               m_array.pop_back();
            }
         }

         void operator=( const Array& aArr )
         {
            if ( &aArr == this )
            {
               return;
            }
            while( m_array.size() )
            {
               delete m_array.back();
               m_array.pop_back();
            }
            m_initialized = aArr.m_initialized;
            ArrayItr itr = aArr.m_array.begin();
            ArrayItr end = aArr.m_array.end();
            for ( ; itr != end ; ++itr )
            {
               m_array.push_back( new T( **itr ) );
            }
         }

         unsigned int size() const { return m_array.size(); }
         const T* element( unsigned int i ) const { return m_array[i]; }
         ArrayItr begin() const { return m_array.begin(); }
         ArrayItr end() const { return m_array.end(); }
         void append( T* item )
         {
            m_initialized = true;
            m_array.push_back( item );
         }

         int marshal( unsigned char ** pp ) const
         {
            int r=0;
            int ret=0;
            unsigned char * p;

            Integer length(m_array.size());
            ret += length.marshal(0);

            ArrayItr itr = m_array.begin();
            ArrayItr end = m_array.end();
            for ( ; itr != end ; ++itr )
            {
               ret += (*itr)->marshal(0);
            }
            M_ASN1_I2D_seq_total();

            length.marshal(&p);
            itr = m_array.begin();
            for ( ; itr != end ; ++itr )
            {
               (*itr)->marshal(&p);
            }
            M_ASN1_I2D_finish();
         }

         void* unmarshal( void* bogus, unsigned char** pp, long length )
         {
            if ( m_initialized )
            {
               return 0;
            }
            if ( (0 == pp) || (0 == *pp) )
            {
               return 0;
            }
            ASN1_CTX c;
            c.pp = pp;
            c.q = *pp;
            c.error = ERR_R_NESTED_ASN1_ERROR;
            int i;
            Integer alength;

            M_ASN1_D2I_Init();
            M_ASN1_D2I_start_sequence();
            M_ASN1_D2I_get(i, alength.unmarshal);
            for ( int j = 0 ; j < alength.value() ; ++j )
            {
               T* item = new T;
               M_ASN1_D2I_get(i, item->unmarshal);
               m_array.push_back(item);
            }
            if ( ! asn1_Finish(&c) )
            {
               return 0;
            }
            *pp = c.p;
            m_initialized = true;
            return this;
           err: // needed by ASN.1 macros
            return 0;
         }

      protected :

      private :
         ArrayType  m_array;
   };

}

#endif /* __CODEX_ASN1_ARRAY_H__ */

---