SeqAn-1.1/seqan/file/file_format_raw.h

   1  /*==========================================================================
   2                 SeqAn - The Library for Sequence Analysis
   3                           http://www.seqan.de
   4  ============================================================================
   5   Copyright (C) 2007
   6
   7   This library is free software; you can redistribute it and/or
   8   modify it under the terms of the GNU Lesser General Public
   9   License as published by the Free Software Foundation; either
  10   version 3 of the License, or (at your option) any later version.
  11
  12   This library is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17  ============================================================================
  18   $Id: file_format_raw.h,v 1.1 2008/08/25 16:20:03 langmead Exp $
  19  ==========================================================================*/
  20
  21 #ifndef SEQAN_HEADER_FILE_RAW_H
  22 #define SEQAN_HEADER_FILE_RAW_H
  23
  24 namespace SEQAN_NAMESPACE_MAIN
  25 {
  26
  27 //////////////////////////////////////////////////////////////////////////////
  28 // File Formats - Raw
  29 //////////////////////////////////////////////////////////////////////////////
  30 /**
  31 .Tag.File Format.tag.Raw:
  32         The file contains data in a raw format.
  33 ..remark:It is supposed that the file contains one single piece of data,
  34 that is the file cannot store multiple records.
  35 */
  36
  37 struct TagRaw_;
  38 typedef Tag<TagRaw_> const Raw;
  39
  40
  41
  42 //////////////////////////////////////////////////////////////////////////////
  43 // read
  44 //////////////////////////////////////////////////////////////////////////////
  45
  46 template <typename TFile, typename TData, typename TTag>
  47 struct _Read_Raw;
  48
  49 //____________________________________________________________________________
  50
  51 template <typename TFile, typename TData>
  52 struct _Read_Raw<TFile, TData, True>
  53 {
  54         static void
  55         read_(TFile & file,
  56                 TData & data)
  57         {
  58 SEQAN_CHECKPOINT
  59                 SEQAN_ASSERT(!_streamEOF(file))
  60
  61                 //determine length
  62                 typename Position<TFile>::Type begin_pos = _streamTellG(file);
  63                 typename Size<TData>::Type count = 0;
  64                 typename Value<TFile>::Type c = _streamGet(file);
  65
  66                 while (!_streamEOF(file))
  67                 {
  68                         c = _streamGet(file);
  69                         ++count;
  70                 }
  71
  72                 //reserve space
  73                 resize(data, count);
  74
  75                 if (!count) return;
  76
  77                 if (length(data) < count)
  78                 {
  79                         count = length(data);
  80                 }
  81
  82                 //read sequence
  83                 _streamSeekG(file, begin_pos);
  84
  85                 typename Position<TData>::Type pos;
  86                 for (pos = 0; pos < count; )
  87                 {
  88                         c = _streamGet(file);
  89                         assignValue(data, pos, c);
  90                         ++pos;
  91                 }
  92         }
  93 //____________________________________________________________________________
  94
  95         template <typename TSize>
  96         static void
  97         read_(TFile & file,
  98                 TData & data,
  99                 TSize _limit)
 100         {
 101 SEQAN_CHECKPOINT
 102                 SEQAN_ASSERT(!_streamEOF(file))
 103
 104                 typename Size<TData>::Type limit = _limit;
 105
 106                 //determine length
 107                 typename Position<TFile>::Type begin_pos = _streamTellG(file);
 108                 typename Size<TData>::Type count = 0;
 109                 typename Value<TFile>::Type c = _streamGet(file);
 110
 111                 while (!_streamEOF(file))
 112                 {
 113                         c = _streamGet(file);
 114                         ++count;
 115                         if (count == limit) break;
 116                 }
 117
 118                 //reserve space
 119                 resize(data, count);
 120
 121                 if (!count) return;
 122
 123                 if (length(data) < count)
 124                 {
 125                         count = length(data);
 126                 }
 127
 128                 //read sequence
 129                 _streamSeekG(file, begin_pos);
 130
 131                 typename Position<TData>::Type pos;
 132                 for (pos = 0; pos < count; )
 133                 {
 134                         c = _streamGet(file);
 135                         assignValue(data, pos, c);
 136                         ++pos;
 137                 }
 138         }
 139 };
 140
 141 //____________________________________________________________________________
 142
 143 template <typename TFile, typename TData>
 144 struct _Read_Raw<TFile, TData, False>
 145 {
 146         static void
 147         read_(TFile & file,
 148                 TData & data)
 149         {
 150 SEQAN_CHECKPOINT
 151
 152                 clear(data);
 153                 if (!_streamEOF(file))
 154                 {
 155 SEQAN_CHECKPOINT
 156                         _ChunkCollector<TData> chunk_collector(data);
 157                         assign(chunk_collector, file);
 158                         append(data, chunk_collector);
 159                 }
 160         }
 161
 162 //____________________________________________________________________________
 163
 164         template <typename TSize>
 165         static void
 166         read_(TFile & file,
 167                 TData & data,
 168                 TSize limit)
 169         {
 170 SEQAN_CHECKPOINT
 171
 172                 clear(data);
 173                 if (!_streamEOF(file))
 174                 {
 175 SEQAN_CHECKPOINT
 176                         _ChunkCollector<TData> chunk_collector(data);
 177                         assign(chunk_collector, file, limit);
 178                         append(data, chunk_collector, limit);
 179                 }
 180         }
 181 };
 182
 183 //////////////////////////////////////////////////////////////////////////////
 184
 185
 186 template <typename TFile, typename TData>
 187 void
 188 read(TFile & file,
 189          TData & data,
 190          Raw)
 191 {
 192 SEQAN_CHECKPOINT
 193         _Read_Raw<TFile, TData, typename _IsTellSeekStream<TFile>::Type>::read_(file, data);
 194 }
 195
 196 //____________________________________________________________________________
 197
 198 template <typename TFile, typename TData, typename TSize>
 199 void
 200 read(TFile & file,
 201          TData & data,
 202          TSize limit,
 203          Raw)
 204 {
 205 SEQAN_CHECKPOINT
 206         _Read_Raw<TFile, TData, typename _IsTellSeekStream<TFile>::Type>::read_(file, data, limit);
 207 }
 208
 209
 210 //////////////////////////////////////////////////////////////////////////////
 211 // readID
 212 //////////////////////////////////////////////////////////////////////////////
 213
 214 template <typename TFile, typename TString>
 215 void
 216 readID(TFile & /*file*/,
 217            TString & id,
 218            Raw)
 219 {
 220 SEQAN_CHECKPOINT
 221         clear(id);
 222 }
 223
 224 //////////////////////////////////////////////////////////////////////////////
 225 // readMeta
 226 //////////////////////////////////////////////////////////////////////////////
 227
 228 template <typename TFile, typename TMeta>
 229 void
 230 readMeta(TFile & file,
 231                  TMeta & meta,
 232                  Raw)
 233 {
 234 SEQAN_CHECKPOINT
 235         clear(meta);
 236 }
 237
 238
 239 //////////////////////////////////////////////////////////////////////////////
 240 // goNext
 241 //////////////////////////////////////////////////////////////////////////////
 242
 243 template <typename TFile>
 244 void
 245 goNext(TFile & file,
 246            Raw)
 247 {
 248 SEQAN_CHECKPOINT
 249         SEQAN_ASSERT(!_streamEOF(file))
 250
 251 //??? TODO: set file to eof
 252 }
 253
 254
 255
 256 //////////////////////////////////////////////////////////////////////////////
 257 // write
 258 //////////////////////////////////////////////////////////////////////////////
 259
 260
 261 template <typename TFile, typename TString, typename TData>
 262 void
 263 write(TFile & file,
 264           TData const & data,
 265           Raw)
 266 {
 267 SEQAN_CHECKPOINT
 268         _streamWrite(file, data);
 269 }
 270
 271 //____________________________________________________________________________
 272
 273 template <typename TFile, typename TData, typename TString>
 274 void
 275 write(TFile & file,
 276           TData const & data,
 277           TString const &,
 278           Raw)
 279 {
 280 SEQAN_CHECKPOINT
 281         _streamWrite(file, data);
 282 }
 283
 284 //____________________________________________________________________________
 285
 286 template <typename TFile, typename TString, typename TData, typename TMeta>
 287 void
 288 write(TFile & file,
 289           TData const & data,
 290           TString const &,
 291           TMeta const &,
 292           Raw)
 293 {
 294 SEQAN_CHECKPOINT
 295         _streamWrite(file, data);
 296 }
 297
 298 //////////////////////////////////////////////////////////////////////////////
 299 // default functions
 300 //////////////////////////////////////////////////////////////////////////////
 301
 302
 303 template <typename TFile, typename TData>
 304 void
 305 read(TFile & file,
 306          TData & data)
 307 {
 308         read(file, data, Raw());
 309 }
 310
 311 template <typename TFile, typename TData, typename TSize>
 312 void
 313 read(TFile & file,
 314          TData & data,
 315          TSize limit)
 316 {
 317 SEQAN_CHECKPOINT
 318         read(file, data, limit, Raw());
 319 }
 320
 321 //____________________________________________________________________________
 322
 323 template <typename TFile, typename TData>
 324 void
 325 write(TFile & file,
 326           TData & data)
 327 {
 328 SEQAN_CHECKPOINT
 329         write(file, data, "", Raw());
 330 }
 331 template <typename TFile, typename TData>
 332 void
 333 write(TFile & file,
 334           TData const & data)
 335 {
 336 SEQAN_CHECKPOINT
 337         write(file, data, "", Raw());
 338 }
 339
 340 //////////////////////////////////////////////////////////////////////////////
 341 } //namespace SEQAN_NAMESPACE_MAIN
 342
 343 //////////////////////////////////////////////////////////////////////////////
 344
 345 #endif //#ifndef SEQAN_HEADER_...