Input stream wrapper with dynamically bound encoding and automatic encoding detection. More...

#include <encodedstream.h>

Collaboration diagram for AutoUTFInputStream< CharType, InputByteStream >:

Public Types
typedef CharType	Ch

Public Member Functions
	AutoUTFInputStream (InputByteStream &is, UTFType type=kUTF8)
	Constructor. More...

UTFType	GetType () const

bool	HasBOM () const

Ch	Peek () const

Ch	Take ()

size_t	Tell () const

void	Put (Ch)

void	Flush ()

Ch *	PutBegin ()

size_t	PutEnd (Ch *)

Private Types
typedef Ch(*	TakeFunc) (InputByteStream &is)

Private Member Functions
	RAPIDJSON_STATIC_ASSERT (sizeof(typename InputByteStream::Ch)==1)

	AutoUTFInputStream (const AutoUTFInputStream &)

AutoUTFInputStream &	operator= (const AutoUTFInputStream &)

void	DetectType ()

Private Attributes
InputByteStream *	is_

UTFType	type_

Ch	current_

TakeFunc	takeFunc_

bool	hasBOM_

Detailed Description

template<typename CharType, typename InputByteStream>
class AutoUTFInputStream< CharType, InputByteStream >

Input stream wrapper with dynamically bound encoding and automatic encoding detection.

Template Parameters

CharType	Type of character for reading.
InputByteStream	type of input byte stream to be wrapped.

Definition at line 135 of file encodedstream.h.

Member Typedef Documentation

◆ Ch

typedef CharType Ch

Definition at line 138 of file encodedstream.h.

◆ TakeFunc

typedef Ch(* TakeFunc) (InputByteStream &is)

private

Definition at line 219 of file encodedstream.h.

Constructor & Destructor Documentation

◆ AutoUTFInputStream() [1/2]

AutoUTFInputStream	(	InputByteStream &	is,
		UTFType	type = `kUTF8`
	)

inline

Constructor.

Parameters

is	input stream to be wrapped.
type	UTF encoding type if it is not detected from the stream.

Definition at line 145 of file encodedstream.h.

                                                                   : is_(&is), type_(type), hasBOM_(false) {
         RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);        
         DetectType();
         static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };
         takeFunc_ = f[type_];
         current_ = takeFunc_(*is_);
     }

Here is the call graph for this function:

◆ AutoUTFInputStream() [2/2]

AutoUTFInputStream ( const AutoUTFInputStream< CharType, InputByteStream > & )

private

Member Function Documentation

◆ DetectType()

void DetectType ( )

inlineprivate

Definition at line 171 of file encodedstream.h.

                       {
         // BOM (Byte Order Mark):
         // 00 00 FE FF  UTF-32BE
         // FF FE 00 00  UTF-32LE
         // FE FF        UTF-16BE
         // FF FE        UTF-16LE
         // EF BB BF     UTF-8
 
         const unsigned char* c = reinterpret_cast<const unsigned char *>(is_->Peek4());
         if (!c)
             return;
 
         unsigned bom = static_cast<unsigned>(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24));
         hasBOM_ = false;
         if (bom == 0xFFFE0000)                  { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
         else if (bom == 0x0000FEFF)             { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
         else if ((bom & 0xFFFF) == 0xFFFE)      { type_ = kUTF16BE; hasBOM_ = true; is_->Take(); is_->Take();                           }
         else if ((bom & 0xFFFF) == 0xFEFF)      { type_ = kUTF16LE; hasBOM_ = true; is_->Take(); is_->Take();                           }
         else if ((bom & 0xFFFFFF) == 0xBFBBEF)  { type_ = kUTF8;    hasBOM_ = true; is_->Take(); is_->Take(); is_->Take();              }
 
         // RFC 4627: Section 3
         // "Since the first two characters of a JSON text will always be ASCII
         // characters [RFC0020], it is possible to determine whether an octet
         // stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
         // at the pattern of nulls in the first four octets."
         // 00 00 00 xx  UTF-32BE
         // 00 xx 00 xx  UTF-16BE
         // xx 00 00 00  UTF-32LE
         // xx 00 xx 00  UTF-16LE
         // xx xx xx xx  UTF-8
 
         if (!hasBOM_) {
             int pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
             switch (pattern) {
             case 0x08: type_ = kUTF32BE; break;
             case 0x0A: type_ = kUTF16BE; break;
             case 0x01: type_ = kUTF32LE; break;
             case 0x05: type_ = kUTF16LE; break;
             case 0x0F: type_ = kUTF8;    break;
             default: break; // Use type defined by user.
             }
         }
 
         // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
         if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
         if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
     }