utf7_encoding.h

 
#pragma once
 
#include <system/text/encoding.h>
 
namespace System { namespace Text {
 
class ASPOSECPP_SHARED_CLASS UTF7Encoding : public Encoding
{
private:
    class UTF7Decoder : public Decoder
    {
    private:
        int m_left_over;
 
    public:
        using Decoder::GetCharCount;
        using Decoder::Convert;
 
        ASPOSECPP_SHARED_API UTF7Decoder();
 
        ASPOSECPP_SHARED_API int GetCharCount(const uint8_t* bytes, int count, bool flush) override;
        ASPOSECPP_SHARED_API void Convert(const uint8_t* bytes, int byte_count, char_t* chars, int char_count, bool flush, int& bytes_used, int& chars_used, bool& completed) override;
    }; // class UTF7Decoder
 
private:
    class UTF7Encoder : public Encoder
    {
    private:
        bool m_allow_optionals;
        int m_left_over;
        bool m_is_in_shifted;
 
    public:
        using Encoder::GetByteCount;
        using Encoder::Convert;
 
        ASPOSECPP_SHARED_API UTF7Encoder(bool allow_optionals);
 
        ASPOSECPP_SHARED_API int GetByteCount(const char_t* chars, int count, bool flush) override;
        ASPOSECPP_SHARED_API void Convert(const char_t* chars, int char_count, uint8_t* bytes, int byte_count, bool flush, int& chars_used, int& bytes_used, bool& completed) override;
    }; // class UTF7Encoder
 
public:
    static constexpr int UTF7_CODE_PAGE = 65000;
 
private:
    bool m_allow_optionals;
 
    static const ArrayPtr<uint8_t> encoding_rules;
    static const String base64_chars;
    static const ArrayPtr<char> base64_values;
 
public:
    using Encoding::GetByteCount;
    using Encoding::GetBytes;
    using Encoding::GetCharCount;
    using Encoding::GetChars;
    using Encoding::GetString;
 
    ASPOSECPP_SHARED_API UTF7Encoding();
    ASPOSECPP_SHARED_API UTF7Encoding(bool allow_optionals);
 
    ASPOSECPP_SHARED_API bool operator==(const UTF7Encoding& other) const;
    ASPOSECPP_SHARED_API bool Equals(SharedPtr<Object> obj) override;
    ASPOSECPP_SHARED_API int GetHashCode() const override;
 
    ASPOSECPP_SHARED_API SharedPtr<Object> Clone() override;
 
    ASPOSECPP_SHARED_API int GetBytes(ArrayPtr<char_t> chars, int char_index, int char_count, ArrayPtr<uint8_t> bytes, int byte_index) override;
    ASPOSECPP_SHARED_API int GetCharCount(ArrayPtr<uint8_t> bytes, int index, int count) override;
 
public:
    ASPOSECPP_SHARED_API int GetChars(ArrayPtr<uint8_t> bytes, int byte_index, int byte_count, ArrayPtr<char_t> chars, int char_index) override;
    ASPOSECPP_SHARED_API int GetMaxByteCount(int char_count) override;
    ASPOSECPP_SHARED_API int GetMaxCharCount(int byte_count) override;
    ASPOSECPP_SHARED_API DecoderPtr GetDecoder() override;
    ASPOSECPP_SHARED_API EncoderPtr GetEncoder() override;
 
    ASPOSECPP_SHARED_API int GetByteCount(const char_t* chars, int count) override;
 
    ASPOSECPP_SHARED_API int GetBytes(const char_t* chars, int char_count, uint8_t* bytes, int byte_count) override;
    ASPOSECPP_SHARED_API int GetBytes(const String& s, int char_index, int char_count, ArrayPtr<uint8_t> bytes, int byte_index) override;
 
    ASPOSECPP_SHARED_API int GetCharCount(const uint8_t* bytes, int count) override;
    ASPOSECPP_SHARED_API int GetChars(const uint8_t* bytes, int byte_count, char_t* chars, int char_count) override;
 
    ASPOSECPP_SHARED_API String GetString(ArrayPtr<uint8_t> bytes, int index, int count) override;
 
private:
    void InitializeInstanceFields();
 
    static int InternalGetByteCount(const char_t* chars, int chars_count, int index, int count, bool flush, int left_over, bool is_in_shifted, bool allow_optionals);
    static int InternalGetBytes(const ArrayPtr<char_t>& chars, int char_index, int char_count, const ArrayPtr<uint8_t>& bytes, int byte_index, bool flush, int& left_over, bool& is_in_shifted, bool allow_optionals);
    static int InternalGetBytes(const char_t* chars, int char_count, uint8_t* bytes, int byte_count, bool flush, int& left_over, bool& is_in_shifted, bool allow_optionals);
 
    static int InternalGetCharCount(const uint8_t* bytes, int bytes_count, int index, int count, int left_over);
    static int InternalGetChars(const ArrayPtr<uint8_t>& bytes, int byte_index, int byte_count, const ArrayPtr<char_t>& chars, int char_index, int& left_over);
    static int InternalGetChars(const uint8_t* bytes, int& byte_count, char_t* chars, int char_count, int& left_over,
                                bool& completed);
}; // class UTF7Encoding
 
}} // namespace System::Text