blib.c

Go to the documentation of this file.

#include "ctl/ctldef.h"
#include "ctl/blib.h"

#ifndef CTL_UNIT

/*
 * Functions to access a library
 */

uint32 BLIB_Size( const BLIB *lib )
{
    assert( BLIB_VALID( lib ) );
    return BLIB_SIZE( lib );
}

uint32 BLIB_Count( const BLIB *lib )
{
    assert( BLIB_VALID( lib ) );
    return BLIB_COUNT( lib );
}

uint32 BLIB_User( const BLIB *lib )
{
    /*  */
    assert( BLIB_VALID( lib ) );
    return BLIB_USER( lib );
}

bool BLIB_Valid( const BLIB *lib, uint32 libSize )
{

    /* Intended for verification of file or resource load. */
    if( !BLIB_VALID( lib ) )
        return false;

    /* Does first index measure out correctly according to element count? */
    if( lib->offsets[0] != sizeof(BLIB) + (lib->count * sizeof(uint32)) )
        return false;
    
    if( libSize )
    {
        uint32 curr;

        /* If we have a size, check it against our calculated size */
        if( BLIB_SIZE( lib ) != libSize )
            return false;

        /* Walk through members to see if they overlap */
        for( curr = lib->count; curr; --curr )
        {
            if( lib->offsets[curr] < lib->offsets[curr - 1] )
            {
                return false;
            }
        }
    }
    return true;
}

uint32 BLIB_ElementSize( const BLIB *lib, int index )
{
    assert( BLIB_VALID( lib ) );
    assert( BLIB_INDEX_VALID( lib, index ) );
    return BLIB_ELEMENT_SIZE( lib, index );
}

const void *BLIB_ElementPointer( const BLIB *lib, int index )
{
    /* Return a pointer to an element in a library */
    assert( BLIB_VALID( lib ) );
    assert( BLIB_INDEX_VALID( lib, index ) );
    return BLIB_ELEMENT_PTR( lib, index );
}

uint32 BLIB_ElementCopyData( const BLIB *lib, int index, void *data, uint32 dataSize )
{
    uint32 dwSize;
    const void *pElement;
    assert( BLIB_VALID( lib ) );
    assert( BLIB_INDEX_VALID( lib, index ) );
    assert( dataSize );
    assertconst( data, dataSize );
    dwSize = min( BLIB_ELEMENT_SIZE( lib, index ), dataSize );
    pElement = BLIB_ELEMENT_PTR( lib, index );
    memcpy( data, pElement, dwSize );
    return dwSize;
}

/*
 * Functions to change a mutable library
 */

BLIB *BLIB_Create( uint32 userID )
{
    /*  */
    BLIB *libRet = malloc( sizeof(BLIB) );
    if( libRet )
    {
        (*((uint32 *)(libRet->magic)) = *((uint32 *)BLIB_MAGIC));
        libRet->userID        = userID;
        libRet->count  = 0;
        libRet->offsets[0]     = sizeof(BLIB);
    }
    return libRet;
}

BLIB *BLIB_Copy( const BLIB *lib )
{
    uint32 size;
    BLIB *pRet;
    assert( BLIB_VALID( lib ) );
    size = BLIB_SIZE( lib );
    pRet = (BLIB *)malloc(size);
    if( pRet )
        memcpy( pRet, lib, size );
    return pRet;
}

void BLIB_Destroy( BLIB **lib )
{
    assert( lib );
    if( BLIB_VALID( *lib ) )
    {
        free( *lib );
        *lib = NULL;
    }
}

bool BLIB_ElementAdd( BLIB **lib, const void *data, uint32 dataSize )
{
    assert( lib );
    assert( BLIB_VALID( *lib ) );
    assert( data );
    assertconst( data, dataSize );
    return BLIB_ElementInsert( lib, BLIB_COUNT( *lib ), data, dataSize );
}

