// Save (SLNDependency)
//------------------------------------------------------------------------------
/*static*/ void SLNDependency::Save( IOStream & stream, const Array< SLNDependency > & slnDeps )
{
const uint32_t num = (uint32_t)slnDeps.GetSize();
stream.Write( num );
for ( const SLNDependency & deps : slnDeps )
{
stream.Write( deps.m_Projects );
stream.Write( deps.m_Dependencies );
}
}
// Serialize
//------------------------------------------------------------------------------
void Node::Serialize( IOStream & stream ) const
{
// Deps
NODE_SAVE_DEPS( m_PreBuildDependencies );
NODE_SAVE_DEPS( m_StaticDependencies );
NODE_SAVE_DEPS( m_DynamicDependencies );
// Properties
const ReflectionInfo * const ri = GetReflectionInfoV();
const ReflectionIter end = ri->End();
for ( ReflectionIter it = ri->Begin(); it != end; ++it )
{
const ReflectedProperty & property = *it;
const PropertyType pt = property.GetType();
switch ( pt )
{
case PT_ASTRING:
{
if ( property.IsArray() )
{
const Array< AString > * arrayOfStrings( nullptr );
property.GetProperty( this, arrayOfStrings );
VERIFY( stream.Write( *arrayOfStrings ) );
}
else
{
AString string; // TODO:C remove this copy
property.GetProperty( this, &string );
VERIFY( stream.Write( string ) );
}
break;
}
case PT_BOOL:
{
bool b( false );
property.GetProperty( this, &b );
VERIFY( stream.Write( b ) );
break;
}
case PT_UINT32:
{
uint32_t u32( 0 );
property.GetProperty( this, &u32 );
VERIFY( stream.Write( u32 ) );
break;
}
default:
{
ASSERT( false ); // Unsupported type
break;
}
}
}
}
// VSProjectFileType::Save
//------------------------------------------------------------------------------
/*static*/ void VSProjectFileType::Save( IOStream & stream, const Array< VSProjectFileType > & fileTypes )
{
uint32_t numFileTypes = (uint32_t)fileTypes.GetSize();
stream.Write( numFileTypes );
for ( uint32_t i=0; i<numFileTypes; ++i )
{
const VSProjectFileType & ft = fileTypes[ i ];
stream.Write( ft.m_FileType );
stream.Write( ft.m_Pattern );
}
}
// SLNSolutionFolder::Save
//------------------------------------------------------------------------------
/*static*/ void SLNSolutionFolder::Save( IOStream & stream, const Array< SLNSolutionFolder > & solutionFolders )
{
uint32_t numSolutionFolders = (uint32_t)solutionFolders.GetSize();
stream.Write( numSolutionFolders );
for ( uint32_t i=0; i<numSolutionFolders; ++i )
{
const SLNSolutionFolder & sln = solutionFolders[ i ];
stream.Write( sln.m_Path );
stream.Write( sln.m_ProjectNames );
}
}
// SaveNode
//------------------------------------------------------------------------------
void Node::SaveNode( IOStream & fileStream, const Node * node ) const
{
// for null pointer, write an empty string
if ( node == nullptr )
{
fileStream.Write( AString::GetEmpty() );
}
else
{
// for valid nodes, write the node name
fileStream.Write( node->GetName() );
}
}
// Serialize
//------------------------------------------------------------------------------
void Job::Serialize( IOStream & stream )
{
PROFILE_FUNCTION
// write jobid
stream.Write( m_JobId );
stream.Write( m_Node->GetName() );
// write properties of node
Node::SaveRemote( stream, m_Node );
stream.Write( IsDataCompressed() );
stream.Write( m_DataSize );
stream.Write( m_Data, m_DataSize );
}
static int XMLCALL _writeCallback(void *user_data, char const *buffer, int len) {
IOStream *stream = (IOStream*)user_data;
uint32 to_write = (uint32)(len&INT_MAX);
uint32 written = stream->Write(buffer, to_write);
if (written != to_write && !(*stream))
return -1;
else
return (int)written;
}
//
//------------------------------------------------------------------------------
/*static*/ void Node::Save( IOStream & stream, const Node * node )
{
ASSERT( node );
// save type
uint32_t nodeType = (uint32_t)node->GetType();
stream.Write( nodeType );
// save stamp (but not for file nodes)
if ( nodeType != Node::FILE_NODE )
{
uint64_t stamp = node->GetStamp();
stream.Write( stamp );
}
// save contents
node->Save( stream );
}
// Save
//------------------------------------------------------------------------------
void Dependencies::Save( IOStream & stream ) const
{
size_t numDeps = GetSize();
stream.Write( (uint32_t)numDeps );
Iter end = End();
for ( Iter it = Begin(); it != end; ++it )
{
const Dependency & dep = *it;
// Nodes are saved by index to simplify deserialization
uint32_t index = dep.GetNode()->GetIndex();
stream.Write( index );
// Save weak flag
bool isWeak = dep.IsWeak();
stream.Write( isWeak );
}
}
// SaveRemote
//------------------------------------------------------------------------------
/*static*/ void Node::SaveRemote( IOStream & stream, const Node * node )
{
ASSERT( node );
// only 1 type of node is ever serialized over the network
ASSERT( node->GetType() == Node::OBJECT_NODE );
// save type
uint32_t nodeType = (uint32_t)node->GetType();
stream.Write( nodeType );
// save contents
node->SaveRemote( stream );
}
void HTTPRequest::ReadContent(IOStream& rStreamToWriteTo)
{
Seek(0, SeekType_Absolute);
CopyStreamTo(rStreamToWriteTo);
IOStream::pos_type bytesCopied = GetSize();
while (bytesCopied < mContentLength)
{
char buffer[1024];
IOStream::pos_type bytesToCopy = sizeof(buffer);
if (bytesToCopy > mContentLength - bytesCopied)
{
bytesToCopy = mContentLength - bytesCopied;
}
bytesToCopy = mpStreamToReadFrom->Read(buffer, bytesToCopy);
rStreamToWriteTo.Write(buffer, bytesToCopy);
bytesCopied += bytesToCopy;
}
}
// Serialize
//------------------------------------------------------------------------------
void ToolManifest::Serialize( IOStream & ms ) const
{
ms.Write( m_ToolId );
const uint32_t numItems( (uint32_t)m_Files.GetSize() );
ms.Write( numItems );
const size_t numFiles( m_Files.GetSize() );
for ( size_t i=0; i<numFiles; ++i )
{
const File & f = m_Files[ i ];
ms.Write( f.m_Name );
ms.Write( f.m_TimeStamp );
ms.Write( f.m_Hash );
ms.Write( f.m_ContentSize );
}
}
// VSProjectConfig::Save
//------------------------------------------------------------------------------
/*static*/ void VSProjectConfig::Save( IOStream & stream, const Array< VSProjectConfig > & configs )
{
uint32_t numConfigs = (uint32_t)configs.GetSize();
stream.Write( numConfigs );
for ( uint32_t i=0; i<numConfigs; ++i )
{
const VSProjectConfig & cfg = configs[ i ];
stream.Write( cfg.m_SolutionPlatform );
stream.Write( cfg.m_SolutionConfig );
stream.Write( cfg.m_Platform );
stream.Write( cfg.m_Config );
Node::SaveNode( stream, cfg.m_Target );
stream.Write( cfg.m_BuildCommand );
stream.Write( cfg.m_RebuildCommand );
stream.Write( cfg.m_CleanCommand );
stream.Write( cfg.m_Output );
stream.Write( cfg.m_PreprocessorDefinitions );
stream.Write( cfg.m_IncludeSearchPath );
stream.Write( cfg.m_ForcedIncludes );
stream.Write( cfg.m_AssemblySearchPath );
stream.Write( cfg.m_ForcedUsingAssemblies );
stream.Write( cfg.m_AdditionalOptions );
stream.Write( cfg.m_OutputDirectory );
stream.Write( cfg.m_IntermediateDirectory );
stream.Write( cfg.m_LayoutDir );
stream.Write( cfg.m_LayoutExtensionFilter );
stream.Write( cfg.m_Xbox360DebuggerCommand );
stream.Write( cfg.m_DebuggerFlavor );
stream.Write( cfg.m_AumidOverride );
stream.Write( cfg.m_PlatformToolset );
stream.Write( cfg.m_DeploymentType );
stream.Write( cfg.m_DeploymentFiles );
stream.Write( cfg.m_LocalDebuggerCommandArguments );
stream.Write( cfg.m_LocalDebuggerWorkingDirectory );
stream.Write( cfg.m_LocalDebuggerCommand );
stream.Write( cfg.m_LocalDebuggerEnvironment );
}
}
// --------------------------------------------------------------------------
//
// Function
// Name: HTTPRequest::Send(IOStream &, int)
// Purpose: Write the request to an IOStream using HTTP.
// Created: 03/01/09
//
// --------------------------------------------------------------------------
bool HTTPRequest::Send(IOStream &rStream, int Timeout, bool ExpectContinue)
{
switch (mMethod)
{
case Method_UNINITIALISED:
THROW_EXCEPTION(HTTPException, RequestNotInitialised); break;
case Method_UNKNOWN:
THROW_EXCEPTION(HTTPException, BadRequest); break;
case Method_GET:
rStream.Write("GET"); break;
case Method_HEAD:
rStream.Write("HEAD"); break;
case Method_POST:
rStream.Write("POST"); break;
case Method_PUT:
rStream.Write("PUT"); break;
}
rStream.Write(" ");
rStream.Write(mRequestURI.c_str());
rStream.Write(" ");
switch (mHTTPVersion)
{
case HTTPVersion_0_9: rStream.Write("HTTP/0.9"); break;
case HTTPVersion_1_0: rStream.Write("HTTP/1.0"); break;
case HTTPVersion_1_1: rStream.Write("HTTP/1.1"); break;
default:
THROW_EXCEPTION_MESSAGE(HTTPException, NotImplemented,
"Unsupported HTTP version: " << mHTTPVersion);
}
rStream.Write("\n");
std::ostringstream oss;
if (mContentLength != -1)
{
oss << "Content-Length: " << mContentLength << "\n";
}
if (mContentType != "")
{
oss << "Content-Type: " << mContentType << "\n";
}
if (mHostName != "")
{
if (mHostPort != 80)
{
oss << "Host: " << mHostName << ":" << mHostPort <<
"\n";
}
else
{
oss << "Host: " << mHostName << "\n";
}
}
if (mpCookies)
{
THROW_EXCEPTION_MESSAGE(HTTPException, NotImplemented,
"Cookie support not implemented yet");
}
if (mClientKeepAliveRequested)
{
oss << "Connection: keep-alive\n";
}
else
{
oss << "Connection: close\n";
}
for (std::vector<Header>::iterator i = mExtraHeaders.begin();
i != mExtraHeaders.end(); i++)
{
oss << i->first << ": " << i->second << "\n";
}
if (ExpectContinue)
{
oss << "Expect: 100-continue\n";
}
rStream.Write(oss.str().c_str());
rStream.Write("\n");
return true;
}
