comparison data/fileio/MatrixFile.cpp @ 929:59e7fe1b1003 warnfix_no_size_t

Unsigned removals and warning fixes in data/

 static size_t totalStorage = 0;
 static size_t totalCount = 0;
 static size_t openCount = 0;
 
 MatrixFile::MatrixFile(QString fileBase, Mode mode,
-                       size_t cellSize, size_t width, size_t height) :
+                       int cellSize, int width, int height) :
     m_fd(-1),
     m_mode(mode),
     m_flags(0),
     m_fmode(0),
     m_cellSize(cellSize),
     m_width(width),
     m_height(height),
-    m_headerSize(2 * sizeof(size_t)),
+    m_headerSize(2 * sizeof(int)),
     m_setColumns(0),
     m_autoClose(false),
     m_readyToReadColumn(-1)
 {
     Profiler profiler("MatrixFile::MatrixFile", true);

 #endif
 
     if (newFile) {
         initialise(); // write header and "unwritten" column tags
     } else {
-        size_t header[2];
-        if (::read(m_fd, header, 2 * sizeof(size_t)) < 0) {
+        int header[2];
+        if (::read(m_fd, header, 2 * sizeof(int)) < 0) {
             ::perror("MatrixFile::MatrixFile: read failed");
             cerr << "ERROR: MatrixFile::MatrixFile: "
                       << "Failed to read header (fd " << m_fd << ", file \""
                       << fileName << "\")" << endl;
             throw FileReadFailed(fileName);

     if (::lseek(m_fd, 0, SEEK_SET) < 0) {
         ::perror("ERROR: MatrixFile::initialise: Seek to write header failed");
         throw FileOperationFailed(m_fileName, "lseek");
     }
 
-    size_t header[2];
+    int header[2];
     header[0] = m_width;
     header[1] = m_height;
-    if (::write(m_fd, header, 2 * sizeof(size_t)) != 2 * sizeof(size_t)) {
+    if (::write(m_fd, header, 2 * sizeof(int)) != 2 * sizeof(int)) {
         ::perror("ERROR: MatrixFile::initialise: Failed to write header");
         throw FileOperationFailed(m_fileName, "write");
     }
 
     if (m_mode == WriteOnly) {

 #endif
     }
 }
 
 void
-MatrixFile::getColumnAt(size_t x, void *data)
+MatrixFile::getColumnAt(int x, void *data)
 {
     assert(m_mode == ReadOnly);
     
 #ifdef DEBUG_MATRIX_FILE_READ_SET
     cerr << "MatrixFile[" << m_fd << "]::getColumnAt(" << x << ")" << endl;

     Profiler profiler("MatrixFile::getColumnAt");
 
     ssize_t r = -1;
 
     if (m_readyToReadColumn < 0 ||
-        size_t(m_readyToReadColumn) != x) {
+        m_readyToReadColumn != x) {
 
         unsigned char set = 0;
         if (!seekTo(x)) {
             cerr << "ERROR: MatrixFile::getColumnAt(" << x << "): Seek failed" << endl;
             throw FileOperationFailed(m_fileName, "seek");

         throw FileReadFailed(m_fileName);
     }
 }
 
 bool
-MatrixFile::haveSetColumnAt(size_t x) const
+MatrixFile::haveSetColumnAt(int x) const
 {
     if (m_mode == WriteOnly) {
         return m_setColumns->get(x);
     }
 
     if (m_readyToReadColumn >= 0 &&
-        size_t(m_readyToReadColumn) == x) return true;
+        int(m_readyToReadColumn) == x) return true;
     
     Profiler profiler("MatrixFile::haveSetColumnAt");
 
 #ifdef DEBUG_MATRIX_FILE_READ_SET
     cerr << "MatrixFile[" << m_fd << "]::haveSetColumnAt(" << x << ")" << endl;

 
     return set;
 }
 
 void
-MatrixFile::setColumnAt(size_t x, const void *data)
+MatrixFile::setColumnAt(int x, const void *data)
 {
     assert(m_mode == WriteOnly);
     if (m_fd < 0) return; // closed
 
 #ifdef DEBUG_MATRIX_FILE_READ_SET

         }
     }
 }
 
 bool
-MatrixFile::seekTo(size_t x) const
+MatrixFile::seekTo(int x) const
 {
     if (m_fd < 0) {
         cerr << "ERROR: MatrixFile::seekTo: File not open" << endl;
         return false;
     }