← Back to branch summary

~hikiko/nux/arb-srgba-shader

« back to all changes in this revision

Viewing changes to NuxCore/FileManager/NFileManagerStandardAnsi.h

  • Committer: Neil Jagdish Patel
  • Date: 2010-09-01 19:25:37 UTC
  • Revision ID: neil.patel@canonical.com-20100901192537-mfz7rm6q262pewg6
Import and build NuxCore

Show diffs side-by-side

added added

removed removed

Lines of Context:
NuxCore/FileManager/NFileManagerStandardAnsi.h
 
1
#ifndef NFILEMANAGERSTANDARDANSI_H
 
2
#define NFILEMANAGERSTANDARDANSI_H
 
3
 
 
4
/*-----------------------------------------------------------------------------
 
5
File Manager.
 
6
-----------------------------------------------------------------------------*/
 
7
NAMESPACE_BEGIN
 
8
// File manager.
 
9
class NSerializeFileReader : public NSerializer
 
10
{
 
11
public:
 
12
    NSerializeFileReader(FILE* InFile, NOutputDevice* InError, t_int InSize);
 
13
    ~NSerializeFileReader();
 
14
 
 
15
    virtual bool Precache(t_int PrecacheOffset, t_int PrecacheSize);
 
16
    virtual t_s64 Seek(t_s64 InPos, NSerializer::SeekPos seekpos);
 
17
    virtual t_s64 Tell();
 
18
    virtual t_s64 GetFileSize();
 
19
    virtual bool Close();
 
20
    virtual void SerializeFinal(void* Dest, t_u64 Length);
 
21
    virtual bool isReader() {return true;}
 
22
    virtual bool isWriter() {return false;}
 
23
 
 
24
protected:
 
25
    FILE*                       m_File;
 
26
    NOutputDevice*      m_Error;
 
27
    t_int                               m_FileSize;
 
28
    t_int                               m_FilePos;
 
29
    t_int                               BufferBase;
 
30
    t_int                               BufferCount;
 
31
    BYTE*               m_PreCacheBuffer;
 
32
    static const t_int  sBufferSize;
 
33
};
 
34
 
 
35
class NSerializeFileWriter : public NSerializer
 
36
{
 
37
public:
 
38
    NSerializeFileWriter(FILE* InFile, NOutputDevice* InError);
 
39
    ~NSerializeFileWriter();
 
40
 
 
41
    virtual t_s64 Seek(t_s64 InPos, NSerializer::SeekPos seekpos);
 
42
    virtual t_s64 Tell();
 
43
    virtual t_s64 GetFileSize();
 
44
    virtual bool Close();
 
45
    virtual void SerializeFinal(void* Src, t_u64 Length);
 
46
    virtual void Flush();
 
47
    virtual bool isReader() {return false;}
 
48
    virtual bool isWriter() {return true;}
 
49
 
 
50
protected:
 
51
    FILE*               m_File;
 
52
    NOutputDevice*      m_Error;
 
53
    t_int               m_FilePos;
 
54
    t_int               m_CachePos;
 
55
    BYTE*               m_CacheBuffer;
 
56
    static const t_int  sBufferSize;
 
57
};
 
58
 
 
59
class NFileManagerAnsi : public NFileManagerGeneric
 
