bytearray.c

Go to the documentation of this file.

/*====================================================================*
 -  Copyright (C) 2001 Leptonica.  All rights reserved.
 -
 -  Redistribution and use in source and binary forms, with or without
 -  modification, are permitted provided that the following conditions
 -  are met:
 -  1. Redistributions of source code must retain the above copyright
 -     notice, this list of conditions and the following disclaimer.
 -  2. Redistributions in binary form must reproduce the above
 -     copyright notice, this list of conditions and the following
 -     disclaimer in the documentation and/or other materials
 -     provided with the distribution.
 -
 -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
 -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *====================================================================*/
 
#ifdef HAVE_CONFIG_H
#include <config_auto.h>
#endif  /* HAVE_CONFIG_H */
 
#include <string.h>
#include "allheaders.h"
#include "array_internal.h"
 
    /* Bounds on array size */
static const l_uint32  MaxArraySize = 1000000000;   /* 10^9 bytes */
static const l_int32   InitialArraySize = 200;      
    /* Static function */
static l_int32 l_byteaExtendArrayToSize(L_BYTEA *ba, size_t size);
 
/*---------------------------------------------------------------------*
 *                  Creation, copy, clone, destruction                 *
 *---------------------------------------------------------------------*/
L_BYTEA *
l_byteaCreate(size_t  nbytes)
{
L_BYTEA  *ba;
 
    if (nbytes <= 0 || nbytes > MaxArraySize)
        nbytes = InitialArraySize;
    ba = (L_BYTEA *)LEPT_CALLOC(1, sizeof(L_BYTEA));
    ba->data = (l_uint8 *)LEPT_CALLOC(nbytes + 1, sizeof(l_uint8));
    if (!ba->data) {
        l_byteaDestroy(&ba);
        return (L_BYTEA *)ERROR_PTR("ba array not made", __func__, NULL);
    }
    ba->nalloc = nbytes + 1;
    ba->refcount = 1;
    return ba;
}
 
 
L_BYTEA *
l_byteaInitFromMem(const l_uint8  *data,
                   size_t          size)
{
L_BYTEA  *ba;
 
    if (!data)
        return (L_BYTEA *)ERROR_PTR("data not defined", __func__, NULL);
    if (size <= 0)
        return (L_BYTEA *)ERROR_PTR("no bytes to initialize", __func__, NULL);
    if (size > MaxArraySize)
        return (L_BYTEA *)ERROR_PTR("size is too big", __func__, NULL);
 
    if ((ba = l_byteaCreate(size)) == NULL)
        return (L_BYTEA *)ERROR_PTR("ba not made", __func__, NULL);
    memcpy(ba->data, data, size);
    ba->size = size;
    return ba;
}
 
 
L_BYTEA *
l_byteaInitFromFile(const char  *fname)
{
FILE     *fp;
L_BYTEA  *ba;
 
    if (!fname)
        return (L_BYTEA *)ERROR_PTR("fname not defined", __func__, NULL);
 
    if ((fp = fopenReadStream(fname)) == NULL)
        return (L_BYTEA *)ERROR_PTR_1("file stream not opened",
                                      fname, __func__, NULL);
    ba = l_byteaInitFromStream(fp);
    fclose(fp);
    if (!ba)
        return (L_BYTEA *)ERROR_PTR_1("ba not made", fname, __func__, NULL);
    return ba;
}
 
 
L_BYTEA *
l_byteaInitFromStream(FILE  *fp)
{
l_uint8  *data;
size_t    nbytes;
L_BYTEA  *ba;
 
    if (!fp)
        return (L_BYTEA *)ERROR_PTR("stream not defined", __func__, NULL);
 
    if ((data = l_binaryReadStream(fp, &nbytes)) == NULL)
        return (L_BYTEA *)ERROR_PTR("data not read", __func__, NULL);
    if ((ba = l_byteaCreate(nbytes)) == NULL) {
        LEPT_FREE(data);
        return (L_BYTEA *)ERROR_PTR("ba not made", __func__, NULL);
    }
    memcpy(ba->data, data, nbytes);
    ba->size = nbytes;
    LEPT_FREE(data);
    return ba;
}
 
 
L_BYTEA *
l_byteaCopy(L_BYTEA  *bas,
            l_int32   copyflag)
{
    if (!bas)
        return (L_BYTEA *)ERROR_PTR("bas not defined", __func__, NULL);
 
    if (copyflag == L_CLONE) {
        bas->refcount++;
        return bas;
    }
 
    return l_byteaInitFromMem(bas->data, bas->size);
}
 
 
void
l_byteaDestroy(L_BYTEA  **pba)
{
L_BYTEA  *ba;
 
    if (pba == NULL) {
        L_WARNING("ptr address is null!\n", __func__);
        return;
    }
 
    if ((ba = *pba) == NULL)
        return;
 
        /* Decrement the ref count.  If it is 0, destroy the lba. */
    if (--ba->refcount == 0) {
        if (ba->data) LEPT_FREE(ba->data);
        LEPT_FREE(ba);
    }
    *pba = NULL;
}
 
 
/*---------------------------------------------------------------------*
 *                               Accessors                             *
 *---------------------------------------------------------------------*/
