← Back to branch summary

~haggai-eran/nux/rtl-rebased

« back to all changes in this revision

Viewing changes to NuxCore/FileManager/NFileManagerGNU.cpp

  • Committer: Jay Taoko
  • Date: 2011-10-21 23:49:15 UTC
  • mfrom: (508.1.2 nux-20)
  • Revision ID: jay.taoko@canonical.com-20111021234915-hnzakb5ndebica8i
* Removed custom Nux types: t_u32, t_s32, t_bool, ...

Show diffs side-by-side

added added

removed removed

Lines of Context:
NuxCore/FileManager/NFileManagerGNU.cpp
26
26
{
27
27
 
28
28
// Choose the size so it is a power of 2. Example (size-1)= 11111111.
29
 
  const t_int  NGNUSerialFileReader::sBufferSize = 1024;
 
29
  const int  NGNUSerialFileReader::sBufferSize = 1024;
30
30
 
31
 
  NGNUSerialFileReader::NGNUSerialFileReader (t_int InFileDescriptor, LogOutputDevice &InError, t_int InSize)
 
31
  NGNUSerialFileReader::NGNUSerialFileReader (int InFileDescriptor, LogOutputDevice &InError, int InSize)
32
32
    :   m_FileDescriptor    (InFileDescriptor)
33
33
    ,   m_Error             (InError)
34
34
    ,   m_FileSize          (InSize)
48
48
    }
49
49
  }
50
50
 
51
 
  bool NGNUSerialFileReader::Precache (t_int PrecacheOffset, t_int PrecacheSize)
 
51
  bool NGNUSerialFileReader::Precache (int PrecacheOffset, int PrecacheSize)
52
52
  {
53
53
    // Only pre-cache at current position and avoid work if pre-caching same offset twice.
54
54
    if ( (m_FilePos == PrecacheOffset) && (!m_BufferBase || !m_BufferCount || m_BufferBase != m_FilePos) )
56
56
      m_BufferBase = m_FilePos;
57
57
      // (sBufferSize - 1) contains only '1', i.e 1111111111.
58
58
      // So (m_FilePos & (sBufferSize-1)) is equal to m_FilePos if m_FilePos <= (sBufferSize-1).
59
 
      m_BufferCount = Min<t_s64> (Min<t_s64> (PrecacheSize, (t_int) (sBufferSize - (m_FilePos & (sBufferSize - 1) ) ) ), m_FileSize - m_FilePos);
60
 
      t_s64 Count = 0;
 
59
      m_BufferCount = Min<long long> (Min<long long> (PrecacheSize, (int) (sBufferSize - (m_FilePos & (sBufferSize - 1) ) ) ), m_FileSize - m_FilePos);
 
60
      long long Count = 0;
61
61
      //GTotalBytesReadViaFileManager += m_BufferCount;
62
62
      Count = read (m_FileDescriptor, m_Buffer, m_BufferCount);
63
63
 
77
77
    return TRUE;
78
78
  }
79
79
 
80
 
  t_s64 NGNUSerialFileReader::Seek (t_s64 InPos, NSerializer::SeekPos seekpos)
 
80
  long long NGNUSerialFileReader::Seek (long long InPos, NSerializer::SeekPos seekpos)
81
81
  {
82
82
    nuxAssert (InPos >= 0);
83
83
    nuxAssert (InPos <= m_FileSize);
85
85
    Flush();
86
86
    // Because we precache our reads, we must perform Seek accordingly.
87
87
 
88
 
    t_s64 pos = m_FilePos;
89
 
    t_s64 filepos = 0;
 
88
    long long pos = m_FilePos;
 
89
    long long filepos = 0;
90
90
 
91
91
    // Set the file pointer to m_FilePos.
92
92
    filepos = lseek (m_FileDescriptor, pos, SEEK_SET);
114
114
    return filepos;
115
115
  }
116
116
 
117
 
  t_s64 NGNUSerialFileReader::Tell()
 
117
  long long NGNUSerialFileReader::Tell()
