]> git.tdb.fi Git - libs/core.git/blob - source/io/file.cpp
Move some common operations to helper functions
[libs/core.git] / source / io / file.cpp
1 #ifndef WIN32
2 #include <errno.h>
3 #include <fcntl.h>
4 #include <unistd.h>
5 #endif
6 #include <msp/strings/format.h>
7 #include <msp/core/systemerror.h>
8 #include "file.h"
9 #include "handle_private.h"
10
11 using namespace std;
12
13 namespace Msp {
14 namespace IO {
15
16 File::File(const string &fn, Mode m, CreateMode cm)
17 {
18         if(!(m&M_RDWR))
19                 throw invalid_argument("File::File mode");
20         if(cm&~(C_CREATE|C_TRUNCATE))
21                 throw invalid_argument("File::File create");
22
23         mode = m;
24
25 #ifdef WIN32
26         int flags = 0;
27         int create_flags = OPEN_EXISTING;
28
29         if(mode&M_READ)
30                 flags |= GENERIC_READ;
31         else if(mode&M_WRITE)
32         {
33                 flags |= GENERIC_WRITE;
34
35                 switch(static_cast<int>(cm))
36                 {
37                 case C_NONE:     create_flags = OPEN_EXISTING; break;
38                 case C_CREATE:   create_flags = OPEN_ALWAYS; break;
39                 case C_TRUNCATE: create_flags = TRUNCATE_EXISTING; break;
40                 case C_CREATE+C_TRUNCATE: create_flags = CREATE_ALWAYS; break;
41                 }
42         }
43
44         *handle = CreateFile(fn.c_str(), flags, 0, 0, create_flags, FILE_ATTRIBUTE_NORMAL, 0);
45         if(!handle)
46         {
47                 int err = GetLastError();
48                 if(err==ERROR_FILE_NOT_FOUND)
49                         throw file_not_found(fn);
50                 else
51                         throw system_error(format("CreateFile(%s)", fn), err);
52         }
53 #else
54         int flags = 0;
55         switch(mode&M_RDWR)
56         {
57         case M_READ:  flags |= O_RDONLY; break;
58         case M_WRITE: flags |= O_WRONLY; break;
59         case M_RDWR:  flags |= O_RDWR; break;
60         default:;
61         }
62
63         if(mode&M_WRITE)
64         {
65                 if(cm&C_CREATE)
66                         flags |= O_CREAT;
67                 if(cm&C_TRUNCATE)
68                         flags |= O_TRUNC;
69         }
70         if(mode&M_APPEND)
71                 flags |= O_APPEND;
72         if(mode&M_NONBLOCK)
73                 flags |= O_NONBLOCK;
74
75         *handle = ::open(fn.c_str(), flags, 0666);
76         if(!handle)
77         {
78                 int err = errno;
79                 if(err==ENOENT)
80                         throw file_not_found(fn);
81                 else
82                         throw system_error(format("open(%s)", fn), err);
83         }
84 #endif
85 }
86
87 File::~File()
88 {
89         close();
90 }
91
92 void File::close()
93 {
94         if(!handle)
95                 return;
96
97         signal_flush_required.emit();
98
99         sys_close(handle);
100
101         handle = Handle();
102         signal_closed.emit();
103 }
104
105 void File::set_block(bool b)
106 {
107         check_access(M_NONE);
108
109         mode = (mode&~M_NONBLOCK);
110         if(b)
111                 mode = (mode|M_NONBLOCK);
112 #ifndef WIN32
113         int flags = fcntl(*handle, F_GETFD);
114         fcntl(*handle, F_SETFL, (flags&O_NONBLOCK)|(b?0:O_NONBLOCK));
115 #endif
116 }
117
118 unsigned File::do_write(const char *buf, unsigned size)
119 {
120         check_access(M_WRITE);
121
122         if(size==0)
123                 return 0;
124
125 #ifdef WIN32
126         if(mode&M_APPEND)
127                 seek(0, S_END);
128 #endif
129
130         return sys_write(handle, buf, size);
131 }
132
133 unsigned File::do_read(char *buf, unsigned size)
134 {
135         check_access(M_READ);
136
137         if(size==0)
138                 return 0;
139
140         unsigned ret = sys_read(handle, buf, size);
141         if(ret==0)
142         {
143                 eof_flag = true;
144                 signal_end_of_file.emit();
145         }
146
147         return ret;
148 }
149
150 void File::sync()
151 {
152 #ifndef WIN32
153         signal_flush_required.emit();
154
155         fsync(*handle);
156 #endif
157 }
158
159 unsigned File::seek(int off, SeekType st)
160 {
161         check_access(M_NONE);
162
163         signal_flush_required.emit();
164
165         int type = sys_seek_type(st);
166 #ifdef WIN32
167         DWORD ret = SetFilePointer(*handle, off, 0, type);
168         if(ret==INVALID_SET_FILE_POINTER)
169                 throw system_error("SetFilePointer");
170 #else
171         off_t ret = lseek(*handle, off, type);
172         if(ret==(off_t)-1)
173                 throw system_error("lseek");
174 #endif
175
176         eof_flag = false;
177
178         return ret;
179 }
180
181 unsigned File::tell() const
182 {
183         check_access(M_NONE);
184
185 #ifdef WIN32
186         DWORD ret = SetFilePointer(*handle, 0, 0, FILE_CURRENT);
187         if(ret==INVALID_SET_FILE_POINTER)
188                 throw system_error("SetFilePointer");
189 #else
190         off_t ret = lseek(*handle, 0, SEEK_CUR);
191         if(ret==(off_t)-1)
192                 throw system_error("lseek");
193 #endif
194
195         return ret;
196 }
197
198 void File::check_access(Mode m) const
199 {
200         if(!handle || (m && !(mode&m)))
201                 throw invalid_access(m);
202 }
203
204 } // namespace IO
205 } // namespace Msp