include/writedb.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	edit
struct	child
struct	sequenceData
Functions
void	writedb_initialize (char *filename, uint4 alphabetType)
void	writedb_addSequence (unsigned char *sequence, uint4 sequenceLength, unsigned char *description, uint4 descriptionLength, unsigned char *wildcards, uint4 wildcardsLength, struct child *children, uint4 numChildren)
void	writedb_close ()
Variables
char *	writedb_filename
FILE *	writedb_sequenceFile
FILE *	writedb_descriptionsFile
uint8	writedb_volumnSize
char *	writedb_sequenceFilename
char *	writedb_descriptionsFilename
char *	writedb_dataFilename
uint4	writedb_maximumSequenceLength
uint4	writedb_alphabetType
uint4	writedb_minimumSequenceLength
uint8	writedb_numberOfLetters
uint4	writedb_volume
uint4	writedb_sequenceCount

---

Function Documentation

void writedb_addSequence	(	unsigned char *	sequence,
		uint4	sequenceLength,
		unsigned char *	description,
		uint4	descriptionLength,
		unsigned char *	wildcards,
		uint4	wildcardsLength,
		struct child *	children,
		uint4	numChildren
	)

Definition at line 72 of file writedb.c.

References edit::code, constants_volumeMaxSize, child::description, sequenceData::descriptionLength, child::descriptionLength, child::edits, sequenceData::encodedLength, encoding_bytePackSequence(), encoding_nucleotide, encoding_sentinalCode, global_malloc(), child::length, memBlocks_newEntry(), child::numEdits, child::regionStart, sequenceData::sequenceLength, uint4, vbyte_safePutVbyte, writedb_alphabetType, writedb_descriptionsFile, writedb_descriptionsFilename, writedb_filename, writedb_maximumSequenceLength, writedb_minimumSequenceLength, writedb_numberOfClusters, writedb_numberOfLetters, writedb_sequenceCount, writedb_sequenceData, writedb_sequenceFile, writedb_sequenceFilename, writedb_volume, and writedb_volumeSize.

Referenced by cluster_writeClusters(), main(), and rsdb_writeClusters().

