Line data    Source code

       1             : // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file. See the AUTHORS file for names of contributors.
       4             : 
       5             : #include "leveldb/env.h"
       6             : 
       7             : namespace leveldb {
       8             : 
       9          52 : Env::~Env() {
      10          52 : }
      11             : 
      12         603 : SequentialFile::~SequentialFile() {
      13         603 : }
      14             : 
      15         160 : RandomAccessFile::~RandomAccessFile() {
      16         160 : }
      17             : 
      18        1112 : WritableFile::~WritableFile() {
      19        1112 : }
      20             : 
      21         244 : Logger::~Logger() {
      22         244 : }
      23             : 
      24         247 : FileLock::~FileLock() {
      25         247 : }
      26             : 
      27         747 : void Log(Logger* info_log, const char* format, ...) {
      28         747 :   if (info_log != NULL) {
      29             :     va_list ap;
      30         747 :     va_start(ap, format);
      31         747 :     info_log->Logv(format, ap);
      32         747 :     va_end(ap);
      33             :   }
      34         747 : }
      35             : 
      36         373 : static Status DoWriteStringToFile(Env* env, const Slice& data,
      37             :                                   const std::string& fname,
      38             :                                   bool should_sync) {
      39             :   WritableFile* file;
      40         373 :   Status s = env->NewWritableFile(fname, &file);
      41         373 :   if (!s.ok()) {
      42             :     return s;
      43             :   }
      44         746 :   s = file->Append(data);
      45         373 :   if (s.ok() && should_sync) {
      46         746 :     s = file->Sync();
      47             :   }
      48         373 :   if (s.ok()) {
      49         746 :     s = file->Close();
      50             :   }
      51         373 :   delete file;  // Will auto-close if we did not close above
      52             :   if (!s.ok()) {
      53           0 :     env->DeleteFile(fname);
      54             :   }
      55             :   return s;
      56             : }
      57             : 
      58           0 : Status WriteStringToFile(Env* env, const Slice& data,
      59             :                          const std::string& fname) {
      60           0 :   return DoWriteStringToFile(env, data, fname, false);
      61             : }
      62             : 
      63         373 : Status WriteStringToFileSync(Env* env, const Slice& data,
      64             :                              const std::string& fname) {
      65         373 :   return DoWriteStringToFile(env, data, fname, true);
      66             : }
      67             : 
      68         244 : Status ReadFileToString(Env* env, const std::string& fname, std::string* data) {
      69             :   data->clear();
      70             :   SequentialFile* file;
      71         244 :   Status s = env->NewSequentialFile(fname, &file);
      72         244 :   if (!s.ok()) {
      73             :     return s;
      74             :   }
      75             :   static const int kBufferSize = 8192;
      76         244 :   char* space = new char[kBufferSize];
      77             :   while (true) {
      78             :     Slice fragment;
      79         976 :     s = file->Read(kBufferSize, &fragment, space);
      80         488 :     if (!s.ok()) {
      81             :       break;
      82             :     }
      83         488 :     data->append(fragment.data(), fragment.size());
      84         488 :     if (fragment.empty()) {
      85             :       break;
      86             :     }
      87             :   }
      88         244 :   delete[] space;
      89         244 :   delete file;
      90             :   return s;
      91             : }
      92             : 
      93          52 : EnvWrapper::~EnvWrapper() {
      94          52 : }
      95             : 
      96             : }  // namespace leveldb