void SimulatedDisk::format() {
    FILE * discoFofinho = fopen(fileName, "wb" );
    for( unsigned i = 0; i < diskSize; i++ )
        fputc(0, discoFofinho);

    fclose(discoFofinho);
}
void SimulatedDisk::writeBlock(Block* block) {
    FILE * discoFofinho = fopen(fileName, "rb+");
    Block::number position = block->physicalSource;
    fseek(discoFofinho, position * blockSize, SEEK_SET);

    unsigned char * data = Storage::extractData(block);
    fwrite(data, 1, blockSize, discoFofinho);
    fclose(discoFofinho);
}
Block * SimulatedDisk::readBlock(Block::number n, Block::flushInterval i) {
    FILE * discoFofinho = fopen(fileName, "rb");
    fseek(discoFofinho, n * blockSize, SEEK_SET);

    unsigned char * data = new unsigned char[blockSize];

    fread(data, 1, blockSize, discoFofinho);
    fclose(discoFofinho);

    return Storage::constructBlock(data, blockSize, n, i);
}
void CResourceMapAnalyzer::SaveResourceMap() {
	std::string map = GetCacheFileName();
	FILE* saveFile = fopen(map.c_str(), "wb");

	assert(saveFile != NULL);

	fwrite(&NumSpotsFound, sizeof(int), 1, saveFile);
	fwrite(&AverageIncome, sizeof(float), 1, saveFile);

	for (int i = 0; i < NumSpotsFound; i++) {
		fwrite(&VectoredSpots[i], sizeof(float3), 1, saveFile);
	}

	fclose(saveFile);
}
bool CResourceMapAnalyzer::LoadResourceMap() {
	std::string map = GetCacheFileName();
	FILE* loadFile = fopen(map.c_str(), "rb");

	if (loadFile != NULL) {
		fread(&NumSpotsFound, sizeof(int), 1, loadFile);
		VectoredSpots.resize(NumSpotsFound);
		fread(&AverageIncome, sizeof(float), 1, loadFile);

		for (int i = 0; i < NumSpotsFound; i++) {
			fread(&VectoredSpots[i], sizeof(float3), 1, loadFile);
		}

		fclose(loadFile);
		return true;
	}

	return false;
}
int mem_usage(double& vm_usage, double& resident_set) {

#ifdef _WIN32

    // Figure out if we're on WinNT
    OSVERSIONINFO osvi; 
    osvi.dwOSVersionInfoSize = sizeof(osvi);
    GetVersionEx( &osvi );
    if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
        SIZE_T lpMinimumWorkingSetSize;
        SIZE_T lpMaximumWorkingSetSize;

        GetProcessWorkingSetSize(
            GetCurrentProcess(),
            &lpMinimumWorkingSetSize,
            &lpMaximumWorkingSetSize
        );

        vm_usage = (double)lpMinimumWorkingSetSize;
        resident_set = (double)lpMaximumWorkingSetSize;
    } else {
        return ERR_NOT_IMPLEMENTED;
    }
    return 0;
#else


#if HAVE_PROCFS_H && HAVE__PROC_SELF_PSINFO
    FILE* f;

    // guess that this is solaris
    // need psinfo_t from procfs.h
    //
    if ((f = fopen("/proc/self/psinfo", "r")) != 0) {
        psinfo_t psinfo;

        if (fread(&psinfo, sizeof(psinfo_t), 1, f) == 1) {
            vm_usage = psinfo.pr_size*1024.;
            resident_set = psinfo.pr_rssize*1024.;
            fclose(f);
            return 0;
        } else {
            fclose(f);
            return ERR_FREAD;
        }
    }
#endif

#if HAVE__PROC_SELF_STAT
    FILE* f;
    // guess that this is linux
    //
    if ((f = fopen("/proc/self/stat", "r")) != 0) {
        char buf[256];
        char* p;
        int i;
        unsigned long tmp;

        i = fread(buf, sizeof(char), 255, f);
        buf[i] = '\0'; // terminate string
        p = &buf[0];

        // skip over first 22 fields
        //
        for (i = 0; i < 22; ++i) {
            p = strchr(p, ' ');
            if (!p) break;
            ++p; // move past space
        }
        if (!p) {
            return ERR_NOT_IMPLEMENTED;
        }

        // read virtual memory size in bytes.
        //
        vm_usage = atof(p);
        p = strchr(p, ' ');

        // read resident set size: number of pages the process has in
        // real memory, minus 3 for administrative purposes.
        //
        tmp = strtol(p, 0, 0);
        resident_set = (double)(tmp + 3)*getpagesize();

        fclose(f);
        return 0;
    }
#endif

    return ERR_NOT_IMPLEMENTED;
#endif
}
static  XalanFileOutputStream::HandleType
openFile(
            const XalanDOMString&   theFileName,
            MemoryManager&          theManager)
{
    typedef XalanFileOutputStream::HandleType   HandleType;

#if defined(XALAN_WINDOWS)
    HandleType  theFileHandle = CreateFileW(
            theFileName.c_str(),
            GENERIC_WRITE,
            0,
            0,
            CREATE_ALWAYS,
            FILE_ATTRIBUTE_NORMAL,
            0);

    if (theFileHandle != INVALID_HANDLE_VALUE && theFileHandle != 0)
    {
        return theFileHandle;
    }
    else
    {
        
        CharVectorType  theResult(theManager);

        TranscodeToLocalCodePage(theFileName, theResult, true);

        if (theResult.empty() == true)
        {
            return INVALID_HANDLE_VALUE;
        }
        else
        {
            const char* const   tmpName = &theResult[0];

            if (tmpName == 0)
            {
                return INVALID_HANDLE_VALUE;
            }
            else
            {
                return CreateFile(
                            tmpName,
                            GENERIC_WRITE,
                            0,
                            0,
                            CREATE_ALWAYS,
                            FILE_ATTRIBUTE_NORMAL,
                            0);
            }
        }
    }
#else
#if defined(XALAN_STRICT_ANSI_HEADERS)
    using std::fopen;
#endif

    CharVectorType  theResult(theManager);
    TranscodeToLocalCodePage(theFileName, theResult, true);

    if (theResult.empty() == true)
    {
        return 0;
    }
    else
    {
        const char* const   tmpName = &theResult[0];

        if (tmpName == 0)
        {
            return 0;
        }
        else
        {
            return fopen(tmpName, "wb");
        }
    }
#endif
}