]> git.tdb.fi Git - libs/core.git/blob - source/io/file.cpp
Disallow closing stuff before destruction
[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         signal_flush_required.emit();
90         sys_close(handle);
91         signal_closed.emit();
92 }
93
94 void File::set_block(bool b)
95 {
96         check_access(M_NONE);
97
98         mode = (mode&~M_NONBLOCK);
99         if(b)
100                 mode = (mode|M_NONBLOCK);
101 #ifndef WIN32
102         int flags = fcntl(*handle, F_GETFD);
103         fcntl(*handle, F_SETFL, (flags&O_NONBLOCK)|(b?0:O_NONBLOCK));
104 #endif
105 }
106
107 unsigned File::do_write(const char *buf, unsigned size)
108 {
109         check_access(M_WRITE);
110
111         if(size==0)
112                 return 0;
113
114 #ifdef WIN32
115         if(mode&M_APPEND)
116                 seek(0, S_END);
117 #endif
118
119         return sys_write(handle, buf, size);
120 }
121
122 unsigned File::do_read(char *buf, unsigned size)
123 {
124         check_access(M_READ);
125
126         if(size==0)
127                 return 0;
128
129         unsigned ret = sys_read(handle, buf, size);
130         if(ret==0)
131         {
132                 eof_flag = true;
133                 signal_end_of_file.emit();
134         }
135
136         return ret;
137 }
138
139 void File::sync()
140 {
141 #ifndef WIN32
142         signal_flush_required.emit();
143
144         fsync(*handle);
145 #endif
146 }
147
148 SeekOffset File::seek(SeekOffset off, SeekType type)
149 {
150         check_access(M_NONE);
151
152         signal_flush_required.emit();
153         off = sys_seek(handle, off, type);
154         eof_flag = false;
155
156         return off;
157 }
158
159 SeekOffset File::tell() const
160 {
161         check_access(M_NONE);
162
163         return sys_seek(const_cast<Handle &>(handle), 0, S_CUR);
164 }
165
166 void File::check_access(Mode m) const
167 {
168         if(!handle || (m && !(mode&m)))
169                 throw invalid_access(m);
170 }
171
172 } // namespace IO
173 } // namespace Msp