60
{
 
61
public:
 
62
    NSerializer* CreateFileReader(const TCHAR* Filename, DWORD Flags, NOutputDevice* Error)
 
63
    {
 
64
        FILE* File;
 
65
        #ifdef WIN32_SECURE
 
66
            ::_tfopen_s(&File, Filename,TEXT("rb"));
 
67
        #else
 
68
            File = ::fopen(Filename,TEXT("rb"));
 
69
        #endif
 
70
        if(!File)
 
71
        {
 
72
            if(Flags & NSerializer::OutputErrorIfFail)
 
73
            {
 
74
                nuxError(TEXT("Failed to read file: %s"), Filename);
 
75
            }
 
76
            return NULL;
 
77
        }
 
78
        ::fseek(File, 0, SEEK_END);
 
79
        return new NSerializeFileReader(File, Error, ftell(File));
 
80
    }
 
81
 
 
82
    NSerializer* CreateFileWriter(const TCHAR* Filename, DWORD Flags, NOutputDevice* Error)
 
83
    {
 
84
        if(!FileExist(Filename))
 
85
            return NULL;
 
86
 
 
87
        if(Flags & NSerializer::NoOverWrite)
 
88
        {
 
89
            return NULL;
 
90
        }
 
91
 
 
92
        if(Flags & NSerializer::OverWriteReadOnly)
 
93
        {
 
94
            ::_chmod(Filename, _S_IREAD | _S_IWRITE);
 
95
        }
 
96
 
 
97
        const TCHAR* Mode = (Flags & NSerializer::Append) ? TEXT("ab") : TEXT("wb"); 
 
98
        FILE* File;
 
99
        #ifdef WIN32_SECURE
 
100
            ::_tfopen_s(&File, Filename, Mode);
 
101
        #else
 
102
            File = ::fopen(Filename, Mode);
 
103
        #endif
 
104
        if(!File)
 
105
        {
 
106
            if(Flags & NSerializer::OutputErrorIfFail)
 
107
            {
 
108
                nuxError(TEXT("Failed to write: %s"), Filename);
 
109
            }
 
110
            return NULL;
 
111
        }
 
112
        if(Flags & NSerializer::Append)
 
113
        {
 
114
            ::fseek(File, 0, SEEK_END);
 
115
        }
 
116
//         if(Flags & NSerializer::Unbuffered)
 
117
//         {
 
118
//             ::setvbuf(File, 0, _IONBF, 0);
 
119
//         }
 
120
        return new NSerializeFileWriter(File, Error);
 
121
    }
 
122
 
 
123
    bool Delete(const TCHAR* Filename, bool OverWriteReadOnly = false)
 
124
    {
 
125
        if(OverWriteReadOnly)
 
126
            _chmod(Filename, _S_IREAD | _S_IWRITE);
 
127
        return (_unlink(Filename) == 0) || (errno == ENOENT);
 
128
    }
 
129
 
 
130
    bool FileExist(const TCHAR* Filename)
 
131
    {
 
132
        return ::_access(TCHAR_TO_ANSI(Filename), 00) == 0;
 
133
    }
 
134
 
 
135
    bool IsDirectory(const TCHAR* DirectoryName)
 
136
    {
 
137
        struct _stat FileInfo;
 
138
        if(_stat(TCHAR_TO_ANSI(DirectoryName), &FileInfo))
 
139
        {
 
140
            if(FileInfo.st_mode & _S_IFDIR)
 
141
                return TRUE;
 
142
        }
 
143
        return FALSE;
 
144
    }
 
145
 
 
146
    bool IsReadOnly(const TCHAR* Filename)
 
147
    {
 
148
        return ::_access(TCHAR_TO_ANSI(Filename), 04) == 0;
 
149
    }
 
150
 
 
151
    bool MakeDirectory(const TCHAR* Path, bool CreateCompletePath = false)
 
152
    {
 
153
        if(CreateCompletePath)
 
154
        {
 
155
            return NFileManagerGeneric::MakeDirectory(Path, CreateCompletePath);
 
156
        }
 
157
        if((::_mkdir(TCHAR_TO_ANSI(Path)) != 0) && (errno != EEXIST))
 
158
        {
 
159
            nuxDebugMsg(TEXT("[NFileManagerAnsi::MakeDirectory] Error creating directory"));
 
160
            return INL_ERROR;
 
161
        }
 
162
        return INL_OK;
 
163
    }
 
164
 
 
165
    bool DeleteDirectory(const TCHAR* Path, bool DeleteContentFirst = false)
 
166
    {
 
167
        if(DeleteContentFirst)
 
168
        {
 
169
            return NFileManagerGeneric::DeleteDirectory(Path, DeleteContentFirst);
 
170
        }
 
171
        if((::_rmdir(TCHAR_TO_ANSI(Path)) != 0) && (errno != EEXIST))
 
172
        {
 
173
            nuxDebugMsg(TEXT("[NFileManagerAnsi::DeleteDirectory] Error deleting directory"));
 
174
            return INL_ERROR;
 
175
        }
 
176
        return INL_OK;
 
177
    }
 
178
 
 
179
    void FindFiles(std::vector<NString>& Result, const TCHAR* Filename, bool Files, bool Directories)
 
180
    {
 
181
        _finddata_t Found;
 
182
        long Handle = ::_findfirst(TCHAR_TO_ANSI(Filename), &Found);
 
183
        if(Handle != -1)
 
184
        {
 
185
            do
 
186
            {
 
187
                const TCHAR* Name = ANSI_TO_TCHAR(Found.name);
 
188
                if(TCharStringCompare(ANSI_TO_TCHAR(Found.name), TEXT(".")) &&
 
189
                    TCharStringCompare(ANSI_TO_TCHAR(Found.name), TEXT("..")) &&
 
190
                    !(Found.attrib & _A_SYSTEM) &&
 
191
                    !(Found.attrib & _A_HIDDEN))
 
192
                {
 
193
                    if((Found.attrib & _A_SUBDIR) ? Directories : Files)
 
194
                        Result.push_back(NString(Name));
 
195
                }
 
196
            }
 
197
            while(::_findnext(Handle, &Found) != -1);
 
198
        }
 
199
        ::_findclose(Handle);
 
200
    }
 
201
 
 
202
    void ListFilesInDirectory(std::vector<NString>& Result, const TCHAR* DirName)
 
203
    {
 
204
 
 
205
    }
 
206
 
 
207
    double GetFileAgeSeconds(const TCHAR* Filename)
 
208
    {
 
209
        struct stat FileInfo;
 
210
        if(stat(TCHAR_TO_ANSI(Filename), &FileInfo))
 
211
        {
 
212
            time_t      CurrentTime, FileTime;  
 
213
            FileTime = FileInfo.st_mtime;
 
214
            time(&CurrentTime);
 
215
 
 
216
            return ::difftime(CurrentTime, FileTime);
 
217
        }
 
218
        return -1.0;
 
219
    }
 
220
 
 
221
    time_t GetFileLastModified(const TCHAR* Filename)
 
222
    {
 
223
        struct stat FileInfo;
 
224
        if(stat(TCHAR_TO_ANSI(Filename), &FileInfo))
 
225
        {
 
226
            time_t FileTime;    
 
227
            FileTime = FileInfo.st_mtime;
 
228
 
 
229
            return FileTime;
 
230
        }
 
231
        return -1;
 
232
    }
 
233
 
 
234
    bool SetDefaultDirectory()
 
235
    {
 
236
        #ifdef WIN32_SECURE
 
237
            return _tchdir(GetProgramDirectory().GetTCharPtr()) == 0;
 
238
        #else
 
239
            // chdir has been deprecated in Visual 2005 for _chdir.
 
240
            return ::chdir(TCHAR_TO_ANSI(GetProgramDirectory())) == 0;
 
241
        #endif
 
242
    }
 
243
 
 
244
    NString GetCurrentDirectory()
 
245
    {
 
246
        char Buffer[1024]= "";
 
247
        ::_tgetcwd(Buffer, INL_ARRAY_COUNT(Buffer));
 
248
        return NString(Buffer);
 
249
    }
 
250
 
 
251
    bool GetTimeStamp(const TCHAR* Filename, FileTimeStamp& Timestamp)
 
252
    {
 
253
        Memzero(&Timestamp, sizeof(Timestamp));
 
254
 
 
255
#if (defined INL_VISUAL_STUDIO_2005) || (defined INL_VISUAL_STUDIO_2008)
 
256
        struct __stat64 FileInfo;
 
257
        if(_tstat64(Filename, &FileInfo) == 0)
 
258
        {
 
259
            time_t      FileTime;       
 
260
            FileTime = FileInfo.st_mtime;
 
261
            tm* pTime = 0;
 
262
            ::_gmtime64_s(pTime, &FileTime);
 
263
 
 
264
            Timestamp.Day       = pTime->tm_mday;
 
265
            Timestamp.DayOfWeek = pTime->tm_wday;
 
266
            Timestamp.DayOfYear = pTime->tm_yday;
 
267
            Timestamp.Hour      = pTime->tm_hour;
 
268
            Timestamp.Minute    = pTime->tm_min;
 
269
            Timestamp.Second    = pTime->tm_sec;
 
270
            Timestamp.Year      = pTime->tm_year + 1900;
 
271
            return TRUE;
 
272
        }
 
273
#else
 
274
        struct stat FileInfo;
 
275
        if(stat(Filename, &FileInfo) == 0)
 
276
        {
 
277
            time_t      FileTime;       
 
278
            FileTime = FileInfo.st_mtime;
 
279
            tm* pTime = ::gmtime(&FileTime);
 
280
 
 
281
            Timestamp.Day       = pTime->tm_mday;
 
282
            Timestamp.DayOfWeek = pTime->tm_wday;
 
283
            Timestamp.DayOfYear = pTime->tm_yday;
 
284
            Timestamp.Hour      = pTime->tm_hour;
 
285
            Timestamp.Minute    = pTime->tm_min;
 
286
            Timestamp.Second    = pTime->tm_sec;
 
287
            Timestamp.Year      = pTime->tm_year + 1900;
 
288
            return TRUE;
 
289
        }
 
290
#endif
 
291
        return FALSE;
 
292
    }
 
293
};
 
294
 
 
295
NAMESPACE_END
 
296
 
 
297
#endif // NFILEMANAGERSTANDARDANSI_H