encoding.h

 
#pragma once
 
#include <system/object.h>
#include <system/text/decoder_fallback.h>
#include <system/text/encoder_fallback.h>
#include <system/text/decoder.h>
#include <system/text/encoder.h>
#include <system/text/encoding_decoder.h>
#include <system/text/encoding_encoder.h>
#include <system/exceptions.h>
#include <system/details/array_view.h>
#include <system/details/stack_array.h>
#include <fwd.h>
 
 
namespace System {
 
template<typename> class ReadOnlySpan;
 
namespace Text {
 
namespace Details {
    struct EncodingInfoInternal;
}
 
class Encoding;
 
class ASPOSECPP_SHARED_CLASS EncodingInfo final : public Object
{
public:
    EncodingInfo(int codepage, const String& name, const String& display_name)
        : m_codepage(codepage)
        , m_name(name)
        , m_display_name(display_name)
    {}
 
    int get_CodePage() const { return m_codepage; }
    const String& get_Name() const { return m_name; }
    const String& get_DisplayName() const { return m_display_name; }
 
    ASPOSECPP_SHARED_API EncodingPtr GetEncoding();
 
private:
    const int m_codepage;
    const String m_name;
    const String m_display_name;
};
 
class ASPOSECPP_SHARED_CLASS Encoding : public Object
{
    RTTI_INFO(System::Text::Encoding, ::System::BaseTypesInfo<System::Object>)
    
public:
    typedef System::SharedPtr<Encoding> Ptr;
 
    static constexpr int DEFAULT_CODE_PAGE = 0;
 
    ASPOSECPP_SHARED_API bool Equals(SharedPtr<Object> obj) override;
    ASPOSECPP_SHARED_API int GetHashCode() const override;
 
    virtual ASPOSECPP_SHARED_API int get_CodePage();
    virtual ASPOSECPP_SHARED_API int get_WindowsCodePage();
 
    virtual ASPOSECPP_SHARED_API String get_WebName();
    virtual ASPOSECPP_SHARED_API String get_BodyName();
    virtual ASPOSECPP_SHARED_API String get_EncodingName();
    virtual ASPOSECPP_SHARED_API String get_HeaderName();
 
    virtual ASPOSECPP_SHARED_API bool get_IsSingleByte();
    virtual ASPOSECPP_SHARED_API bool get_IsBrowserDisplay();
    virtual ASPOSECPP_SHARED_API bool get_IsBrowserSave();
    virtual ASPOSECPP_SHARED_API bool get_IsMailNewsDisplay();
    virtual ASPOSECPP_SHARED_API bool get_IsMailNewsSave();
    ASPOSECPP_SHARED_API bool get_IsReadOnly();
 
    ASPOSECPP_SHARED_API DecoderFallbackPtr get_DecoderFallback() const;
    ASPOSECPP_SHARED_API void set_DecoderFallback(const DecoderFallbackPtr& value);
    ASPOSECPP_SHARED_API const EncoderFallbackPtr get_EncoderFallback() const;
    ASPOSECPP_SHARED_API void set_EncoderFallback(const EncoderFallbackPtr& value);
 
    static ASPOSECPP_SHARED_API ArrayPtr<uint8_t> Convert(const EncodingPtr& src_encoding, const EncodingPtr& dst_encoding, const ArrayPtr<uint8_t>& bytes);
    static ASPOSECPP_SHARED_API ArrayPtr<uint8_t> Convert(const EncodingPtr& src_encoding, const EncodingPtr& dst_encoding, const ArrayPtr<uint8_t>& bytes, int index, int count);
 
    virtual ASPOSECPP_SHARED_API int GetByteCount(ArrayPtr<char_t> chars, int index, int count);
 
    virtual ASPOSECPP_SHARED_API int GetByteCount(System::Details::ArrayView<char_t> chars, int index, int count);
    template<std::size_t N>
    int GetByteCount(const System::Details::StackArray<char_t, N> & chars, int index, int count)
    {
        return GetByteCount(static_cast<System::Details::ArrayView<char_t>>(chars), index, count);
    }
 
    virtual ASPOSECPP_SHARED_API int GetByteCount(const String& s);
    virtual ASPOSECPP_SHARED_API int GetByteCount(ArrayPtr<char_t> chars);
    virtual ASPOSECPP_SHARED_API int GetByteCount(const char_t *chars, int count);
 
    virtual ASPOSECPP_SHARED_API int GetBytes(ArrayPtr<char_t> chars, int char_index, int char_count, ArrayPtr<uint8_t> bytes, int byte_index);
    virtual ASPOSECPP_SHARED_API int GetBytes(System::Details::ArrayView<char_t> chars, int char_index, int char_count, System::Details::ArrayView<uint8_t> bytes, int byte_index);
    template<std::size_t SC, std::size_t  SB>
    int GetBytes(System::Details::StackArray<char_t, SC> &chars, int char_index, int char_count, System::Details::StackArray<uint8_t, SB> &bytes, int byte_index)
    {
        return GetBytes(static_cast<System::Details::ArrayView<char_t>>(chars), char_index, char_count, static_cast<System::Details::ArrayView<uint8_t>>(bytes), byte_index);
    }
 
    virtual ASPOSECPP_SHARED_API int GetBytes(const String &s, int char_index, int char_count, ArrayPtr<uint8_t> bytes, int byte_index);
    virtual ASPOSECPP_SHARED_API ArrayPtr<uint8_t> GetBytes(const String &s);
    virtual ASPOSECPP_SHARED_API ArrayPtr<uint8_t> GetBytes(ArrayPtr<char_t> chars, int index, int count);
    virtual ASPOSECPP_SHARED_API ArrayPtr<uint8_t> GetBytes(const System::Details::ArrayView<char_t> &chars, int index, int count);
    template<std::size_t N>
    ArrayPtr<uint8_t> GetBytes(const System::Details::StackArray<char_t, N> &chars, int index, int count)
    {
        return GetBytes(static_cast<System::Details::ArrayView<char_t>>(chars), index, count);
    }
    
