C++ DynArray::GetData方法代码示例

Reflect::ObjectPtr Helium::Cache::ReadCacheObjectFromBuffer( const DynArray< uint8_t > &_buffer )
{
    if (_buffer.GetSize() == 0)
    {
        Reflect::ObjectPtr null_object;
        return null_object;
    }

    return ReadCacheObjectFromBuffer(_buffer.GetData(), 0, _buffer.GetSize());
}

int main()
{
	DynArray <char> a;
	DynArray <char> b;

	char c = 'c';
	char d = 'd';
	char e = 'e';
	char f = 'f';
	char g = 'g';

	a.Push_Back(c);
	a.Push_Back(d);
	b.Push_Back(e);
	b.Push_Back(f);

	char result = a.At(0,result);

	//a = c,d 
	//b = e,f

	printf("At 0: %c\n", result);

	printf("A at 0,1: %c,%c\nB at 0,1: %c,%c\n", a[0], a[1], b[0], b[1]);

	a.Clear();

	printf("A clear... Size: %i\n", a.Size());

	a.Push_Back(c);
	a.Push_Back(d);

	a += b;

	printf("A after += : %c,%c,%c,%c\n", a[0], a[1], a[2], a[3]);

	printf("A[0] = %c, A[3] = %c\n", a[0], a[3]);

	printf("A.GetData = %p\n", a.GetData());

	printf("Capacity: %i, size = %i\n", a.Capacity(), a.Size());

	printf("Empty: ");

	if (a.Empty())
	{
		printf("yes\n");
	}
	else
	{
		printf("no\n");
	}

	a.Flip();

	printf("A fliped: %c,%c,%c,%c\n", a[0], a[1], a[2], a[3]);

	a.Push_Back(c);
	a.Push_Back(d);
	a.Push_Back(e);
	a.Push_Back(f);

	a.Insert(2, g);

	printf("A inserted g in 2: %c,%c,%c,%c,%c,%c,%c,%c,%c\n", a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);

	a.Erase(1);

	printf("A: %s\n", a.GetData());

	DynArray <int> test;
	int swaps = 0;
	int z;
	time_t t;

	test.Push_Back(5);
	test.Push_Back(8);
	test.Push_Back(3);
	test.Push_Back(1);
	test.Push_Back(4);
	test.Push_Back(2);

	printf("Int Array : %i,%i,%i,%i,%i,%i\n", test[0], test[1], test[2], test[3], test[4], test[5]);

	swaps = test.BubbleSort();

	printf("Int Array : %i,%i,%i,%i,%i,%i\nSwaps: %i\n", test[0], test[1], test[2], test[3], test[4], test[5], swaps);
	
	DynArray <int> test2;
	time(&t);
	srand(t);
	for (int i = 0; i <= 1000; i++)
	{
		z = rand();
		test2.Push_Back(z);
	}

	system("pause");
	return 0;
}

/// Helper function for compiling a shader for a specific profile.
///
/// @param[in]  pVariant             Shader variant for which we are compiling.
/// @param[in]  pPreprocessor        Platform preprocessor to use for compiling.
/// @param[in]  platformIndex        Platform index.
/// @param[in]  shaderProfileIndex   Index of the target shader profile.
/// @param[in]  shaderType           Type of shader to compile.
/// @param[in]  pShaderSourceData    Buffer in which the shader source code is stored.
/// @param[in]  shaderSourceSize     Size of the shader source buffer, in bytes.
/// @param[in]  rTokens              Array specifying preprocessor tokens to pass to the shader compiler.
/// @param[out] rCompiledCodeBuffer  Buffer in which the compiled code will be stored.
///
/// @return  True if compiling was successful, false if not.
bool ShaderVariantResourceHandler::CompileShader(
    ShaderVariant* pVariant,
    PlatformPreprocessor* pPreprocessor,
    size_t platformIndex,
    size_t shaderProfileIndex,
    RShader::EType shaderType,
    const void* pShaderSourceData,
    size_t shaderSourceSize,
    const DynArray< PlatformPreprocessor::ShaderToken >& rTokens,
    DynArray< uint8_t >& rCompiledCodeBuffer )
{
    HELIUM_ASSERT( pVariant );
    HELIUM_ASSERT( pPreprocessor );
    HELIUM_ASSERT( static_cast< size_t >( shaderType ) < static_cast< size_t >( RShader::TYPE_MAX ) );
    HELIUM_ASSERT( pShaderSourceData || shaderSourceSize == 0 );

    HELIUM_UNREF( platformIndex );  // Variable is used for logging only.

    rCompiledCodeBuffer.Resize( 0 );

#if HELIUM_ENABLE_TRACE
    DynArray< String > errorMessages;
#endif

    Path shaderFilePath;
    if ( !File::GetDataDirectory( shaderFilePath ) )
    {
        HELIUM_TRACE(
            TRACE_ERROR,
            TXT( "ShaderVariantResourceHandler: Failed to obtain data directory." ) );

        return false;
    }

    shaderFilePath += pVariant->GetPath().GetParent().ToFilePathString().GetData();

    bool bCompileResult = pPreprocessor->CompileShader(
                              shaderFilePath,
                              shaderProfileIndex,
                              shaderType,
                              pShaderSourceData,
                              shaderSourceSize,
                              rTokens.GetData(),
                              rTokens.GetSize(),
                              rCompiledCodeBuffer
#if HELIUM_ENABLE_TRACE
                              , &errorMessages
#else
                              , NULL
#endif
                          );
    if( !bCompileResult )
    {
        rCompiledCodeBuffer.Resize( 0 );

#if HELIUM_ENABLE_TRACE
        String tokenList;
#if HELIUM_UNICODE
        String convertedToken;
#endif
        size_t tokenCount = rTokens.GetSize();
        for( size_t tokenIndex = 0; tokenIndex < tokenCount; ++tokenIndex )
        {
            tokenList += TXT( ' ' );
#if HELIUM_UNICODE
            StringConverter< char, tchar_t >::Convert( convertedToken, rTokens[ tokenIndex ].name );
            tokenList += convertedToken;
#else
            tokenList += rTokens[ tokenIndex ].name;
#endif
        }

        size_t errorCount = errorMessages.GetSize();

        HELIUM_TRACE(
            TRACE_ERROR,
            ( TXT( "ShaderVariantResourceHandler: Failed to compile \"%s\" for platform %" ) TPRIuSZ
              TXT( ", profile %" ) TPRIuSZ TXT( "; %" ) TPRIuSZ TXT( " errors (tokens:%s):\n" ) ),
            *pVariant->GetPath().ToString(),
            platformIndex,
            shaderProfileIndex,
            errorCount,
            *tokenList );

        for( size_t errorIndex = 0; errorIndex < errorCount; ++errorIndex )
        {
            HELIUM_TRACE( TRACE_ERROR, TXT( "- %s\n" ), *errorMessages[ errorIndex ] );
//.........这里部分代码省略.........