{
        uint4 encodedLength, childNum, sizeEdits = 0, editNum;
        unsigned char *editData, *startEditData;
    struct child child;
    struct sequenceData* sequenceData;

    sequenceData = memBlocks_newEntry(writedb_sequenceData);

    // Write the description to file
    if (description != NULL)
        if (fwrite(description, sizeof(unsigned char), descriptionLength, writedb_descriptionsFile)
            < descriptionLength)
        {
            fprintf(stderr, "Error writing header to sequence file %s\n", writedb_sequenceFilename);
            exit(-1);
        }

    // Calculate length of encoded sequence
    if (writedb_alphabetType == encoding_nucleotide)
    {
        encodedLength = encoding_bytePackSequence(sequence, sequenceLength);
        }
    else
    {
        encodedLength = sequenceLength + 2;
    }

        // Calculate maximum space required to record sequence's edits
    childNum = 0;
        while (childNum < numChildren)
    {
        child = children[childNum];
                sizeEdits += 16 + 5 * child.numEdits;
        childNum++;
        }

    // Initialize array to record edits
        editData = startEditData = global_malloc(sizeEdits);

    // Record children edits as vbytes
    childNum = 0;
        while (childNum < numChildren)
    {
        child = children[childNum];

        // Write children descriptions to disk
        if (fwrite(child.description, sizeof(unsigned char), child.descriptionLength,
            writedb_descriptionsFile) < child.descriptionLength)
        {
            fprintf(stderr, "Error writing description to sequence file %s\n", writedb_descriptionsFilename);
            exit(-1);
        }
        descriptionLength += child.descriptionLength;

        // Convert child details to vbytes
        vbyte_safePutVbyte(editData, child.descriptionLength);
        vbyte_safePutVbyte(editData, child.regionStart);
        vbyte_safePutVbyte(editData, child.length);
        vbyte_safePutVbyte(editData, child.numEdits);

        // Append edits
        editNum = 0;
        while (editNum < child.numEdits)
        {
                // Record edit character
                        *editData = child.edits[editNum].code;
            editData++;

                editNum++;
        }

        // Add sequence size to total tally of letters
        writedb_numberOfLetters += child.length;
        writedb_sequenceCount++;

        childNum++;
    }

    // Update volume size, encoded length
    encodedLength += (editData - startEditData);
    writedb_volumeSize += encodedLength + wildcardsLength;

    sequenceData->descriptionLength = descriptionLength;
        sequenceData->sequenceLength = sequenceLength;
        sequenceData->encodedLength = encodedLength + wildcardsLength;

    // If the entry will exceed volume max size
    if (writedb_volumeSize > constants_volumeMaxSize)
    {
        // Close current volume
        fclose(writedb_sequenceFile);

        // Open next volume for writing
        writedb_volume++;
        sprintf(writedb_sequenceFilename, "%s.sequences%d", writedb_filename, writedb_volume);
        if ((writedb_sequenceFile = fopen(writedb_sequenceFilename, "w")) == NULL)
        {
            fprintf(stderr, "Error opening file %s for writing\n", writedb_sequenceFilename);
            exit(-1);
        }

        // Reset volume size counter
        writedb_volumeSize = encodedLength + wildcardsLength;
    }

    // Nulceotide
    if (writedb_alphabetType == encoding_nucleotide)
    {
        // Write packed nucleotide sequences to disk
        if (fwrite(sequence, sizeof(unsigned char), encodedLength, writedb_sequenceFile) < encodedLength)
        {
            fprintf(stderr, "Error writing to sequence file %s\n", writedb_sequenceFilename);
            exit(-1);
        }
    }
    // Protein
    else
    {
        // Write sentinal byte after protein sequences
        fputc(encoding_sentinalCode, writedb_sequenceFile);

        // Write sequence codes to disk
        if (fwrite(sequence, sizeof(unsigned char), sequenceLength, writedb_sequenceFile) < sequenceLength)
        {
            fprintf(stderr, "Error writing to sequence file %s\n", writedb_sequenceFilename);
            exit(-1);
        }

        // Write sentinal byte after protein sequences
        fputc(encoding_sentinalCode, writedb_sequenceFile);
    }

    // Write wildcard data to disk
    if (fwrite(wildcards, sizeof(unsigned char), wildcardsLength, writedb_sequenceFile) < wildcardsLength)
    {
        fprintf(stderr, "Error writing to sequence file %s\n", writedb_sequenceFilename);
        exit(-1);
    }

    // Write edit information to disk
    if (fwrite(startEditData, sizeof(unsigned char), (editData - startEditData),
               writedb_sequenceFile) < (editData - startEditData))
    {
        fprintf(stderr, "Error writing to sequence file %s\n", writedb_sequenceFilename);
        exit(-1);
    }
    free(startEditData);

        if (numChildren == 0)
    {
        // Add sequence size to total tally of letters
        writedb_numberOfLetters += sequenceLength;
        writedb_sequenceCount++;
        }

    writedb_numberOfClusters++;

    // Check for new longest/shortest sequence
    if (sequenceLength > writedb_maximumSequenceLength)
        writedb_maximumSequenceLength = sequenceLength;
    if (writedb_minimumSequenceLength == 0 || sequenceLength < writedb_minimumSequenceLength)
        writedb_minimumSequenceLength = sequenceLength;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void writedb_close

(

)

Definition at line 240 of file writedb.c.

References constants_databaseVersion, sequenceData::descriptionLength, sequenceData::encodedLength, encoding_protein, encoding_sentinalCode, memBlocks_free(), memBlocks_getCurrent(), memBlocks_resetCurrent(), sequenceData::sequenceLength, uint4, vbyte_safePutVbyte, writedb_alphabetType, writedb_dataFile, writedb_dataFilename, writedb_descriptionsFile, writedb_maximumSequenceLength, writedb_numberOfClusters, writedb_numberOfLetters, writedb_sequenceCount, writedb_sequenceData, writedb_sequenceFile, and writedb_volume.

Referenced by cluster_writeClusters(), main(), and rsdb_writeClusters().

{
        unsigned char headerData[40], *headerDataPointer;
        uint4 headerLength;
    struct sequenceData* sequenceData;

    // Write sentinal/padding byte at end
        if (writedb_alphabetType == encoding_protein)
        fputc(encoding_sentinalCode, writedb_sequenceFile);
    else
        fputc(0, writedb_sequenceFile);

    // Close writing to sequence and description files
        fclose(writedb_sequenceFile);
        fclose(writedb_descriptionsFile);

        // Open data file for writing
        if ((writedb_dataFile = fopen(writedb_dataFilename, "w")) == NULL)
        {
                fprintf(stderr, "Error opening file %s for writing\n", writedb_dataFilename);
                exit(-1);
        }

        // Convert 6 header values to vbytes
    headerDataPointer = headerData;
    vbyte_safePutVbyte(headerDataPointer, constants_databaseVersion);
    vbyte_safePutVbyte(headerDataPointer, writedb_sequenceCount);
    vbyte_safePutVbyte(headerDataPointer, writedb_numberOfLetters);
    vbyte_safePutVbyte(headerDataPointer, writedb_maximumSequenceLength);
    vbyte_safePutVbyte(headerDataPointer, writedb_alphabetType);
    vbyte_safePutVbyte(headerDataPointer, writedb_numberOfClusters);
        vbyte_safePutVbyte(headerDataPointer, writedb_volume + 1);

    // Write the header data at the start of the file
    headerLength = headerDataPointer - headerData;
    if (fwrite(&headerData, sizeof(unsigned char), headerLength, writedb_dataFile) < headerLength)
        {
                fprintf(stderr, "Error writing header to sequence file %s\n", writedb_dataFilename);
                exit(-1);
        }

    // For each sequence
        memBlocks_resetCurrent(writedb_sequenceData);
    while ((sequenceData = memBlocks_getCurrent(writedb_sequenceData)) != NULL)
    {
        // Prepare to write sequence description length, subject length, and encoded length using vbytes
            headerDataPointer = headerData;
        vbyte_safePutVbyte(headerDataPointer, sequenceData->descriptionLength);
        vbyte_safePutVbyte(headerDataPointer, sequenceData->sequenceLength);
        vbyte_safePutVbyte(headerDataPointer, sequenceData->encodedLength);

        // Write sequence header information
        headerLength = headerDataPointer - headerData;
        if (fwrite(headerData, sizeof(unsigned char), headerLength, writedb_dataFile) < headerLength)
        {
            fprintf(stderr, "Error writing to sequence file %s\n", writedb_dataFilename);
            exit(-1);
        }
        }

        // Close writing to sequence file
        fclose(writedb_dataFile);

    memBlocks_free(writedb_sequenceData);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void writedb_initialize	(	char *	filename,
		uint4	alphabetType
	)

Definition at line 20 of file writedb.c.

References constants_initialSequenceData, encoding_protein, encoding_sentinalCode, global_malloc(), memBlocks_initialize(), writedb_alphabetType, writedb_dataFilename, writedb_descriptionsFile, writedb_descriptionsFilename, writedb_filename, writedb_maximumSequenceLength, writedb_minimumSequenceLength, writedb_numberOfClusters, writedb_numberOfLetters, writedb_sequenceCount, writedb_sequenceData, writedb_sequenceFile, writedb_sequenceFilename, writedb_volume, and writedb_volumeSize.

Referenced by cluster_writeClusters(), main(), and rsdb_writeClusters().

{
        char* wildcardsFilename;

    writedb_filename = filename;
    writedb_alphabetType = alphabetType;
        writedb_maximumSequenceLength = 0;
        writedb_minimumSequenceLength = 0;
        writedb_numberOfLetters = 0;
        writedb_volume = 0;
    writedb_sequenceCount = 0;
    writedb_numberOfClusters = 0;

        // Construct sequence and description filenames
        writedb_sequenceFilename = (char*)global_malloc(strlen(filename) + 13);
        sprintf(writedb_sequenceFilename, "%s.sequences", filename);
        writedb_descriptionsFilename = (char*)global_malloc(strlen(filename) + 15);
        sprintf(writedb_descriptionsFilename, "%s.descriptions", filename);
        writedb_dataFilename = (char*)global_malloc(strlen(filename) + 8);
        sprintf(writedb_dataFilename, "%s.data", filename);
        wildcardsFilename = (char*)global_malloc(strlen(filename) + 12);
        sprintf(wildcardsFilename, "%s.wildcards", filename);

    // Delete the wildcards file if one exists
    rename(wildcardsFilename, writedb_sequenceFilename);

        // Open sequence file for writing
        if ((writedb_sequenceFile = fopen(writedb_sequenceFilename, "w")) == NULL)
        {
                fprintf(stderr, "Error opening file %s for writing\n", writedb_sequenceFilename);
                exit(-1);
        }

    // Write sentinal/padding byte at start
        if (alphabetType == encoding_protein)
        fputc(encoding_sentinalCode, writedb_sequenceFile);
    else
        fputc(0, writedb_sequenceFile);

        // Open descriptions file for writing
        if ((writedb_descriptionsFile = fopen(writedb_descriptionsFilename, "w")) == NULL)
        {
                fprintf(stderr, "Error opening file %s for writing\n", writedb_descriptionsFilename);
                exit(-1);
        }

    writedb_volumeSize = 1;
    writedb_sequenceData = memBlocks_initialize(sizeof(struct sequenceData),
                           constants_initialSequenceData);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

uint4 writedb_alphabetType

Definition at line 14 of file writedb.c.

Referenced by writedb_addSequence(), writedb_close(), and writedb_initialize().

char * writedb_dataFilename

Definition at line 13 of file writedb.c.

Referenced by cluster_writeClusters(), writedb_close(), and writedb_initialize().

FILE * writedb_descriptionsFile

Definition at line 11 of file writedb.c.

Referenced by writedb_addSequence(), writedb_close(), and writedb_initialize().

char * writedb_descriptionsFilename

Definition at line 13 of file writedb.c.

Referenced by cluster_writeClusters(), writedb_addSequence(), and writedb_initialize().

char* writedb_filename

Definition at line 10 of file writedb.c.

Referenced by writedb_addSequence(), and writedb_initialize().

uint4 writedb_maximumSequenceLength

Definition at line 14 of file writedb.c.

Referenced by main(), writedb_addSequence(), writedb_close(), and writedb_initialize().

uint4 writedb_minimumSequenceLength

Definition at line 14 of file writedb.c.

Referenced by main(), writedb_addSequence(), and writedb_initialize().

uint8 writedb_numberOfLetters

Definition at line 15 of file writedb.c.

Referenced by main(), rsdb_writeClusters(), writedb_addSequence(), writedb_close(), and writedb_initialize().

uint4 writedb_sequenceCount

Definition at line 16 of file writedb.c.

Referenced by main(), writedb_addSequence(), writedb_close(), and writedb_initialize().

FILE* writedb_sequenceFile

Definition at line 11 of file writedb.c.

Referenced by writedb_addSequence(), writedb_close(), and writedb_initialize().

char* writedb_sequenceFilename

Definition at line 13 of file writedb.c.

Referenced by cluster_writeClusters(), writedb_addSequence(), and writedb_initialize().

uint4 writedb_volume

Definition at line 16 of file writedb.c.

Referenced by main(), writedb_addSequence(), writedb_close(), and writedb_initialize().

uint8 writedb_volumnSize

---