(file) Return to Base64.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Base64.cpp between version 1.5 and 1.18

version 1.5, 2002/02/08 17:13:14 version 1.18, 2003/10/22 14:26:01
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2003////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
   // IBM Corp.; EMC Corporation, The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 27 
Line 29 
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "Base64.h"  
 #include <cassert>  
 #include <strstream> #include <strstream>
 #include <string>  #include "Base64.h"
 #include <Pegasus/Common/String.h>  #include <Pegasus/Common/ArrayInternal.h>
 #include <Pegasus/Common/Base64.h>  
 #include <Pegasus/Common/Array.h>  
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
 PEGASUS_USING_STD; PEGASUS_USING_STD;
Line 42 
Line 40 
 #define inline #define inline
 #endif #endif
  
   
   //**********************************************************
   /*  Encode thanslates one six-bit pattern into a base-64 character.
       Unsigned char is used to represent a six-bit stream of date.
   
   */
   inline PEGASUS_COMMON_LINKAGE char Base64::_Encode(Uint8 uc)
   {
       if (uc < 26)
           return 'A'+uc;
   
       if (uc < 52)
           return 'a'+(uc-26);
   
       if (uc < 62)
           return '0'+(uc-52);
   
       if (uc == 62)
           return '+';
   
       return '/';
   };
   
    //Helper function returns true is a character is a valid base-64 character and false otherwise.
   
   inline Boolean Base64::_IsBase64(char c)
   {
   
       if (c >= 'A' && c <= 'Z')
           return true;
   
       if (c >= 'a' && c <= 'z')
           return true;
   
       if (c >= '0' && c <= '9')
           return true;
   
       if (c == '+')
           return true;
   
       if (c == '/')
           return true;
   
       if (c == '=')
           return true;
   
       return false;
   };
   
    // Translate one base-64 character into a six bit pattern
   inline Uint8 Base64::_Decode(char c)
   {
       if (c >= 'A' && c <= 'Z')
           return c - 'A';
       if (c >= 'a' && c <= 'z')
           return c - 'a' + 26;
   
       if (c >= '0' && c <= '9')
           return c - '0' + 52;
   
       if (c == '+')
           return 62;
   
       return 63;
   };
   
   
 //************************************************************* //*************************************************************
 /*  Encode static method takes an array of 8-bit values and /*  Encode static method takes an array of 8-bit values and
     returns a base-64 stream.     returns a base-64 stream.
Line 56 
Line 121 
     if (vby.size() == 0)     if (vby.size() == 0)
         return retArray;         return retArray;
     // for every character in the input array taken 3 bytes at a time     // for every character in the input array taken 3 bytes at a time
   
     for (Uint32 i=0; i < vby.size(); i+=3)     for (Uint32 i=0; i < vby.size(); i+=3)
     {     {
  
Line 86 
Line 150 
         else         else
             retArray.append('=');             retArray.append('=');
  
   
         if (i+2<vby.size())         if (i+2<vby.size())
             retArray.append( _Encode(by7));             retArray.append( _Encode(by7));
         else         else
             retArray.append('=');             retArray.append('=');
  
           /* ATTN: Need to fix this. It adds unwanted cr-lf after 4 chars.
   
         if (i % (76/4*3) == 0)         if (i % (76/4*3) == 0)
         {         {
             retArray.append( '\r');             retArray.append( '\r');
             retArray.append( '\n');             retArray.append( '\n');
         }         }
           */
     };     };
  
     return retArray;     return retArray;
 }; };
 /*I checked for the zero length. The algorithm would also work for zero length input stream, but I’m pretty adamant about handling border conditions. They are often the culprits of run-time production failures. /*I checked for the zero length. The algorithm would also work for zero length input stream, but I’m pretty adamant about handling border conditions. They are often the culprits of run-time production failures.
 The algorithm goes thru each three bytes of data at a time. The first thing I do is to shift the bits around from three 8-bit values to four 6-bit values. Then I encode the 6-bit values and add then one at a time to the output stream. This is actually quite inefficient. The STL character array is being allocated one byte at a time. The algorithm would be much faster, if I pre-allocated that array. I’ll leave that as an optimization practical exercise for the reader. The algorithm goes thru each three bytes of data at a time. The first thing I do is to shift the bits around from three 8-bit values to four 6-bit values. Then I encode the 6-bit values and add then one at a time to the output stream. This is actually quite inefficient. The STL character array is being allocated one byte at a time. The algorithm would be much faster, if I pre-allocated that array. I’ll leave that as an optimization practical exercise for the reader.
   */
  
 /*  The decode static method takes a base-64 stream and converts it /*  The decode static method takes a base-64 stream and converts it
     to an array of 8-bit values.     to an array of 8-bit values.
Line 110 
Line 178 
 Array<Uint8> Base64::decode(const Array<Sint8> strInput) Array<Uint8> Base64::decode(const Array<Sint8> strInput)
 { {
     //Strip any non-base64 characters from the input     //Strip any non-base64 characters from the input
     PEGASUS_STD(string) str;      Array<Sint8> str;
     for (Uint32 j=0;j<strInput.size();j++)     for (Uint32 j=0;j<strInput.size();j++)
     {     {
         if (_IsBase64(strInput[j]))         if (_IsBase64(strInput[j]))
             str += strInput[j];              str.append(strInput[j]);
     }     }
  
     Array<Uint8> retArray;     Array<Uint8> retArray;
  
     // Return if the input is zero length     // Return if the input is zero length
     if (str.length() == 0)      if (str.size() == 0)
         return retArray;         return retArray;
  
     //  comment     //  comment
     for (int i=0; i < str.length();i+=4)      for (Uint32 i=0; i < str.size(); i+=4)
     {     {
         char c1='A',c2='A',c3='A',c4='A';         char c1='A',c2='A',c3='A',c4='A';
  
         c1 = str[i];         c1 = str[i];
         if (i+1<str.length())          if (i+1<str.size())
             c2 = str[i+1];             c2 = str[i+1];
         if (i+2<str.length())          if (i+2<str.size())
             c3 = str[i+2];             c3 = str[i+2];
         if (i+3<str.length())          if (i+3<str.size())
             c4 = str[i+3];             c4 = str[i+3];
  
         Uint8 by1=0,by2=0,by3=0,by4=0;         Uint8 by1=0,by2=0,by3=0,by4=0;
Line 158 
Line 226 
             retArray.append( ((by3&0x3)<<6)|by4 );             retArray.append( ((by3&0x3)<<6)|by4 );
     }     }
  
     return retArray;  
 };  
   
 //**********************************************************  
 /*  Encode thanslates one six-bit pattern into a base-64 character.  
     Unsigned char is used to represent a six-bit stream of date.  
   
 */  
 inline PEGASUS_COMMON_LINKAGE char Base64::_Encode(Uint8 uc)  
 {  
     if (uc < 26)  
         return 'A'+uc;  
   
     if (uc < 52)  
         return 'a'+(uc-26);  
   
     if (uc < 62)  
         return '0'+(uc-52);  
   
     if (uc == 62)  
         return '+';  
   
     return '/';  
 };  
   
  //Helper function returns true is a character is a valid base-64 character and false otherwise.  
   
 inline Boolean Base64::_IsBase64(char c)  
 {  
   
     if (c >= 'A' && c <= 'Z')  
         return true;  
  
     if (c >= 'a' && c <= 'z')      return retArray;
         return true;  
   
     if (c >= '0' && c <= '9')  
         return true;  
   
     if (c == '+')  
         return true;  
   
     if (c == '/')  
         return true;  
   
     if (c == '=')  
         return true;  
   
     return false;  
 };  
   
  // Translate one base-64 character into a six bit pattern  
 inline Uint8 Base64::_Decode(char c)  
 {  
     if (c >= 'A' && c <= 'Z')  
         return c - 'A';  
     if (c >= 'a' && c <= 'z')  
         return c - 'a' + 26;  
   
     if (c >= '0' && c <= '9')  
         return c - '0' + 52;  
   
     if (c == '+')  
         return 62;  
   
     return 63;  
 }; };
  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.5  
changed lines
  Added in v.1.18
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2