#include "../precomp.hpp"

#include "THGeneral.h"

#include "THDiskFile.h"

#include "THFilePrivate.h"

namespace TH

{

typedef struct THDiskFile__

} THDiskFile;

static int THDiskFile_isOpened(THFile *self)

}

#ifdef __APPLE__

static size_t fread__(void *ptr, size_t size, size_t nitems, FILE *stream)

}

#else

#define fread__ fread

#endif

#define READ_WRITE_METHODS(TYPE, TYPEC, ASCII_READ_ELEM, ASCII_WRITE_ELEM) \

static long THDiskFile_read##TYPEC(THFile *self, TYPE *data, long n) \

{ \

THDiskFile *dfself = (THDiskFile*)(self); \

long nread = 0L; \

\

THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); \

THArgCheck(dfself->file.isReadable, 1, "attempt to read in a write-only file"); \

\

if(dfself->file.isBinary) \

{ \

nread = fread__(data, sizeof(TYPE), n, dfself->handle); \

if(!dfself->isNativeEncoding && (sizeof(TYPE) > 1) && (nread > 0)) \

THDiskFile_reverseMemory(data, data, sizeof(TYPE), nread); \

} \

else \

{ \

long i; \

for(i = 0; i < n; i++) \

{ \

ASCII_READ_ELEM; /* increment here result and break if wrong */ \

} \

if(dfself->file.isAutoSpacing && (n > 0)) \

{ \

int c = fgetc(dfself->handle); \

if( (c != '\n') && (c != EOF) ) \

ungetc(c, dfself->handle); \

} \

} \

\

if(nread != n) \

{ \

dfself->file.hasError = 1; /* shouldn't we put hasError to 0 all the time ? */ \

if(!dfself->file.isQuiet) \

THError("read error: read %d blocks instead of %d", nread, n); \

} \

\

return nread; \

}

static int THDiskFile_mode(const char *mode, int *isReadable, int *isWritable)

}

static void THDiskFile_seek(THFile *self, long position)

}

static void THDiskFile_seekEnd(THFile *self)

}

static long THDiskFile_position(THFile *self)

}

static void THDiskFile_close(THFile *self)

}

static void THDiskFile_reverseMemory(void *dst, const void *src, long blockSize, long numBlocks)

}

int THDiskFile_isLittleEndianCPU(void)

}

int THDiskFile_isBigEndianCPU(void)

{

return(!THDiskFile_isLittleEndianCPU());

}

void THDiskFile_nativeEndianEncoding(THFile *self)

}

void THDiskFile_littleEndianEncoding(THFile *self)

}

void THDiskFile_bigEndianEncoding(THFile *self)

}

void THDiskFile_longSize(THFile *self, int size)

}

void THDiskFile_noBuffer(THFile *self)

}

static void THDiskFile_free(THFile *self)

}

READ_WRITE_METHODS(unsigned char, Byte,

nread = fread(data, 1, n, dfself->handle); break,

nwrite = fwrite(data, 1, n, dfself->handle); break)

READ_WRITE_METHODS(char, Char,

nread = fread(data, 1, n, dfself->handle); break,

nwrite = fwrite(data, 1, n, dfself->handle); break)

READ_WRITE_METHODS(short, Short,

int ret = fscanf(dfself->handle, "%hd", &data[i]); if(ret <= 0) break; else nread++,

int ret = fprintf(dfself->handle, "%hd", data[i]); if(ret <= 0) break; else nwrite++)

READ_WRITE_METHODS(int, Int,

int ret = fscanf(dfself->handle, "%d\n\r", &data[i]); if(ret <= 0) break; else nread++,

int ret = fprintf(dfself->handle, "%d", data[i]); if(ret <= 0) break; else nwrite++)

READ_WRITE_METHODS(float, Float,

int ret = fscanf(dfself->handle, "%g", &data[i]); if(ret <= 0) break; else nread++,

int ret = fprintf(dfself->handle, "%.9g", data[i]); if(ret <= 0) break; else nwrite++)

READ_WRITE_METHODS(double, Double,

int ret = fscanf(dfself->handle, "%lg", &data[i]); if(ret <= 0) break; else nread++,

int ret = fprintf(dfself->handle, "%.17g", data[i]); if(ret <= 0) break; else nwrite++)

static long THDiskFile_readLong(THFile *self, int64 *data, long n)

}

static long THDiskFile_readString(THFile *self, const char *format, char **str_)

}

THFile *THDiskFile_new(const std::string &name, const char *mode, int isQuiet)

{

static struct THFileVTable vtable = {

THDiskFile_isOpened,

THDiskFile_readByte,

THDiskFile_readChar,

THDiskFile_readShort,

THDiskFile_readInt,

THDiskFile_readLong,

THDiskFile_readFloat,

THDiskFile_readDouble,

THDiskFile_readString,

THDiskFile_seek,

THDiskFile_seekEnd,

THDiskFile_position,

THDiskFile_close,

THDiskFile_free

};

int isReadable;

int isWritable;

FILE *handle;

THDiskFile *self;

THArgCheck(THDiskFile_mode(mode, &isReadable, &isWritable), 2, "file mode should be 'r','w' or 'rw'");

CV_Assert(isReadable && !isWritable);

#ifdef _MSC_VER

if (fopen_s(&handle, name.c_str(), "rb") != 0)

handle = NULL;

#else

handle = fopen(name.c_str(),"rb");

#endif

if(!handle)

{

if(isQuiet)

return 0;

else

THError("cannot open <%s> in mode %c%c", name.c_str(), (isReadable ? 'r' : ' '), (isWritable ? 'w' : ' '));

}

self = (THDiskFile*)THAlloc(sizeof(THDiskFile));

if (!self)

THError("cannot allocate memory for self");

self->handle = handle;

self->isNativeEncoding = 1;

self->longSize = 0;

self->file.vtable = &vtable;

self->file.isQuiet = isQuiet;

self->file.isReadable = isReadable;

self->file.isWritable = isWritable;

self->file.isBinary = 0;

self->file.isAutoSpacing = 1;

self->file.hasError = 0;

return (THFile*)self;

}

}