// Copyright © 2011 CCP ehf.

#include "StdAfx.h"

#include "BlueFileStream.h"

#include "BlueMemStream.h"

#include "BlueResManBackgroundCall.h"

#include <BlueStatistics.h>

#include "IBlueOS.h"

#if CCP_STACKLESS

#include "BluePyCpp.h"

#define PY_ALLOWTHREADS() Ccp::PyAllowThreads allowThreads( true )

#else

#define PY_ALLOWTHREADS()

#endif

#include "IBlueThreadMonitor.h"

CCP_STATS_DECLARE( fileStreamBytesRead, "Blue/BlueFileStream/BytesRead", false, CST_COUNTER_HIGH, "Number of bytes read from local files using BlueFileStream" );

CCP_STATS_DECLARE( fileStreamBytesWritten, "Blue/BlueFileStream/BytesWritten", false, CST_COUNTER_HIGH, "Number of bytes written from local files using BlueFileStream" );

namespace

{

const int INVALID_FILE = -1;

#if CCP_STACKLESS

class BackgroundReader : public IBlueResManBackgroundCall

{

public:

BackgroundReader( BlueFileStream* stream, const wchar_t* filename ) :

m_stream( stream ),

m_filename( filename )

{

}

virtual ~BackgroundReader() = default;

virtual void Perform()

{

m_result = m_stream->ReadEntireFile( m_filename.c_str(), m_contents );

}

Be::Result<std::string> GetResult()

{

return m_result;

}

const std::string& GetContents()

{

return m_contents;

}

private:

std::wstring m_filename;

BlueFileStreamPtr m_stream;

std::string m_contents;

Be::Result<std::string> m_result;

};

#endif

}

BlueFileStream::BlueFileStream() :

m_fileDescriptor( INVALID_FILE ),

m_data( nullptr ),

m_dataSize( 0 )

{

}

BlueFileStream::~BlueFileStream()

{

if( m_data )

{

UnlockData();

}

Close();

}

bool BlueFileStream::Open( const wchar_t* filename, CcpOpenMode mode, CcpShareMode shareMode )

{

PY_ALLOWTHREADS();

ScopedThreadStatus threadStatus( IBlueThreadMonitor::BTS_LOADING );

m_fileDescriptor = CcpOpenFile( filename, mode, shareMode );

if( m_fileDescriptor == INVALID_FILE )

{

return false;

}

return true;

}

bool BlueFileStream::Create( const wchar_t* filename )

{

PY_ALLOWTHREADS();

m_fileDescriptor = CcpCreateFile( filename, CCP_SM_NOSHARING );

if( m_fileDescriptor == INVALID_FILE )

{

return false;

}

return true;

}

void BlueFileStream::Close()

{

if( m_fileDescriptor != INVALID_FILE )

{

CcpCloseFile( m_fileDescriptor );

}

m_fileDescriptor = INVALID_FILE;

}

ptrdiff_t BlueFileStream::Read( void* dest, ptrdiff_t count )

{

CCP_STATS_ZONE( __FUNCTION__ );

PY_ALLOWTHREADS();

ScopedThreadStatus threadStatus( IBlueThreadMonitor::BTS_LOADING );

if( count == -1 )

{

// Count of -1 is taken to mean the remainder of the file

count = INT_MAX;

}

ssize_t bytesRead;

bytesRead = CcpReadFromFile( m_fileDescriptor, dest, count );

if( bytesRead == -1 )

{

BeOS->SetError(BE32, Clsid(), "Couldn't Read");

return -1;

}

CCP_STATS_ADD( fileStreamBytesRead, bytesRead );

return bytesRead;

}

ptrdiff_t BlueFileStream::Write( const void* source, size_t count )