size_t
l_byteaGetSize(L_BYTEA  *ba)
{
    if (!ba)
        return ERROR_INT("ba not defined", __func__, 0);
    return ba->size;
}
 
 
l_uint8 *
l_byteaGetData(L_BYTEA  *ba,
               size_t   *psize)
{
    if (!ba)
        return (l_uint8 *)ERROR_PTR("ba not defined", __func__, NULL);
    if (!psize)
        return (l_uint8 *)ERROR_PTR("&size not defined", __func__, NULL);
 
    *psize = ba->size;
    return ba->data;
}
 
 
l_uint8 *
l_byteaCopyData(L_BYTEA  *ba,
                size_t   *psize)
{
l_uint8  *data;
 
    if (!psize)
        return (l_uint8 *)ERROR_PTR("&size not defined", __func__, NULL);
    *psize = 0;
    if (!ba)
        return (l_uint8 *)ERROR_PTR("ba not defined", __func__, NULL);
 
    data = l_byteaGetData(ba, psize);
    return l_binaryCopy(data, *psize);
}
 
 
/*---------------------------------------------------------------------*
 *                               Appending                             *
 *---------------------------------------------------------------------*/
l_ok
l_byteaAppendData(L_BYTEA        *ba,
                  const l_uint8  *newdata,
                  size_t          newbytes)
{
size_t  size, nalloc, reqsize;
 
    if (!ba)
        return ERROR_INT("ba not defined", __func__, 1);
    if (!newdata)
        return ERROR_INT("newdata not defined", __func__, 1);
 
    size = l_byteaGetSize(ba);
    reqsize = size + newbytes + 1;
    nalloc = ba->nalloc;
    if (nalloc < reqsize) {
        if (l_byteaExtendArrayToSize(ba, 2 * reqsize))
            return ERROR_INT("extension failed", __func__, 1);
    }
 
    memcpy(ba->data + size, newdata, newbytes);
    ba->size += newbytes;
    return 0;
}
 
 
l_ok
l_byteaAppendString(L_BYTEA     *ba,
                    const char  *str)
{
size_t  size, len, nalloc, reqsize;
 
    if (!ba)
        return ERROR_INT("ba not defined", __func__, 1);
    if (!str)
        return ERROR_INT("str not defined", __func__, 1);
 
    size = l_byteaGetSize(ba);
    len = strlen(str);
    reqsize = size + len + 1;
    nalloc = ba->nalloc;
    if (nalloc < reqsize) {
        if (l_byteaExtendArrayToSize(ba, 2 * reqsize))
            return ERROR_INT("extension failed", __func__, 1);
    }
 
    memcpy(ba->data + size, str, len);
    ba->size += len;
    return 0;
}
 
 
static l_int32
l_byteaExtendArrayToSize(L_BYTEA  *ba,
                         size_t    size)
{
    if (!ba)
        return ERROR_INT("ba not defined", __func__, 1);
    if (ba->nalloc > MaxArraySize)  /* belt & suspenders */
        return ERROR_INT("ba has too many ptrs", __func__, 1);
    if (size > MaxArraySize)
        return ERROR_INT("size > 1 GB; too large", __func__, 1);
    if (size <= ba->nalloc) {
        L_INFO("size too small; no extension\n", __func__);
        return 0;
    }
 
    if ((ba->data =
        (l_uint8 *)reallocNew((void **)&ba->data, ba->nalloc, size)) == NULL)
        return ERROR_INT("new array not returned", __func__, 1);
    ba->nalloc = size;
    return 0;
}
 
 
/*---------------------------------------------------------------------*
 *                        String join/split                            *
 *---------------------------------------------------------------------*/
