a

doum

2 天以前 307960b07d8cb122d9de0c8267b8cb7a63cfc605

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// :mode=c++:
/*
encode.h - c++ wrapper for a base64 encoding algorithm
 
This is part of the libb64 project, and has been placed in the public domain.
For details, see http://sourceforge.net/projects/libb64
*/
#ifndef BASE64_ENCODE_H
#define BASE64_ENCODE_H
 
#include <iostream>
 
namespace base64
{
    extern "C"
    {
        #include "cencode.h"
    }
 
    struct encoder
    {
        base64_encodestate _state;
        int _buffersize;
 
        encoder(int buffersize_in = BUFFERSIZE)
        : _buffersize(buffersize_in)
        {
            base64_init_encodestate(&_state);
        }
 
        int encode(char value_in)
        {
            return base64_encode_value(value_in);
        }
 
        int encode(const char* code_in, const int length_in, char* plaintext_out)
        {
            return base64_encode_block(code_in, length_in, plaintext_out, &_state);
        }
 
        int encode_end(char* plaintext_out)
        {
            return base64_encode_blockend(plaintext_out, &_state);
        }
 
        void encode(std::istream& istream_in, std::ostream& ostream_in)
        {
            base64_init_encodestate(&_state);
            //
            const int N = _buffersize;
            char* plaintext = new char[N];
            char* code = new char[2*N];
            int plainlength;
            int codelength;
 
            do
            {
                istream_in.read(plaintext, N);
                plainlength = static_cast<int>(istream_in.gcount());
                //
                codelength = encode(plaintext, plainlength, code);
                ostream_in.write(code, codelength);
            }
            while (istream_in.good() && plainlength > 0);
 
            codelength = encode_end(code);
            ostream_in.write(code, codelength);
            //
            base64_init_encodestate(&_state);
 
            delete [] code;
            delete [] plaintext;
        }
    };
 
} // namespace base64
 
#endif // BASE64_ENCODE_H