1 /*-------------------------------------------------------------------------
2 * drawElements Stream Library
3 * ---------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Stream wrapper for deFile
22 *//*--------------------------------------------------------------------*/
23 #include "deFileStream.h"
24
25 #include <stdlib.h>
26
27 typedef struct FileStream_s
28 {
29 deFile *file;
30 deStreamStatus status;
31 const char *error;
32 } FileStream;
33
fileIOStream_read(deStreamData * stream,void * buf,int32_t bufSize,int32_t * numRead)34 static deStreamResult fileIOStream_read(deStreamData *stream, void *buf, int32_t bufSize, int32_t *numRead)
35 {
36 int64_t _numRead = 0;
37 FileStream *fileStream = (FileStream *)stream;
38
39 deFileResult result = deFile_read(fileStream->file, buf, bufSize, &_numRead);
40 *numRead = (int32_t)_numRead;
41
42 switch (result)
43 {
44 case DE_FILERESULT_SUCCESS:
45 return DE_STREAMRESULT_SUCCESS;
46
47 case DE_FILERESULT_ERROR:
48 fileStream->error = "deFile: DE_FILERESULT_ERROR";
49 fileStream->status = DE_STREAMSTATUS_ERROR;
50 return DE_STREAMRESULT_ERROR;
51
52 case DE_FILERESULT_END_OF_FILE:
53 return DE_STREAMRESULT_END_OF_STREAM;
54
55 default:
56 fileStream->error = "Uknown: DE_FILERESULT";
57 fileStream->status = DE_STREAMSTATUS_ERROR;
58 return DE_STREAMRESULT_ERROR;
59 }
60 }
61
fileIOStream_write(deStreamData * stream,const void * buf,int32_t bufSize,int32_t * numWritten)62 static deStreamResult fileIOStream_write(deStreamData *stream, const void *buf, int32_t bufSize, int32_t *numWritten)
63 {
64 int64_t _numWritten = 0;
65 FileStream *fileStream = (FileStream *)stream;
66
67 deFileResult result = deFile_write(fileStream->file, buf, bufSize, &_numWritten);
68 *numWritten = (int32_t)_numWritten;
69
70 switch (result)
71 {
72 case DE_FILERESULT_SUCCESS:
73 return DE_STREAMRESULT_SUCCESS;
74
75 case DE_FILERESULT_ERROR:
76 fileStream->error = "deFile: DE_FILERESULT_ERROR";
77 fileStream->status = DE_STREAMSTATUS_ERROR;
78 return DE_STREAMRESULT_ERROR;
79
80 case DE_FILERESULT_END_OF_FILE:
81 return DE_STREAMRESULT_END_OF_STREAM;
82
83 default:
84 fileStream->error = "Uknown: DE_FILERESULT";
85 fileStream->status = DE_STREAMSTATUS_ERROR;
86 return DE_STREAMRESULT_ERROR;
87 }
88 }
89
fileIOStream_getError(deStreamData * stream)90 static const char *fileIOStream_getError(deStreamData *stream)
91 {
92 FileStream *fileStream = (FileStream *)stream;
93 /* \note [mika] There is only error reporting through return value in deFile */
94 return fileStream->error;
95 }
96
fileIOStream_flush(deStreamData * stream)97 static deStreamResult fileIOStream_flush(deStreamData *stream)
98 {
99 /* \todo mika deFile doesn't have flush, how should this be handled? */
100 DE_UNREF(stream);
101
102 return DE_STREAMRESULT_SUCCESS;
103 }
104
fileIOStream_deinit(deStreamData * stream)105 static deStreamResult fileIOStream_deinit(deStreamData *stream)
106 {
107 FileStream *fileStream = (FileStream *)stream;
108
109 deFile_destroy(fileStream->file);
110
111 free(fileStream);
112
113 return DE_STREAMRESULT_SUCCESS;
114 }
115
fileIOStrem_getStatus(deStreamData * stream)116 static deStreamStatus fileIOStrem_getStatus(deStreamData *stream)
117 {
118 FileStream *fileStream = (FileStream *)stream;
119 return fileStream->status;
120 }
121
122 static const deIOStreamVFTable fileIOStreamVFTable = {fileIOStream_read, fileIOStream_write, fileIOStream_getError,
123 fileIOStream_flush, fileIOStream_deinit, fileIOStrem_getStatus};
124
125 static const deIOStreamVFTable fileInStreamVFTable = {
126 fileIOStream_read, DE_NULL, fileIOStream_getError, DE_NULL, fileIOStream_deinit, fileIOStrem_getStatus};
127
128 static const deIOStreamVFTable fileOutStreamVFTable = {
129 DE_NULL, fileIOStream_write, fileIOStream_getError, fileIOStream_flush, fileIOStream_deinit, fileIOStrem_getStatus};
130
fileIOStream_init(deIOStream * stream,const char * filename,deFileMode mode)131 void fileIOStream_init(deIOStream *stream, const char *filename, deFileMode mode)
132 {
133 FileStream *fileStream = DE_NULL;
134
135 DE_ASSERT(stream);
136
137 fileStream = malloc(sizeof(FileStream));
138
139 /* \note mika Check that file is readable and writeable, currently not supported by deFile */
140 stream->vfTable = &fileIOStreamVFTable;
141 stream->streamData = (deStreamData *)fileStream;
142
143 fileStream->file = deFile_create(filename, mode);
144 fileStream->status = DE_STREAMSTATUS_GOOD;
145 fileStream->error = DE_NULL;
146
147 if (!fileStream->file)
148 fileStream->status = DE_STREAMSTATUS_ERROR;
149 }
150
deFileInStream_init(deInStream * stream,const char * filename,deFileMode mode)151 void deFileInStream_init(deInStream *stream, const char *filename, deFileMode mode)
152 {
153 FileStream *fileStream = DE_NULL;
154
155 DE_ASSERT(stream);
156
157 fileStream = malloc(sizeof(FileStream));
158
159 /* \note mika Check that file is readable, currently not supported by deFile */
160 stream->ioStream.vfTable = &fileInStreamVFTable;
161 stream->ioStream.streamData = (deStreamData *)fileStream;
162
163 fileStream->file = deFile_create(filename, mode);
164 fileStream->status = DE_STREAMSTATUS_GOOD;
165 fileStream->error = DE_NULL;
166
167 if (!fileStream->file)
168 fileStream->status = DE_STREAMSTATUS_ERROR;
169 }
170
deFileOutStream_init(deOutStream * stream,const char * filename,deFileMode mode)171 void deFileOutStream_init(deOutStream *stream, const char *filename, deFileMode mode)
172 {
173 FileStream *fileStream = DE_NULL;
174
175 DE_ASSERT(stream);
176
177 fileStream = malloc(sizeof(FileStream));
178
179 /* \note mika Check that file is writeable, currently not supported by deFile */
180 stream->ioStream.vfTable = &fileOutStreamVFTable;
181 stream->ioStream.streamData = (deStreamData *)fileStream;
182
183 fileStream->file = deFile_create(filename, mode);
184 fileStream->status = DE_STREAMSTATUS_GOOD;
185 fileStream->error = DE_NULL;
186
187 if (!fileStream->file)
188 fileStream->status = DE_STREAMSTATUS_ERROR;
189 }
190