    virtual ASPOSECPP_SHARED_API ArrayPtr<uint8_t> GetBytes(ArrayPtr<char_t> chars);
    virtual ASPOSECPP_SHARED_API int GetBytes(const char_t* chars, int char_count, uint8_t* bytes, int byte_count);
 
    virtual ASPOSECPP_SHARED_API int GetCharCount(ArrayPtr<uint8_t> bytes, int index, int count);
    virtual ASPOSECPP_SHARED_API int GetCharCount(ArrayPtr<uint8_t> bytes);
    virtual ASPOSECPP_SHARED_API int GetCharCount(const uint8_t* bytes, int count);
 
    virtual ASPOSECPP_SHARED_API int GetChars(ArrayPtr<uint8_t> bytes, int byte_index, int byte_count, ArrayPtr<char_t> chars, int char_index);
    virtual ASPOSECPP_SHARED_API ArrayPtr<char_t> GetChars(ArrayPtr<uint8_t> bytes, int index, int count);
    virtual ASPOSECPP_SHARED_API ArrayPtr<char_t> GetChars(ArrayPtr<uint8_t> bytes);
    virtual ASPOSECPP_SHARED_API int GetChars(const uint8_t *bytes, int byte_count, char_t *chars, int char_count);
 
    virtual ASPOSECPP_SHARED_API DecoderPtr GetDecoder();
    virtual ASPOSECPP_SHARED_API EncoderPtr GetEncoder();
 
    virtual ASPOSECPP_SHARED_API String GetString(uint8_t* bytes, int byte_count);
    ASPOSECPP_SHARED_API String GetString(const ReadOnlySpan<uint8_t>& bytes);
    virtual ASPOSECPP_SHARED_API String GetString(ArrayPtr<uint8_t> bytes);
    virtual ASPOSECPP_SHARED_API String GetString(const System::Details::ArrayView<uint8_t> &bytes);
    template<std::size_t N>
    String GetString(System::Details::StackArray<uint8_t, N> &bytes)
    {
        return GetString(static_cast<System::Details::ArrayView<uint8_t>>(bytes));
    }
 
    virtual ASPOSECPP_SHARED_API String GetString(ArrayPtr<uint8_t> bytes, int index, int count);
    virtual ASPOSECPP_SHARED_API String GetString(const System::Details::ArrayView<uint8_t> &bytes, int index, int count);
    template<std::size_t N>
    String GetString(System::Details::StackArray<uint8_t, N> bytes, int index, int count)
    {
        return GetString(static_cast<System::Details::ArrayView<uint8_t>>(bytes), index, count);
    }
 
    virtual ASPOSECPP_SHARED_API int GetMaxByteCount(int char_count) = 0;
    virtual ASPOSECPP_SHARED_API int GetMaxCharCount(int byte_count) = 0;
 
    virtual ASPOSECPP_SHARED_API SharedPtr<Object> Clone();
    virtual ASPOSECPP_SHARED_API ArrayPtr<uint8_t> GetPreamble();
 
    static ASPOSECPP_SHARED_API EncodingPtr get_ASCII();
    static ASPOSECPP_SHARED_API EncodingPtr get_BigEndianUnicode();
    static ASPOSECPP_SHARED_API EncodingPtr get_Unicode();
    static ASPOSECPP_SHARED_API EncodingPtr get_UTF8();
    static ASPOSECPP_SHARED_API EncodingPtr get_UTF8Unmarked();
    // Gets the standard UTF-32 encoding object.
    static ASPOSECPP_SHARED_API EncodingPtr get_UTF32();
    static ASPOSECPP_SHARED_API EncodingPtr get_BigEndianUTF32();
    static ASPOSECPP_SHARED_API EncodingPtr get_UTF7();
    static EncodingPtr get_Latin1();
 
    static ASPOSECPP_SHARED_API EncodingPtr GetEncoding(const String& name);
    static ASPOSECPP_SHARED_API EncodingPtr GetEncoding(int codepage);
    static ASPOSECPP_SHARED_API EncodingPtr GetEncoding(int codepage, const EncoderFallbackPtr& encoder_fallback, const DecoderFallbackPtr& decoder_fallback);
    static ASPOSECPP_SHARED_API EncodingPtr GetEncoding(const String& name, const EncoderFallbackPtr& encoder_fallback, const DecoderFallbackPtr& decoder_fallback);
 
    static ASPOSECPP_SHARED_API EncodingPtr get_Default();
 
    static ASPOSECPP_SHARED_API ArrayPtr<EncodingInfoPtr> GetEncodings();
 
protected:
    const Details::EncodingInfoInternal* m_info;
    const int m_codepage;
    bool m_is_read_only = true;
 
    ASPOSECPP_SHARED_API Encoding();
    ASPOSECPP_SHARED_API Encoding(int codepage);
    ASPOSECPP_SHARED_API Encoding(int codepage, const EncoderFallbackPtr& encoder_fallback, const DecoderFallbackPtr& decoder_fallback);
 
    Encoding(const Details::EncodingInfoInternal* info);  
 
private:
    void SetDefaultFallbacks();
    void VerifyInternalData();
 
    DecoderFallbackPtr m_decoder_fallback;
    EncoderFallbackPtr m_encoder_fallback;
};
 
}} // System::Text