cel_base64.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_base64_h_
#define _cel_base64_h_

#include "cel_string.h"
#include "cel_memory.h"

namespace Celartem
{
    template<typename Base64Traits> struct Base64T
    {
        static String encode(const u8 * CEL_RESTRICT src, size_t size)
        {
            if(size == 0)
                return String(L"");

            String str;
            UChar1 *p = str.allocate((size + 2) / 3 * 4);
            for(;;)
            {
                if(size <= 3)
                {
                    encode_3bytes(p, src, size);
                    return str;
                }
                
                encode_3bytes(p, src, 3);
                p += 4;
                src += 3;
                size -= 3;
            }
        }

        static void decode(SimpleArray<u8>& buffer, const String& src)
        {
            size_t n = src.getLength() / 4;
            buffer.resize(n * 3);
            u8 *p = &buffer[0];
            const UChar1 *q = src.c_str();
            size_t realSize = 0;
            for(size_t i = 0; i < n; i++)
            {
                realSize += decode_4chars(p, q);
                p += 3;
                q += 4;
            }
            buffer.resize(realSize);
            return;
        }

        static void encode_3bytes(
            char * CEL_RESTRICT buffer,
            const u8 * CEL_RESTRICT src, size_t size)
        {
            u8 tmp[3] = {0, 0, 0};
            for(size_t i = 0; i < size; i++)
                tmp[i] = src[i];

            buffer[0] = (char)Base64Traits::enc(tmp[0] >> 2);
            buffer[1] = (char)Base64Traits::enc(((tmp[0] & 3) << 4) | (tmp[1] >> 4));
            buffer[2] = (char)Base64Traits::enc(((tmp[1] & 15) << 2) | (tmp[2] >> 6));
            buffer[3] = (char)Base64Traits::enc(tmp[2] & 63);

            if(size == 1) buffer[2] = '=';
            if(size <= 2) buffer[3] = '=';
        }

        static size_t decode_4chars(
            u8 * CEL_RESTRICT buffer,
            const UChar1 * CEL_RESTRICT src)
        {
            int tmp[4];
            for(size_t i = 0; i < 4; i++)
                tmp[i] = Base64Traits::dec(src[i]);

            buffer[0] = (tmp[0] << 2) | (tmp[1] >> 4);
            if(tmp[2] < 0)
                return 1;

            buffer[1] = ((tmp[1] & 15) << 4) | (tmp[2] >> 2);
            if(tmp[3] < 0)
                return 2;

            buffer[2] = ((tmp[2] & 3) << 6) | tmp[3];
            return 3;
        }
    };
    
    struct Base64Traits_A
    {
        static int dec(int 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;
            if(c == '/') return 63;
            return -1;
        }

        static int enc(int w)
        {
            if(w <= 25) return (int)w + 'A';
            if(w <= 51) return (int)w - 26 + 'a';
            if(w <= 61) return (int)w - 52 + '0';
            if(w == 62) return '+';
            return '/';
        }
    };

    struct UrlSafeBase64Traits
    {
        static int dec(int 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;
            if(c == '!') return 63;
            return -1;
        }

        static int enc(int w)
        {
            if(w <= 25) return (int)w + 'A';
            if(w <= 51) return (int)w - 26 + 'a';
            if(w <= 61) return (int)w - 52 + '0';
            if(w == 62) return '-';
            return '!';
        }
    };

    typedef Base64T<Base64Traits_A> Base64;
    
    typedef Base64T<UrlSafeBase64Traits> UrlSafeBase64;
    
    
} // namespace Celartem

#endif // _cel_base64_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.