Base64.hpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:9k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 2001, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  56. /*
  57.  * $Id: Base64.hpp,v 1.6 2003/05/20 21:32:02 peiyongz Exp $
  58.  */
  59. #ifndef BASE64_HPP
  60. #define BASE64_HPP
  61. #include <xercesc/util/XercesDefs.hpp>
  62. #include <xercesc/util/XMLUniDefs.hpp>
  63. #include <xercesc/framework/MemoryManager.hpp>
  64. XERCES_CPP_NAMESPACE_BEGIN
  65. //
  66. // This class provides encode/decode for RFC 2045 Base64 as
  67. // defined by RFC 2045, N. Freed and N. Borenstein.
  68. // RFC 2045: Multipurpose Internet Mail Extensions (MIME)
  69. // Part One: Format of Internet Message Bodies. Reference
  70. // 1996 Available at: http://www.ietf.org/rfc/rfc2045.txt
  71. // This class is used by XML Schema binary format validation
  72. //
  73. //
  74. class XMLUTIL_EXPORT Base64
  75. {
  76. public :
  77.     //@{
  78.     /**
  79.      * Encodes octets into Base64 data
  80.      *
  81.      * NOTE: The returned buffer is dynamically allocated and is the
  82.      * responsibility of the caller to delete it when not longer needed.
  83.      * You can call XMLString::release to release this returned buffer.
  84.      *
  85.      * If a memory manager is provided, ask the memory manager to de-allocate
  86.      * the returned buffer.
  87.      *
  88.      * @param inputData Binary data in XMLByte stream.
  89.      * @param inputLength Length of the XMLByte stream.
  90.      * @param outputLength Length of the encoded Base64 byte stream.
  91.      * @param memMgr, client provided memory manager
  92.      * @return Encoded Base64 data in XMLByte stream,
  93.      *      or NULL if input data can not be encoded.
  94.      * @see   XMLString::release(XMLByte**)
  95.      */
  96.     static XMLByte* encode(const XMLByte* const inputData
  97.                          , const unsigned int   inputLength
  98.                          , unsigned int*        outputLength
  99.                          , MemoryManager* const memMgr = 0);
  100.     /**
  101.      * Decodes Base64 data into octets
  102.      *
  103.      * NOTE: The returned buffer is dynamically allocated and is the
  104.      * responsibility of the caller to delete it when not longer needed.
  105.      * You can call XMLString::release to release this returned buffer.
  106.      *
  107.      * If a memory manager is provided, ask the memory manager to de-allocate
  108.      * the returned buffer.
  109.      *
  110.      * @param inputData Base64 data in XMLByte stream.
  111.      * @param outputLength Length of decoded XMLByte stream.
  112.      * @param memMgr, client provided memory manager
  113.      * @return Decoded binary data in XMLByte stream,
  114.      *      or NULL if input data can not be decoded.
  115.      * @see   XMLString::release(XMLByte**)
  116.      */
  117.     static XMLByte* decode(const XMLByte* const inputData
  118.                          , unsigned int*        outputLength
  119.                          , MemoryManager* const memMgr = 0);
  120.     /**
  121.      * Decodes Base64 data into XMLCh
  122.      *
  123.      * NOTE: The returned buffer is dynamically allocated and is the
  124.      * responsibility of the caller to delete it when not longer needed.
  125.      * You can call XMLString::release to release this returned buffer.
  126.      *
  127.      * If a memory manager is provided, ask the memory manager to de-allocate
  128.      * the returned buffer.
  129.      *
  130.      * @param inputData Base64 data in XMLCh stream.
  131.      * @param outputLength Length of decoded XMLCh stream
  132.      * @param memMgr, client provided memory manager
  133.      * @return Decoded binary data in XMLCh stream,
  134.      *      or NULL if input data can not be decoded.
  135.      * @see   XMLString::release(XMLCh**)
  136.      */
  137.     static XMLCh* decode(const XMLCh* const   inputData
  138.                        , unsigned int*        outputLength
  139.                        , MemoryManager* const memMgr = 0);
  140.     /**
  141.      * Get data length
  142.  *
  143.      * Returns length of decoded data given an array
  144.      * containing encoded data.
  145.      *
  146.      * @param inputData Base64 data in XMLCh stream.
  147.      * @return Length of decoded data,
  148.  *      or -1 if input data can not be decoded.
  149.      */
  150.     static int getDataLength(const XMLCh* const inputData);
  151.     //@}
  152. private :
  153.     // -----------------------------------------------------------------------
  154.     //  Helper methods
  155.     // -----------------------------------------------------------------------
  156.     static void init();
  157.     static bool isData(const XMLByte& octet);
  158.     static bool isPad(const XMLByte& octet);
  159.     static XMLByte set1stOctet(const XMLByte&, const XMLByte&);
  160.     static XMLByte set2ndOctet(const XMLByte&, const XMLByte&);
  161.     static XMLByte set3rdOctet(const XMLByte&, const XMLByte&);
  162.     static void split1stOctet(const XMLByte&, XMLByte&, XMLByte&);
  163.     static void split2ndOctet(const XMLByte&, XMLByte&, XMLByte&);
  164.     static void split3rdOctet(const XMLByte&, XMLByte&, XMLByte&);
  165.     // -----------------------------------------------------------------------
  166.     //  Unimplemented constructors and operators
  167.     // -----------------------------------------------------------------------
  168.     Base64();
  169.     Base64(const Base64&);
  170.     // -----------------------------------------------------------------------
  171.     //  Private data members
  172.     //
  173.     //  base64Alphabet
  174.     //     The Base64 alphabet (see RFC 2045).
  175.     //
  176.     //  base64Padding
  177.     //     Padding character (see RFC 2045).
  178.     //
  179.     //  base64Inverse
  180.     //     Table used in decoding base64.
  181.     //
  182.     //  isInitialized
  183.     //     Set once base64Inverse is initalized.
  184.     //
  185.     //  quadsPerLine
  186.     //     Number of quadruplets per one line. The encoded output
  187.     //     stream must be represented in lines of no more
  188.     //     than 19 quadruplets each.
  189.     //
  190.     // -----------------------------------------------------------------------
  191.     static const XMLByte  base64Alphabet[];
  192.     static const XMLByte  base64Padding;
  193.     static XMLByte  base64Inverse[];
  194.     static bool  isInitialized;
  195.     static const unsigned int  quadsPerLine;
  196. };
  197. // -----------------------------------------------------------------------
  198. //  Helper methods
  199. // -----------------------------------------------------------------------
  200. inline bool Base64::isPad(const XMLByte& octet)
  201. {
  202.     return ( octet == base64Padding );
  203. }
  204. inline XMLByte Base64::set1stOctet(const XMLByte& b1, const XMLByte& b2)
  205. {
  206.     return (( b1 << 2 ) | ( b2 >> 4 ));
  207. }
  208. inline XMLByte Base64::set2ndOctet(const XMLByte& b2, const XMLByte& b3)
  209. {
  210.     return (( b2 << 4 ) | ( b3 >> 2 ));
  211. }
  212. inline XMLByte Base64::set3rdOctet(const XMLByte& b3, const XMLByte& b4)
  213. {
  214.     return (( b3 << 6 ) | b4 );
  215. }
  216. inline void Base64::split1stOctet(const XMLByte& ch, XMLByte& b1, XMLByte& b2) {
  217.     b1 = ch >> 2;
  218.     b2 = ( ch & 0x3 ) << 4;
  219. }
  220. inline void Base64::split2ndOctet(const XMLByte& ch, XMLByte& b2, XMLByte& b3) {
  221.     b2 |= ch >> 4;  // combine with previous value
  222.     b3 = ( ch & 0xf ) << 2;
  223. }
  224. inline void Base64::split3rdOctet(const XMLByte& ch, XMLByte& b3, XMLByte& b4) {
  225.     b3 |= ch >> 6;  // combine with previous value
  226.     b4 = ( ch & 0x3f );
  227. }
  228. XERCES_CPP_NAMESPACE_END
  229. #endif