//----------------------------------------------------------------//
STLString USLuaSerializer::SerializeToString () {
USMemStream memStream;
this->SerializeToStream( memStream );
memStream.Seek ( 0, SEEK_SET );
return memStream.ToString ( memStream.GetLength ());
}
//----------------------------------------------------------------//
bool USLuaState::Transform ( int idx, USStreamFormatter& formatter ) {
if ( !this->IsType ( idx, LUA_TSTRING )) return false;
size_t len;
cc8* buffer = lua_tolstring ( this->mState, idx, &len );
if ( !len ) return false;
USMemStream stream;
formatter.SetStream ( &stream );
formatter.WriteBytes ( buffer, len );
formatter.Flush ();
len = stream.GetLength ();
void* temp = malloc ( len );
stream.Seek ( 0, SEEK_SET );
stream.ReadBytes (( void* )temp, len );
lua_pushlstring ( this->mState, ( cc8* )temp, len );
free ( temp );
return true;
}
//----------------------------------------------------------------//
bool USData::Decode ( USCipher& cipher ) {
this->mMutex.Lock ();
USByteStream cryptStream;
cryptStream.SetBuffer ( this->mBytes, this->mBytes.Size ());
cryptStream.SetLength ( this->mBytes.Size ());
USCipherStream cipherStream;
cipherStream.OpenCipher ( cryptStream, cipher );
USMemStream plainStream;
plainStream.Pipe ( cipherStream );
cipherStream.CloseCipher ();
size_t len = plainStream.GetLength ();
this->mBytes.Init ( len );
plainStream.Seek ( 0, SEEK_SET );
plainStream.ReadBytes ( this->mBytes, len );
this->mMutex.Unlock ();
return true;
}
//----------------------------------------------------------------//
bool USLuaState::Encode ( int idx, USCipher& cipher ) {
if ( !this->IsType ( idx, LUA_TSTRING )) return false;
size_t len;
cc8* buffer = lua_tolstring ( this->mState, idx, &len );
if ( !len ) return false;
USCipherStream cipherStream;
USMemStream stream;
cipherStream.OpenCipher ( stream, cipher );
cipherStream.WriteBytes ( buffer, len );
cipherStream.CloseCipher ();
len = stream.GetLength ();
void* temp = malloc ( len );
stream.Seek ( 0, SEEK_SET );
stream.ReadBytes (( void* )temp, len );
lua_pushlstring ( this->mState, ( cc8* )temp, len );
free ( temp );
return true;
}
//----------------------------------------------------------------//
bool USLuaState::Decode ( int idx, USCipher& cipher ) {
if ( !this->IsType ( idx, LUA_TSTRING )) return false;
size_t len;
void* buffer = ( void* )lua_tolstring ( this->mState, idx, &len );
if ( !len ) return false;
USByteStream cryptStream;
cryptStream.SetBuffer ( buffer, len );
cryptStream.SetLength ( len );
USCipherStream cipherStream;
cipherStream.OpenCipher ( cryptStream, cipher );
USMemStream plainStream;
plainStream.Pipe ( cipherStream );
cipherStream.CloseCipher ();
len = plainStream.GetLength ();
buffer = malloc ( len );
plainStream.Seek ( 0, SEEK_SET );
plainStream.ReadBytes ( buffer, len );
lua_pushlstring ( this->mState, ( cc8* )buffer, len );
free ( buffer );
return true;
}
//----------------------------------------------------------------//
bool MOAILuaState::Encode ( int idx, USStreamWriter& writer ) {
if ( !this->IsType ( idx, LUA_TSTRING )) return false;
size_t len;
cc8* buffer = lua_tolstring ( this->mState, idx, &len );
if ( !len ) return false;
USMemStream stream;
writer.Open ( &stream );
writer.WriteBytes ( buffer, len );
writer.Close ();
len = stream.GetLength ();
void* temp = malloc ( len );
stream.Seek ( 0, SEEK_SET );
stream.ReadBytes (( void* )temp, len );
lua_pushlstring ( this->mState, ( cc8* )temp, len );
free ( temp );
return true;
}
//----------------------------------------------------------------//
void STLString::base_64_encode ( const void* buffer, u32 len ) {
( *this ) = "";
if ( !len ) return;
USMemStream memStream;
USBase64Writer base64;
base64.Open ( &memStream );
base64.WriteBytes ( buffer, len );
base64.Close ();
memStream.Seek ( 0, SEEK_SET );
( *this ) = memStream.ReadString ( memStream.GetLength ());
}
//----------------------------------------------------------------//
void STLString::base_64_encode ( const void* buffer, u32 len ) {
( *this ) = "";
if ( !len ) return;
USCipherStream cipherStream;
USMemStream memStream;
USBase64Cipher base64;
cipherStream.OpenCipher ( memStream, base64 );
cipherStream.WriteBytes ( buffer, len );
cipherStream.CloseCipher ();
memStream.Seek ( 0, SEEK_SET );
( *this ) = memStream.ToString ( memStream.GetLength ());
}
//----------------------------------------------------------------//
bool USData::Transform ( USStreamFormatter& formatter ) {
this->mMutex.Lock ();
USMemStream stream;
formatter.SetStream ( &stream );
formatter.WriteBytes ( this->mBytes, this->mBytes.Size ());
formatter.Flush ();
size_t len = stream.GetLength ();
this->mBytes.Init ( len );
stream.Seek ( 0, SEEK_SET );
stream.ReadBytes ( this->mBytes, len );
this->mMutex.Unlock ();
return true;
}
//----------------------------------------------------------------//
bool USData::Encode ( USStreamWriter& writer ) {
this->mMutex.Lock ();
USMemStream stream;
writer.Open ( &stream );
writer.WriteBytes ( this->mBytes, this->mBytes.Size ());
writer.Close ();
size_t len = stream.GetLength ();
this->mBytes.Init ( len );
stream.Seek ( 0, SEEK_SET );
stream.ReadBytes ( this->mBytes, len );
this->mMutex.Unlock ();
return true;
}
//----------------------------------------------------------------//
bool USData::Encode ( USCipher& cipher ) {
this->mMutex.Lock ();
USCipherStream cipherStream;
USMemStream stream;
cipherStream.OpenCipher ( stream, cipher );
cipherStream.WriteBytes ( this->mBytes, this->mBytes.Size ());
cipherStream.CloseCipher ();
size_t len = stream.GetLength ();
this->mBytes.Init ( len );
stream.Seek ( 0, SEEK_SET );
stream.ReadBytes ( this->mBytes, len );
this->mMutex.Unlock ();
return true;
}
//----------------------------------------------------------------//
bool USData::Decode ( USStreamReader& reader ) {
this->mMutex.Lock ();
USByteStream cryptStream;
cryptStream.SetBuffer ( this->mBytes, this->mBytes.Size ());
cryptStream.SetLength ( this->mBytes.Size ());
USMemStream plainStream;
reader.Open ( &cryptStream );
plainStream.WriteStream ( reader );
reader.Close ();
size_t len = plainStream.GetLength ();
this->mBytes.Init ( len );
plainStream.Seek ( 0, SEEK_SET );
plainStream.ReadBytes ( this->mBytes, len );
this->mMutex.Unlock ();
return true;
}
/** @name toCppHeader
@text Convert data to CPP header file.
@overload
@in string data The string data to encode
@in string name
@opt number columns Default value is 12
@out string output
@overload
@in MOAIDataBuffer data The data buffer to encode
@in string name
@opt number columns Default value is 12
@out string output
*/
int MOAIDataBuffer::_toCppHeader ( lua_State* L ) {
MOAILuaState state ( L );
cc8* name = state.GetValue < cc8* >( 2, "" );
u32 columns = state.GetValue < u32 >( 3, 12 );
if ( !strlen ( name )) return 0;
USMemStream memStream;
if ( state.IsType ( 1, LUA_TSTRING )) {
size_t size;
const void* bytes = lua_tolstring ( state, 1, &size );
USHexDump::DumpAsCPPHeader ( memStream, name, bytes, size, columns );
}
MOAIDataBuffer* dataBuffer = state.GetLuaObject < MOAIDataBuffer >( 1, true );
if ( dataBuffer ) {
size_t size;
void* bytes;
dataBuffer->Lock ( &bytes, &size );
USHexDump::DumpAsCPPHeader ( memStream, name, bytes, size, columns );
}
if ( memStream.GetLength ()) {
memStream.Seek ( 0, SEEK_SET );
STLString result = memStream.ReadString ( memStream.GetLength ());
lua_pushstring ( state, result );
return 1;
}
return 0;
}
//----------------------------------------------------------------//
STLString USStream::ReadToken ( cc8* delimiters ) {
STLString str;
if ( this->IsAtEnd ()) return str;
char stackBuffer [ LOCAL_BUFFER ];
USMemStream memStream;
memStream.SetChunkSize ( LOCAL_BUFFER );
memStream.SetGuestBuffer ( stackBuffer, LOCAL_BUFFER );
char c = 0;
size_t size = 0;
do {
c = this->Read < char >( 0 );
if ( delimiters && c ) {
bool isDelimiter = false;
for ( size_t i = 0; delimiters [ i ]; ++i ) {
if ( delimiters [ i ] == c ) {
isDelimiter = true;
break;
}
}
if ( isDelimiter ) {
if ( size ) {
c = 0;
}
else {
continue;
}
}
}
memStream.Write < char >( c );
size++;
}
while ( c );
if ( size ) {
str.reserve ( size + 1 );
memStream.Seek ( 0, SEEK_SET );
while ( size > 0 ) {
char buffer [ LOCAL_BUFFER ];
size_t readSize = size;
if ( LOCAL_BUFFER < readSize ) {
readSize = LOCAL_BUFFER;
}
memStream.ReadBytes ( buffer, readSize );
str.append ( buffer, readSize );
size -= readSize;
}
}
return str;
}