118
118
  {
119
119
    //     Flush();
120
120
    //     LARGE_INTEGER pos;
126
126
    return m_FilePos;
127
127
  }
128
128
 
129
 
  t_s64 NGNUSerialFileReader::GetFileSize()
 
129
  long long NGNUSerialFileReader::GetFileSize()
130
130
  {
131
131
    return m_FileSize;
132
132
  }
148
148
    return !m_ErrorCode;
149
149
  }
150
150
 
151
 
  void NGNUSerialFileReader::SerializeFinal (void *Dest, t_s64 Length)
 
151
  void NGNUSerialFileReader::SerializeFinal (void *Dest, long long Length)
152
152
  {
153
153
    nuxAssert (Dest);
154
154
 
155
155
    while (Length > 0)
156
156
    {
157
 
      t_int DataSize = Min<t_s64> (Length, m_BufferBase + m_BufferCount - m_FilePos);
 
157
      int DataSize = Min<long long> (Length, m_BufferBase + m_BufferCount - m_FilePos);
158
158
 
159
159
      if (DataSize == 0)
160
160
      {
161
161
        if (Length >= sBufferSize)
162
162
        {
163
 
          t_s64 Count = 0;
 
163
          long long Count = 0;
164
164
          //GTotalBytesReadViaFileManager += Length;
165
165
          Count = read (m_FileDescriptor, Dest, Length);
166
166
 
182
182
        }
183
183
 
184
184
        Precache (m_FilePos, t_s32_max);
185
 
        DataSize = Min<t_s64> (Length, m_BufferBase + m_BufferCount - m_FilePos);
 
185
        DataSize = Min<long long> (Length, m_BufferBase + m_BufferCount - m_FilePos);
186
186
 
187
187
        if (DataSize <= 0)
188
188
        {
202
202
  }
203
203
//////////////////////////////////////////////////////////////////////////
204
204
// Choose the size so it is a power of 2. Example (size-1)= 11111111.
205
 
  const t_int  NGNUSerialFileWriter::sBufferSize = 32;
 
205
  const int  NGNUSerialFileWriter::sBufferSize = 32;
206
206
 
207
 
  NGNUSerialFileWriter::NGNUSerialFileWriter (t_int InFileDescriptor, LogOutputDevice &InError, t_int InPos)
 
207
  NGNUSerialFileWriter::NGNUSerialFileWriter (int InFileDescriptor, LogOutputDevice &InError, int InPos)
208
208
    :   m_FileDescriptor (InFileDescriptor)
209
209
    ,   m_Error         (InError)
210
210
    ,   m_BufferCount   (0)
223
223
    m_FileDescriptor = 0;
224
224
  }
225
225
 
226
 
  t_s64 NGNUSerialFileWriter::Seek (t_s64 InPos, NSerializer::SeekPos seekpos)
 
226
  long long NGNUSerialFileWriter::Seek (long long InPos, NSerializer::SeekPos seekpos)
227
227
  {
228
228
    NScopeLock Scope (&m_CriticalSection);
229
229
    nuxAssert (m_FileDescriptor);
232
232
      return -1;
233
233
 
234
234
    _Flush();
235
 
    t_s64 pos = InPos;
236
 
    t_s64 filepos = 0;
 
235
    long long pos = InPos;
 
236
    long long filepos = 0;
237
237
    filepos = lseek (m_FileDescriptor, pos, (seekpos == SeekStart) ? SEEK_SET : (seekpos == SeekCurrent) ? SEEK_CUR : SEEK_END);
238
238
 
239
239
    if (filepos == -1)
246
246
    return filepos;
247
247
  }
248
248
 
249
 
  t_s64 NGNUSerialFileWriter::Tell()
 
249
  long long NGNUSerialFileWriter::Tell()
250
250
  {
251
251
    NScopeLock Scope (&m_CriticalSection);
252
252
    nuxAssert (m_FileDescriptor);
255
255
      return -1;
256
256
 
257
257
    _Flush();
258
 
    t_s64 pos = 0;
259
 
    t_s64 filepos = 0;
 
258
    long long pos = 0;
 
259
    long long filepos = 0;
260
260
    filepos = lseek (m_FileDescriptor, pos, SEEK_CUR);
261
261
 
262
262
    if (filepos == -1)
289
289
    return !m_ErrorCode;
290
290
  }
291
291
 
292
 
  t_s64 NGNUSerialFileWriter::GetFileSize()
 
292
  long long NGNUSerialFileWriter::GetFileSize()
293
293
  {
294
294
    NScopeLock Scope (&m_CriticalSection);
295
295
    nuxAssert (m_FileDescriptor);
308
308
    return sb.st_size;
309
309
  }
310
310
 
311
 
  void NGNUSerialFileWriter::SerializeFinal (void *V, t_s64 Length)
 
311
  void NGNUSerialFileWriter::SerializeFinal (void *V, long long Length)
312
312
  {
313
313
    // This method is not re-entrant by itself. It relies on m_Buffer and other variables
314
314
    // that belong to this object. Therefore, it is not thread safe. We add a critical section
321
321
    NUX_RETURN_IF_NULL (m_FileDescriptor);
322
322
 
323
323
    m_Pos += Length;
324
 
    t_int FreeSpace;
 
324
    int FreeSpace;
325
325
 
326
326
    while (Length > (FreeSpace = sBufferSize - m_BufferCount) )
327
327
    {
356
356
    //GTotalBytesWrittenViaFileManager += m_BufferCount;
357
357
    if (m_BufferCount)
358
358
    {
359
 
      t_s64 Result = 0;
 
359
      long long Result = 0;
360
360
      Result = write (m_FileDescriptor, m_Buffer, m_BufferCount);
361
361
 
362
362
      if (Result == -1)
381
381
 
382
382
  NSerializer *NFileManagerGNU::CreateFileReader (const TCHAR *Filename, DWORD Flags, LogOutputDevice &Error)
383
383
  {
384
 
    t_int FileDesc = open (TCHAR_TO_ANSI (Filename), O_RDONLY);
 
384
    int FileDesc = open (TCHAR_TO_ANSI (Filename), O_RDONLY);
385
385
 
386
386
    if (FileDesc == -1)
387
387
    {
446
446
    ModeFlags |= (Flags & NSerializer::Append) ? O_APPEND : O_TRUNC;
447
447
    ModeFlags |= (Flags & NSerializer::NoOverWrite) ? (O_CREAT | O_EXCL) /*fail if the file already exist*/ : O_CREAT /*create the file if it does not exist*/;
448
448
 
449
 
    t_int FileDesc = open (TCHAR_TO_ANSI (Filename), ModeFlags, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 
449
    int FileDesc = open (TCHAR_TO_ANSI (Filename), ModeFlags, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
450
450
 
451
451
    if (FileDesc == -1)
452
452
    {
458
458
      return NULL;
459
459
    }
460
460
 
461
 
    t_s64 Pos = 0;
 
461
    long long Pos = 0;
462
462
 
463
463
    if (Flags & NSerializer::Append)
464
464
    {
489
489
    return new NGNUSerialFileWriter (FileDesc, Error, 0);
490
490
  }
491
491
 
492
 
  t_s64 NFileManagerGNU::FileSize (const TCHAR *Filename)
 
492
  long long NFileManagerGNU::FileSize (const TCHAR *Filename)
493
493
  {
494
494
    struct stat sb;
495
495
 
634
634
  /*!
635
635
      @return TRUE is the file exist.
636
636
  */
637
 
  bool NFileManagerGNU::GetFileAttribute (const TCHAR *Filename, bool &isDirectory, bool &isReadOnly, bool &isHidden, t_s64 &Size)
 
637
  bool NFileManagerGNU::GetFileAttribute (const TCHAR *Filename, bool &isDirectory, bool &isReadOnly, bool &isHidden, long long &Size)
638
638
  {
639
639
    isDirectory = false;
640
640
    isReadOnly = false;