{

CCP_STATS_ZONE( __FUNCTION__ );

if( m_fileDescriptor == INVALID_FILE )

{

BeOS->SetError(BE32, Clsid(), "Couldn't Write - file is not open");

return -1;

}

PY_ALLOWTHREADS();

ssize_t wrote;

wrote = CcpWriteToFile( m_fileDescriptor, source, count );

if( wrote == -1 )

{

BeOS->SetError(BE32, Clsid(), "Couldn't Write");

return -1;

}

CCP_STATS_ADD( fileStreamBytesWritten, wrote );

return wrote;

}

ptrdiff_t BlueFileStream::Seek( ptrdiff_t distance, SeekOrigin method )

{

CCP_STATS_ZONE( __FUNCTION__ );

if( CcpLseek( m_fileDescriptor, (long)distance, method ) )

{

return false;

}

return true;

}

ptrdiff_t BlueFileStream::GetPosition()

{

long pos = CcpTell( m_fileDescriptor );

return pos;

}

ptrdiff_t BlueFileStream::GetSize()

{

CCP_STATS_ZONE( __FUNCTION__ );

if( m_fileDescriptor == INVALID_FILE )

{

return -1;

}

long curPos = CcpTell( m_fileDescriptor );

if( CcpLseek( m_fileDescriptor, 0, SEEK_END ) == -1 )

{

BeOS->SetError( BEDEF, Clsid(), "Couldn't get file size" );

return -1;

}

long size = CcpTell( m_fileDescriptor );

if( CcpLseek( m_fileDescriptor, curPos, SEEK_SET ) == -1 )

{

BeOS->SetError( BEDEF, Clsid(), "Couldn't get file size" );

return -1;

}

return size;

}

bool BlueFileStream::LockData( void** data, size_t size )

{

CCP_STATS_ZONE( __FUNCTION__ );

if( m_data )

{

return false;

}

m_dataSize = GetSize();

if( !m_dataSize )

{

return false;

}

m_data = CCP_MALLOC( "BlueFileStream/m_data", m_dataSize );

if( !m_data )

{

return false;

}

if( !Seek( 0, SO_BEGIN ) )

{

return false;

}

if( Read( m_data, m_dataSize ) != m_dataSize )

{

m_dataSize = 0;

CCP_FREE( m_data );

m_data = NULL;

return false;

}

*data = m_data;

return true;

}

bool BlueFileStream::UnlockData()

{

CCP_STATS_ZONE( __FUNCTION__ );

if( !m_data )

{

return false;

}

m_dataSize = 0;

CCP_FREE( m_data );

m_data = NULL;

return true;

}

Be::Result<std::string> BlueFileStream::ReadEntireFile( const wchar_t* filename, std::string& contents )

{

CCP_STATS_ZONE( __FUNCTION__ );

PY_ALLOWTHREADS();

m_fileDescriptor = CcpOpenFile( filename, CCP_OM_READONLY, CCP_SM_RWSHARING );

if( m_fileDescriptor == INVALID_FILE )

{

return Be::Result<std::string>( "Open failed" );

}

ssize_t size = GetSize();

if( size < 0 )

{

return Be::Result<std::string>( "GetSize failed" );

}

contents.resize( size );

ssize_t bytesRead = Read( &contents[0], size );

Close();

if( bytesRead < size )

{

return Be::Result<std::string>( "Read failed" );

}

return Be::Result<std::string>();

}

Be::Result<std::string> BlueFileStream::ReadEntireFileWithYield( const wchar_t* filename, std::string& contents )

{

CCP_STATS_ZONE( __FUNCTION__ );

#if CCP_STACKLESS

BackgroundReader* reader = CCP_NEW( "ReadEntireFileWithYield/reader" )

BackgroundReader( this, filename );

Be::Result<std::string> result;

if( BlueResManBackgroundCall::Issue( reader ) )

{

result = reader->GetResult();

if( BeIsSuccess( result ) )

{

contents = reader->GetContents();

}

}

else

{

result = Be::Result<std::string>( "Tasklet killed" );

}

CCP_DELETE reader;

return result;

#else

return ReadEntireFile( filename, contents );

#endif

}