framework/delibs/destream/deFileStream.c

   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
  34 static deStreamResult fileIOStream_read (deStreamData* stream, void* buf, deInt32 bufSize, deInt32* numRead)
  35 {
  36         deInt64 _numRead = 0;
  37         FileStream* fileStream = (FileStream*)stream;
  38
  39
  40         deFileResult result = deFile_read(fileStream->file, buf, bufSize, &_numRead);
  41         *numRead = (deInt32)_numRead;
  42
  43         switch (result)
  44         {
  45                 case  DE_FILERESULT_SUCCESS:
  46                         return DE_STREAMRESULT_SUCCESS;
  47                         break;
  48
  49                 case DE_FILERESULT_ERROR:
  50                         fileStream->error       = "deFile: DE_FILERESULT_ERROR";
  51                         fileStream->status      = DE_STREAMSTATUS_ERROR;
  52                         return DE_STREAMRESULT_ERROR;
  53                         break;
  54
  55                 case DE_FILERESULT_END_OF_FILE:
  56                         return DE_STREAMRESULT_END_OF_STREAM;
  57                         break;
  58
  59                 default:
  60                         fileStream->error       = "Uknown: DE_FILERESULT";
  61                         fileStream->status      = DE_STREAMSTATUS_ERROR;
  62                         return DE_STREAMRESULT_ERROR;
  63                         break;
  64         };
  65 }
  66
  67 static deStreamResult fileIOStream_write (deStreamData* stream, const void* buf, deInt32 bufSize, deInt32* numWritten)
  68 {
  69         deInt64 _numWritten = 0;
  70         FileStream* fileStream = (FileStream*)stream;
  71
  72         deFileResult result = deFile_write(fileStream->file, buf, bufSize, &_numWritten);
  73         *numWritten = (deInt32)_numWritten;
  74
  75         switch (result)
  76         {
  77                 case  DE_FILERESULT_SUCCESS:
  78                         return DE_STREAMRESULT_SUCCESS;
  79                         break;
  80
  81                 case DE_FILERESULT_ERROR:
  82                         fileStream->error       = "deFile: DE_FILERESULT_ERROR";
  83                         fileStream->status      = DE_STREAMSTATUS_ERROR;
  84                         return DE_STREAMRESULT_ERROR;
  85                         break;
  86
  87                 case DE_FILERESULT_END_OF_FILE:
  88                         return DE_STREAMRESULT_END_OF_STREAM;
  89                         break;
  90
  91                 default:
  92                         fileStream->error       = "Uknown: DE_FILERESULT";
  93                         fileStream->status      = DE_STREAMSTATUS_ERROR;
  94                         return DE_STREAMRESULT_ERROR;
  95                         break;
  96         };
  97 }
  98
  99 static const char* fileIOStream_getError (deStreamData* stream)
 100 {
 101         FileStream* fileStream = (FileStream*)stream;
 102         /* \note [mika] There is only error reporting through return value in deFile */
 103         return fileStream->error;
 104 }
 105
 106 static deStreamResult fileIOStream_flush (deStreamData* stream)
 107 {
 108         /* \todo mika deFile doesn't have flush, how should this be handled? */
 109         DE_UNREF(stream);
 110
 111         return DE_STREAMRESULT_SUCCESS;
 112 }
 113
 114 static deStreamResult fileIOStream_deinit (deStreamData* stream)
 115 {
 116         FileStream* fileStream = (FileStream*)stream;
 117
 118         deFile_destroy(fileStream->file);
 119
 120         free(fileStream);
 121
 122         return DE_STREAMRESULT_SUCCESS;
 123 }
 124
 125 static deStreamStatus fileIOStrem_getStatus (deStreamData* stream)
 126 {
 127         FileStream* fileStream = (FileStream*)stream;
 128         return fileStream->status;
 129 }
 130
 131 static const deIOStreamVFTable fileIOStreamVFTable = {
 132         fileIOStream_read,
 133         fileIOStream_write,
 134         fileIOStream_getError,
 135         fileIOStream_flush,
 136         fileIOStream_deinit,
 137         fileIOStrem_getStatus
 138 };
 139
 140 static const deIOStreamVFTable fileInStreamVFTable = {
 141         fileIOStream_read,
 142         DE_NULL,
 143         fileIOStream_getError,
 144         DE_NULL,
 145         fileIOStream_deinit,
 146         fileIOStrem_getStatus
 147 };
 148
 149 static const deIOStreamVFTable fileOutStreamVFTable = {
 150         DE_NULL,
 151         fileIOStream_write,
 152         fileIOStream_getError,
 153         fileIOStream_flush,
 154         fileIOStream_deinit,
 155         fileIOStrem_getStatus
 156 };
 157
 158 void fileIOStream_init (deIOStream* stream, const char* filename, deFileMode mode)
 159 {
 160         FileStream* fileStream = DE_NULL;
 161
 162         DE_ASSERT(stream);
 163
 164         fileStream = malloc(sizeof(FileStream));
 165
 166         /* \note mika Check that file is readable and writeable, currently not supported by deFile */
 167         stream->vfTable         = &fileIOStreamVFTable;
 168         stream->streamData      = (deStreamData*)fileStream;
 169
 170         fileStream->file        = deFile_create(filename, mode);
 171         fileStream->status      = DE_STREAMSTATUS_GOOD;
 172         fileStream->error       = DE_NULL;
 173
 174         if (!fileStream->file)
 175                 fileStream->status = DE_STREAMSTATUS_ERROR;
 176 }
 177
 178 void deFileInStream_init (deInStream* stream, const char* filename, deFileMode mode)
 179 {
 180         FileStream* fileStream = DE_NULL;
 181
 182         DE_ASSERT(stream);
 183
 184         fileStream = malloc(sizeof(FileStream));
 185
 186         /* \note mika Check that file is readable, currently not supported by deFile */
 187         stream->ioStream.vfTable                = &fileInStreamVFTable;
 188         stream->ioStream.streamData             = (deStreamData*)fileStream;
 189
 190         fileStream->file        = deFile_create(filename, mode);
 191         fileStream->status      = DE_STREAMSTATUS_GOOD;
 192         fileStream->error       = DE_NULL;
 193
 194         if (!fileStream->file)
 195                 fileStream->status = DE_STREAMSTATUS_ERROR;
 196 }
 197
 198 void deFileOutStream_init (deOutStream* stream, const char* filename, deFileMode mode)
 199 {
 200         FileStream* fileStream = DE_NULL;
 201
 202         DE_ASSERT(stream);
 203
 204         fileStream = malloc(sizeof(FileStream));
 205
 206         /* \note mika Check that file is writeable, currently not supported by deFile */
 207         stream->ioStream.vfTable                = &fileOutStreamVFTable;
 208         stream->ioStream.streamData             = (deStreamData*)fileStream;
 209
 210         fileStream->file        = deFile_create(filename, mode);
 211         fileStream->status      = DE_STREAMSTATUS_GOOD;
 212         fileStream->error       = DE_NULL;
 213
 214         if (!fileStream->file)
 215                 fileStream->status = DE_STREAMSTATUS_ERROR;;
 216 }