bool BLIB_ElementReplace( BLIB **lib, int index, const void *data, uint32 dataSize )
{
    assert( lib );
    assert( BLIB_VALID( *lib ) );
    assert( BLIB_INDEX_VALID( *lib, index ) );
    assert( data );
    assert( dataSize > 0 );
    assertconst( data, dataSize );

    {
        int32 lDiff      = dataSize - BLIB_ELEMENT_SIZE( *lib, index );
        /* Though it's tempting not to reallocate the return if it's smaller, that could allow memory to slowly  */
        /* bleed as Libraries change items. */
        if( lDiff )
        {
            /* Size of output will change */
            int curr;
            uint32 dwSizeIn  = BLIB_SIZE(*lib);
            BLIB *libIn      = *lib;
            uint32 dwSizeOut = dwSizeIn + lDiff;
            BLIB *libOut     = lDiff ? malloc( dwSizeOut ) : libIn;
            if( !libOut )
                return false;
            /* Copy original data */
            *libOut = *libIn;
            dwSizeOut = sizeof( BLIB ) + (libOut->count * sizeof(uint32) );

            /* Copy over any unaffected items */
            for( curr = 0; curr < index; ++curr )
            {
                libOut->offsets[curr] = dwSizeOut;
                dwSizeOut += BLIB_ELEMENT_SIZE(libIn, curr);
                memcpy( BLIB_ELEMENT_PTR(libOut, curr), BLIB_ELEMENT_PTR(libIn, curr), BLIB_ELEMENT_SIZE(libIn, curr) );
            }

            /* Copy the new data */
            libOut->offsets[index] = dwSizeOut;
            dwSizeOut += dataSize;
            memcpy( BLIB_ELEMENT_PTR(libOut, index), data, dataSize );

            /* Copy over any unaffected items */
            for( curr = index + 1; curr < (int)libIn->count; ++curr )
            {
                libOut->offsets[curr] = dwSizeOut;
                dwSizeOut += BLIB_ELEMENT_SIZE(libIn, curr);
                memcpy( BLIB_ELEMENT_PTR(libOut, curr), BLIB_ELEMENT_PTR(libIn, curr), BLIB_ELEMENT_SIZE(libIn, curr) );
            }
            libOut->offsets[curr] = dwSizeOut;

            /* Destroy the input library */
            BLIB_Destroy( &libIn );

            /* Return the output library */
            *lib = libOut;
        }
        else
        {
            /* Size unchanged, just copy the data */
            memcpy( BLIB_ELEMENT_PTR(*lib,index), data, dataSize );
        }
    }

    /* Success */
    return true;
}

bool BLIB_ElementInsert( BLIB **lib, int index, const void *data, uint32 dataSize )
{
    assert( lib );
    assert( BLIB_VALID( *lib ) );
    assert( index >= 0 && index <= (int)BLIB_COUNT( *lib ) );
    assert( data );
    assertconst( data, dataSize );

    {
        int curr;
        uint32 dwSizeIn  = BLIB_SIZE(*lib);
        BLIB *libIn      = *lib;
        uint32 dwSizeOut = dwSizeIn + dataSize + sizeof(uint32);
        BLIB *libOut     = malloc( dwSizeOut );
        if( !libOut )
            return false;

        /* Copy original data */
        *libOut = *libIn;
        libOut->count++;
        dwSizeOut = sizeof( BLIB ) + (libOut->count * sizeof(uint32) );

        /* Copy over any unaffected items */
        for( curr = 0; curr < index; ++curr )
        {
            libOut->offsets[curr] = dwSizeOut;
            dwSizeOut += BLIB_ELEMENT_SIZE(libIn, curr);
            memcpy( BLIB_ELEMENT_PTR(libOut, curr), BLIB_ELEMENT_PTR(libIn, curr), BLIB_ELEMENT_SIZE(libIn, curr) );
        }

        /* Copy the new data */
        libOut->offsets[index] = dwSizeOut;
        dwSizeOut += dataSize;
        memcpy( BLIB_ELEMENT_PTR(libOut, index), data, dataSize );
        
        /* Copy over any unaffected items */
        for( curr = index; curr < (int)libIn->count; ++curr )
        {
            libOut->offsets[curr+1] = dwSizeOut;
            dwSizeOut += BLIB_ELEMENT_SIZE(libIn, curr);
            memcpy( BLIB_ELEMENT_PTR(libOut, curr+1), BLIB_ELEMENT_PTR(libIn, curr), BLIB_ELEMENT_SIZE(libIn, curr) );
        }
        libOut->offsets[curr+1] = dwSizeOut;

        /* Destroy the input library */
        BLIB_Destroy( &libIn );

        /* Return the output library */
        *lib = libOut;
    }
    return true;
}

bool BLIB_ElementDelete( BLIB **lib, int index )
{
    /* Remove an element from the library */
    assert( BLIB_VALID( *lib ) );
    assert( BLIB_INDEX_VALID( *lib, index ) );
    assert( (*lib)->count );

    {
        int curr;
        uint32 dwSizeIn  = BLIB_SIZE(*lib);
        BLIB *libIn      = *lib;
        uint32 dwSizeOut = dwSizeIn - (BLIB_ELEMENT_SIZE( libIn, index ) + sizeof(uint32));
        BLIB *libOut     = malloc( dwSizeOut );
        if( !libOut )
            return false;

        /* Copy original data */
        *libOut = *libIn;
        libOut->count--;
        dwSizeOut = sizeof( BLIB ) + (libOut->count * sizeof(uint32) );

        /* Copy over any unaffected items */
        for( curr = 0; curr < index; ++curr )
        {
            libOut->offsets[curr] = dwSizeOut;
            dwSizeOut += BLIB_ELEMENT_SIZE(libIn, curr);
            memcpy( BLIB_ELEMENT_PTR(libOut, curr), BLIB_ELEMENT_PTR(libIn, curr), BLIB_ELEMENT_SIZE(libIn, curr) );
        }
        
        /* Copy over any unaffected items */
        for( curr = index + 1; curr < (int)libIn->count; ++curr )
        {
            libOut->offsets[curr-1] = dwSizeOut;
            dwSizeOut += BLIB_ELEMENT_SIZE(libIn, curr);
            memcpy( BLIB_ELEMENT_PTR(libOut, curr-1), BLIB_ELEMENT_PTR(libIn, curr), BLIB_ELEMENT_SIZE(libIn, curr) );
        }
        libOut->offsets[curr-1] = dwSizeOut;

        /* Destroy the input library */
        BLIB_Destroy( &libIn );

        /* Return the output library */
        *lib = libOut;
    }
    return true;
}