l_ok
l_byteaJoin(L_BYTEA   *ba1,
            L_BYTEA  **pba2)
{
l_uint8  *data2;
size_t    nbytes2;
L_BYTEA  *ba2;
 
    if (!ba1)
        return ERROR_INT("ba1 not defined", __func__, 1);
    if (!pba2)
        return ERROR_INT("&ba2 not defined", __func__, 1);
    if ((ba2 = *pba2) == NULL) return 0;
 
    data2 = l_byteaGetData(ba2, &nbytes2);
    l_byteaAppendData(ba1, data2, nbytes2);
 
    l_byteaDestroy(pba2);
    return 0;
}
 
 
l_ok
l_byteaSplit(L_BYTEA   *ba1,
             size_t     splitloc,
             L_BYTEA  **pba2)
{
l_uint8  *data1;
size_t    nbytes1, nbytes2;
 
    if (!pba2)
        return ERROR_INT("&ba2 not defined", __func__, 1);
    *pba2 = NULL;
    if (!ba1)
        return ERROR_INT("ba1 not defined", __func__, 1);
 
    data1 = l_byteaGetData(ba1, &nbytes1);
    if (splitloc >= nbytes1)
        return ERROR_INT("splitloc invalid", __func__, 1);
    nbytes2 = nbytes1 - splitloc;
 
        /* Make the new lba */
    *pba2 = l_byteaInitFromMem(data1 + splitloc, nbytes2);
 
        /* Null the removed bytes in the input lba */
    memset(data1 + splitloc, 0, nbytes2);
    ba1->size = splitloc;
    return 0;
}
 
 
/*---------------------------------------------------------------------*
 *                                Search                               *
 *---------------------------------------------------------------------*/
l_ok
l_byteaFindEachSequence(L_BYTEA        *ba,
                        const l_uint8  *sequence,
                        size_t          seqlen,
                        L_DNA         **pda)
{
l_uint8  *data;
size_t    size;
 
    if (!pda)
        return ERROR_INT("&da not defined", __func__, 1);
    *pda = NULL;
    if (!ba)
        return ERROR_INT("ba not defined", __func__, 1);
    if (!sequence)
        return ERROR_INT("sequence not defined", __func__, 1);
 
    data = l_byteaGetData(ba, &size);
    *pda = arrayFindEachSequence(data, size, sequence, seqlen);
    return 0;
}
 
 
/*---------------------------------------------------------------------*
 *                              Output to file                         *
 *---------------------------------------------------------------------*/
l_ok
l_byteaWrite(const char  *fname,
             L_BYTEA     *ba,
             size_t       startloc,
             size_t       nbytes)
{
l_int32  ret;
FILE    *fp;
 
    if (!fname)
        return ERROR_INT("fname not defined", __func__, 1);
    if (!ba)
        return ERROR_INT("ba not defined", __func__, 1);
 
    if ((fp = fopenWriteStream(fname, "wb")) == NULL)
        return ERROR_INT_1("stream not opened", fname, __func__, 1);
    ret = l_byteaWriteStream(fp, ba, startloc, nbytes);
    fclose(fp);
    return ret;
}
 
 
l_ok
l_byteaWriteStream(FILE     *fp,
                   L_BYTEA  *ba,
                   size_t    startloc,
                   size_t    nbytes)
{
l_uint8  *data;
size_t    size, maxbytes;
 
    if (!fp)
        return ERROR_INT("stream not defined", __func__, 1);
    if (!ba)
        return ERROR_INT("ba not defined", __func__, 1);
 
    data = l_byteaGetData(ba, &size);
    if (startloc >= size)
        return ERROR_INT("invalid startloc", __func__, 1);
    maxbytes = size - startloc;
    nbytes = (nbytes == 0) ? maxbytes : L_MIN(nbytes, maxbytes);
 
    fwrite(data + startloc, 1, nbytes, fp);
    return 0;
}