Xerces-C++: Base64.hpp Source File

- Main Page
- Related Pages
- Classes
- Files

# Base64.hpp

Go to the documentation of this file.

    00001 /*
    00002  * Licensed to the Apache Software Foundation (ASF) under one or more
    00003  * contributor license agreements.  See the NOTICE file distributed with
    00004  * this work for additional information regarding copyright ownership.
    00005  * The ASF licenses this file to You under the Apache License, Version 2.0
    00006  * (the "License"); you may not use this file except in compliance with
    00007  * the License.  You may obtain a copy of the License at
    00008  *
    00009  *      http://www.apache.org/licenses/LICENSE-2.0
    00010  *
    00011  * Unless required by applicable law or agreed to in writing, software
    00012  * distributed under the License is distributed on an "AS IS" BASIS,
    00013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    00014  * See the License for the specific language governing permissions and
    00015  * limitations under the License.
    00016  */
    00017
    00018 /*
    00019  * $Id: Base64.hpp 932887 2010-04-11 13:04:59Z borisk $
    00020  */
    00021
    00022 #if !defined(XERCESC_INCLUDE_GUARD_BASE64_HPP)
    00023 #define XERCESC_INCLUDE_GUARD_BASE64_HPP
    00024
    00025 #include <xercesc/util/XercesDefs.hpp>
    00026 #include <xercesc/util/XMLUniDefs.hpp>
    00027 #include <xercesc/framework/MemoryManager.hpp>
    00028
    00029 XERCES_CPP_NAMESPACE_BEGIN
    00030
    00031 //
    00032 // This class provides encode/decode for RFC 2045 Base64 as
    00033 // defined by RFC 2045, N. Freed and N. Borenstein.
    00034 // RFC 2045: Multipurpose Internet Mail Extensions (MIME)
    00035 // Part One: Format of Internet Message Bodies. Reference
    00036 // 1996 Available at: http://www.ietf.org/rfc/rfc2045.txt
    00037 // This class is used by XML Schema binary format validation
    00038 //
    00039 //
    00040 class XMLUTIL_EXPORT Base64
    00041 {
    00042 public :
    00043
    00044     enum Conformance
    00045     {
    00046         Conf_RFC2045
    00047       , Conf_Schema
    00048     };
    00049
    00051
    00067     static XMLByte* encode(const XMLByte* const inputData
    00068                          , const XMLSize_t      inputLength
    00069                          , XMLSize_t*           outputLength
    00070                          , MemoryManager* const memMgr = 0);
    00071
    00091     static XMLByte* decode(
    00092                            const XMLByte*        const   inputData
    00093                          ,       XMLSize_t*              decodedLength
    00094                          ,       MemoryManager*  const   memMgr = 0
    00095                          ,       Conformance             conform = Conf_RFC2045
    00096                           );
    00097
    00117     static XMLByte* decodeToXMLByte(
    00118                            const XMLCh*          const   inputData
    00119                          ,       XMLSize_t*              decodedLength
    00120                          ,       MemoryManager*  const   memMgr = 0
    00121                          ,       Conformance             conform = Conf_RFC2045
    00122                           );
    00135     static int getDataLength(
    00136                              const XMLCh*         const  inputData
    00137                             ,      MemoryManager* const  memMgr = 0
    00138                             ,      Conformance           conform = Conf_RFC2045
    00139                              );
    00140
    00142
    00158     static XMLCh* getCanonicalRepresentation
    00159                   (
    00160                       const XMLCh*          const inputData
    00161                     ,       MemoryManager*  const memMgr = 0
    00162                     ,       Conformance           conform = Conf_RFC2045
    00163                   );
    00164
    00165 private :
    00166
    00167     // -----------------------------------------------------------------------
    00168     //  Helper methods
    00169     // -----------------------------------------------------------------------
    00170
    00171     static XMLByte* decode(
    00172                            const XMLByte*        const   inputData
    00173                          ,       XMLSize_t*              outputLength
    00174                          ,       XMLByte*&               canRepData
    00175                          ,       MemoryManager*  const   memMgr = 0
    00176                          ,       Conformance             conform = Conf_RFC2045
    00177                           );
    00178
    00179     static bool isData(const XMLByte& octet);
    00180     static bool isPad(const XMLByte& octet);
    00181
    00182     static XMLByte set1stOctet(const XMLByte&, const XMLByte&);
    00183     static XMLByte set2ndOctet(const XMLByte&, const XMLByte&);
    00184     static XMLByte set3rdOctet(const XMLByte&, const XMLByte&);
    00185
    00186     static void split1stOctet(const XMLByte&, XMLByte&, XMLByte&);
    00187     static void split2ndOctet(const XMLByte&, XMLByte&, XMLByte&);
    00188     static void split3rdOctet(const XMLByte&, XMLByte&, XMLByte&);
    00189
    00190     // -----------------------------------------------------------------------
    00191     //  Unimplemented constructors and operators
    00192     // -----------------------------------------------------------------------
    00193     Base64();
    00194     Base64(const Base64&);
    00195
    00196     // -----------------------------------------------------------------------
    00197     //  Private data members
    00198     //
    00199     //  base64Alphabet
    00200     //     The Base64 alphabet (see RFC 2045).
    00201     //
    00202     //  base64Padding
    00203     //     Padding character (see RFC 2045).
    00204     //
    00205     //  base64Inverse
    00206     //     Table used in decoding base64.
    00207     //
    00208     //  isInitialized
    00209     //     Set once base64Inverse is initialized.
    00210     //
    00211     //  quadsPerLine
    00212     //     Number of quadruplets per one line. The encoded output
    00213     //     stream must be represented in lines of no more
    00214     //     than 19 quadruplets each.
    00215     //
    00216     // -----------------------------------------------------------------------
    00217
    00218     static const XMLByte  base64Alphabet[];
    00219     static const XMLByte  base64Padding;
    00220
    00221     static const XMLByte  base64Inverse[];
    00222
    00223     static const unsigned int  quadsPerLine;
    00224 };
    00225
    00226 // -----------------------------------------------------------------------
    00227 //  Helper methods
    00228 // -----------------------------------------------------------------------
    00229 inline bool Base64::isPad(const XMLByte& octet)
    00230 {
    00231     return ( octet == base64Padding );
    00232 }
    00233
    00234 inline XMLByte Base64::set1stOctet(const XMLByte& b1, const XMLByte& b2)
    00235 {
    00236     return (( b1 << 2 ) | ( b2 >> 4 ));
    00237 }
    00238
    00239 inline XMLByte Base64::set2ndOctet(const XMLByte& b2, const XMLByte& b3)
    00240 {
    00241     return (( b2 << 4 ) | ( b3 >> 2 ));
    00242 }
    00243
    00244 inline XMLByte Base64::set3rdOctet(const XMLByte& b3, const XMLByte& b4)
    00245 {
    00246     return (( b3 << 6 ) | b4 );
    00247 }
    00248
    00249 inline void Base64::split1stOctet(const XMLByte& ch, XMLByte& b1, XMLByte& b2) {
    00250     b1 = ch >> 2;
    00251     b2 = ( ch & 0x3 ) << 4;
    00252 }
    00253
    00254 inline void Base64::split2ndOctet(const XMLByte& ch, XMLByte& b2, XMLByte& b3) {
    00255     b2 |= ch >> 4;  // combine with previous value
    00256     b3 = ( ch & 0xf ) << 2;
    00257 }
    00258
    00259 inline void Base64::split3rdOctet(const XMLByte& ch, XMLByte& b3, XMLByte& b4) {
    00260     b3 |= ch >> 6;  // combine with previous value
    00261     b4 = ( ch & 0x3f );
    00262 }
    00263
    00264 XERCES_CPP_NAMESPACE_END
    00265
    00266 #endif