Base.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: Base.h,v 1.4 2005/01/21 19:44:15 mmarsh Exp $
//
// $Log: Base.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:31:46  mmarsh
// *** empty log message ***
//
//

#ifndef __CODEX_ASN1_BASE_H__
#define __CODEX_ASN1_BASE_H__


#include <openssl/asn1.h>
#include <openssl/asn1_mac.h>
#include <openssl/err.h>
#include <string>
#include <iostream>
#include "config.h"

#ifdef NEED_CHAR_TRAITS_UCHAR
namespace std {
   template<>
   struct char_traits<unsigned char>
   {
         typedef unsigned char     char_type;
         typedef unsigned int      int_type;
         typedef streampos         pos_type;
         typedef streamoff         off_type;
         typedef mbstate_t         state_type;

         static void 
         assign(char_type& __c1, const char_type& __c2)
         { __c1 = __c2; }

         static bool 
         eq(const char_type& __c1, const char_type& __c2)
         { return __c1 == __c2; }

         static bool 
         lt(const char_type& __c1, const char_type& __c2)
         { return __c1 < __c2; }

         static int 
         compare(const char_type* __s1, const char_type* __s2, size_t __n)
         { return memcmp(__s1, __s2, __n); }

         static size_t
         length(const char_type* __s)
         { return strlen((const char*)__s); }

         static const char_type* 
         find(const char_type* __s, size_t __n, const char_type& __a)
         { return static_cast<const char_type*>(memchr(__s, __a, __n)); }

         static char_type* 
         move(char_type* __s1, const char_type* __s2, size_t __n)
         { return static_cast<char_type*>(memmove(__s1, __s2, __n)); }

         static char_type* 
         copy(char_type* __s1, const char_type* __s2, size_t __n)
         {  return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }

         static char_type* 
         assign(char_type* __s, size_t __n, char_type __a)
         { return static_cast<char_type*>(memset(__s, __a, __n)); }

         static char_type 
         to_char_type(const int_type& __c)
         { return static_cast<char_type>(__c); }

         // To keep both the byte 0xff and the eof symbol 0xffffffff
         // from ending up as 0xffffffff.
         static int_type 
         to_int_type(const char_type& __c)
         { return static_cast<int_type>(static_cast<unsigned char>(__c)); }

         static bool 
         eq_int_type(const int_type& __c1, const int_type& __c2)
         { return __c1 == __c2; }

         static int_type 
         eof() { return static_cast<int_type>(EOF); }

         static int_type 
         not_eof(const int_type& __c)
         { return (__c == eof()) ? 0 : __c; }
   };
}
#endif /* NEED_CHAR_TRAITS_UCHAR */

using namespace std;

namespace CODEX_ASN1
{
   typedef basic_string< unsigned char > ustring;

   class Base
   {
      public :
         Base( bool initialized );
         virtual ~Base();

         virtual int marshal( unsigned char ** pp ) const = 0;

         virtual void* unmarshal( void* bogus,
                                  unsigned char** pp,
                                  long length ) = 0;

         bool initialized() const { return m_initialized; }

      protected :
         bool m_initialized;

      private :
         void operator=( const Base& ); // stop default
   };

}

#endif /* __CODEX_ASN1_BASE_H__ */

---