#else /* CTL_UNIT */

#include "unit/unit.h"

/* Just run this in the debugger to try out various  */
const char *TestJunk[] = {
    "1SPORK",
    "2FOON",
    "3FOO",
    "4BAR",
    "5BAZ",
    "6NI",
    "76543210",
    NULL
};

void Test_BLIB(void)
{
    {   
        /*
         * Append test
         */
        int curr, count;
        BLIB *lib = BLIB_Create( *((uint32 *)"SPAM") );
        Test_Error( BLIB_Valid( lib, BLIB_Size(lib) ) );
        for( curr = 0; TestJunk[curr]; ++curr )
        {
            BLIB_ElementAdd( &lib, TestJunk[curr], strlen( TestJunk[curr] ) + 1 );
            Test_Error( BLIB_Valid( lib, BLIB_Size(lib) ) );
        }
        Test_Error( BLIB_Count( lib ) == countof(TestJunk)-1 );
        /*
         * Contains what was put in?
         */
        count = BLIB_Count( lib );
        for( curr = 0; curr < count; ++curr )
        {
            Test_Error( !strcmp(TestJunk[curr], BLIB_ElementPointer( lib, curr ) ) );
        }
    
        /*
         * Deletion test
         */
        BLIB_ElementDelete( &lib, 2 );
        BLIB_ElementDelete( &lib, 1 );
        BLIB_ElementDelete( &lib, 0 );
        count = BLIB_Count( lib );
        for( curr = 0; curr < count; ++curr )
        {
            Test_Error( !strcmp(TestJunk[curr+3], BLIB_ElementPointer( lib, curr ) ) );
            Test_Error( BLIB_Valid( lib, BLIB_Size(lib) ) );
        }

        /*
         * Un-delete first three members
         */
        for( curr = 0; curr < 3; ++curr )
        {
            BLIB_ElementInsert( &lib, 0, TestJunk[curr], strlen( TestJunk[curr] ) + 1 );
            Test_Error( BLIB_Valid( lib, BLIB_Size(lib) ) );
        }

        /*
         * Replacement test
         */

        BLIB_ElementReplace( &lib, 2, "ZAP! ZAP!", strlen("ZAP! ZAP!") + 1 );
        Test_Error( BLIB_Valid( lib, BLIB_Size(lib) ) );
        BLIB_ElementReplace( &lib, 0, "PING! PING!", strlen("PING! PING!") + 1 );
        Test_Error( BLIB_Valid( lib, BLIB_Size(lib) ) );
        count = BLIB_Count( lib );
        for( curr = 0; curr < count; ++curr )
        {
            if( curr == 0 )
            {
                Test_Error( !strcmp("PING! PING!", BLIB_ElementPointer( lib, curr ) ) );
            }
            else if( curr == 2 )
            {
                Test_Error( !strcmp("ZAP! ZAP!", BLIB_ElementPointer( lib, curr ) ) );
            }
            else
                Test_Error( !strcmp(TestJunk[curr], BLIB_ElementPointer( lib, curr ) ) );
        }
        
        BLIB_Destroy( &lib );
    }
    {   
        /*
         * Insertion test
         */
        int curr,rcurr, count;
        BLIB *lib = BLIB_Create( *((uint32 *)"FOON") );
        for( curr = 0; TestJunk[curr]; ++curr )
        {
            BLIB_ElementInsert( &lib, 0, TestJunk[curr], strlen( TestJunk[curr] ) + 1 );
            Test_Error( BLIB_Valid( lib, 0 ) );
        }
        Test_Error( BLIB_Count( lib ) == countof(TestJunk)-1 );
        /*
         * Contains what was put in?
         */
        count = BLIB_Count( lib );
        for( curr = 0, rcurr = countof(TestJunk)-2; curr < count; ++curr, --rcurr )
        {
            Test_Error( !strcmp(TestJunk[rcurr], BLIB_ElementPointer( lib, curr ) ) );
        }

        BLIB_Destroy( &lib );
    }
    

}


#endif /* CTL_UNIT */