resizeBuff.cpp

#include <resizeBuff.h>

//#include <debug.h>


//****************************************************************************************
//****************************************************************************************
//
//       DON'T USE UNINITIALIZED POINTERS!! EVEN JUST SETTING TO NULL WILL BE FINE.
//
// Once your pointer is either set to NULL or allocated, then it can be used in here all
// you want.
//****************************************************************************************
//****************************************************************************************



//****************************************************************************************
// resizeBuff:
//****************************************************************************************


bool resizeBuff(int numBytes,uint8_t** buff) {

	if(*buff) {											// If we did NOT get passed in a NULL..
		free(*buff);									// We free the memory.
		*buff = NULL;									// Set the pointer to NULL.
	}														//
	if (numBytes>0) {									// If we got a positive non zero value..
		*buff = (uint8_t*)malloc(numBytes);		// We attempt allocate that number of bytes.
		if (*buff==NULL) {
			//Serial.print("resizeBuff fail : ");
			//Serial.println(numBytes);
		}
		return *buff != NULL;						// And we return true for non NULL result (non-NULL = Success)
	}														//
	return true;										// In this case we were not asked to allocate anything so it was a success.
}

bool resizeBuff(int numBytes,char** buff) { return resizeBuff(numBytes,(uint8_t**)buff); }

bool resizeBuff(int numBytes,void** buff) { return resizeBuff(numBytes,(uint8_t**)buff); }

bool resizeBuff(int numBytes,float** buff) { return resizeBuff(numBytes,(uint8_t**)buff); }



//****************************************************************************************
// maxBuff:
//
// Class for slicing up huge data streams into bite sized buffers. Good for things like
// copying one file to another.
//****************************************************************************************


maxBuff::maxBuff(unsigned long numBytes,unsigned long  minBytes) {

    theBuff           = NULL;                              // Pointers start at NULL.
    numBuffBytes    = numBytes;                            // In a perfect world, numBytes will work.
    numPasses         = 1;                                 // In that same world, we'll only need one pass.
    while(!resizeBuff(numBuffBytes,&theBuff)) {            // Have a go at allocating the buffer..
        numPasses++;                                       // If we didn't get it, bump up number of passes.
        numBuffBytes = (numBytes/numPasses) + 1;           // Cut down the buffer size.
        if (numBuffBytes<minBytes) return;                 // At some point, lets just give up.
    }                                                      // If we didn't get it last time, we try again smaller.
}


maxBuff::~maxBuff(void) { resizeBuff(0,&theBuff); }