EncodeBase64

Function to encode any data input array into a BASE64 string.

The output string has to be allocated by the host. The return value defines the length of the string size in bytes.

Terminator adds a 0 element to the end of the BASE64 generated string, it will NOT increase the length.

If output is nullptr the length will be calculated but the string itself will not be generated.

Syntax

C++ 32 bit

C++ 64 bit

C# 32 bit

C# 64 bit

//
//   Strong typing definition
//
int64_t         EncodeBase64(
                        char                    * output,
                        const unsigned char     * input,
                        int64_t                 size,
                        bool                    terminator
                    );

static  inline  int64_t EncodeBase64(
                                char                    * output,
                                const unsigned char     * input,
                                int64_t                 size
                            )
{
    return  EncodeBase64(
                    output,
                    input,
                    size,
                    false                               //    terminator
                );
}

static  inline  char    * EncodeBase64(
                                const unsigned char     * input,
                                int64_t                 size
                            )
{
#ifdef _ALLOC
    char    * output = (char*) malloc((int_t) EncodeBase64(nullptr, input, size) + sizeof(char));
#else
    char    * output = new char[(int_t) EncodeBase64(nullptr, input, size) / sizeof(char) + 1];
#endif

    EncodeBase64(
            output,
            input,
            size,
            true                                //    terminator
        );

    return  output;
}


//
//   Weak typing definition
//
int64_t __declspec(dllexport) __stdcall EncodeBase64(
                                                char                    * output,
                                                const unsigned char     * input,
                                                int64_t                 size,
                                                bool                    terminator
                                            );

static  inline  int64_t EncodeBase64(
                                char                    * output,
                                const unsigned char     * input,
                                int64_t                 size
                            )
{
    return  EncodeBase64(
                    output,
                    input,
                    size,
                    false                               //    terminator
                );
}

static  inline  char    * EncodeBase64(
                                const unsigned char     * input,
                                int64_t                 size
                            )
{
#ifdef _ALLOC
    char    * output = (char*) malloc((int_t) EncodeBase64(nullptr, input, size) + sizeof(char));
#else
    char    * output = new char[(int_t) EncodeBase64(nullptr, input, size) / sizeof(char) + 1];
#endif

    EncodeBase64(
            output,
            input,
            size,
            true                                //    terminator
        );

    return  output;
}

Property output

Size: 64 bit / 8 byte (reference)
???.

Property input

Size: 64 bit / 8 byte (reference)
???.

Property size

Size: 64 bit / 8 byte (value)
The given size.

Property terminator

Size: 8 bit / 1 byte (value)
If defined the generated string will have an added terminator (zero).