Branch data     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                 :         374 : Env::~Env() = default;
      10                 :             : 
      11                 :           0 : Status Env::NewAppendableFile(const std::string& fname, WritableFile** result) {
      12         [ #  # ]:           0 :   return Status::NotSupported("NewAppendableFile", fname);
      13                 :             : }
      14                 :             : 
      15                 :        1046 : SequentialFile::~SequentialFile() = default;
      16                 :             : 
      17                 :         155 : RandomAccessFile::~RandomAccessFile() = default;
      18                 :             : 
      19                 :        2384 : WritableFile::~WritableFile() = default;
      20                 :             : 
      21                 :         489 : Logger::~Logger() = default;
      22                 :             : 
      23                 :         881 : FileLock::~FileLock() = default;
      24                 :             : 
      25                 :         841 : void Log(Logger* info_log, const char* format, ...) {
      26         [ +  - ]:         841 :   if (info_log != nullptr) {
      27                 :         841 :     va_list ap;
      28                 :         841 :     va_start(ap, format);
      29                 :         841 :     info_log->Logv(format, ap);
      30                 :         841 :     va_end(ap);
      31                 :             :   }
      32                 :         841 : }
      33                 :             : 
      34                 :         910 : static Status DoWriteStringToFile(Env* env, const Slice& data,
      35                 :             :                                   const std::string& fname, bool should_sync) {
      36                 :         910 :   WritableFile* file;
      37                 :         910 :   Status s = env->NewWritableFile(fname, &file);
      38         [ +  - ]:         910 :   if (!s.ok()) {
      39                 :             :     return s;
      40                 :             :   }
      41   [ +  -  -  + ]:         910 :   s = file->Append(data);
      42   [ +  -  +  - ]:         910 :   if (s.ok() && should_sync) {
      43   [ +  -  -  + ]:         910 :     s = file->Sync();
      44                 :             :   }
      45         [ +  - ]:         910 :   if (s.ok()) {
      46   [ +  -  -  + ]:         910 :     s = file->Close();
      47                 :             :   }
      48         [ +  - ]:         910 :   delete file;  // Will auto-close if we did not close above
      49         [ -  + ]:         910 :   if (!s.ok()) {
      50         [ #  # ]:           0 :     env->DeleteFile(fname);
      51                 :             :   }
      52                 :             :   return s;
      53                 :           0 : }
      54                 :             : 
      55                 :           0 : Status WriteStringToFile(Env* env, const Slice& data,
      56                 :             :                          const std::string& fname) {
      57                 :           0 :   return DoWriteStringToFile(env, data, fname, false);
      58                 :             : }
      59                 :             : 
      60                 :         910 : Status WriteStringToFileSync(Env* env, const Slice& data,
      61                 :             :                              const std::string& fname) {
      62                 :         910 :   return DoWriteStringToFile(env, data, fname, true);
      63                 :             : }
      64                 :             : 
      65                 :         489 : Status ReadFileToString(Env* env, const std::string& fname, std::string* data) {
      66                 :         489 :   data->clear();
      67                 :         489 :   SequentialFile* file;
      68                 :         489 :   Status s = env->NewSequentialFile(fname, &file);
      69         [ +  - ]:         489 :   if (!s.ok()) {
      70                 :             :     return s;
      71                 :             :   }
      72                 :         489 :   static const int kBufferSize = 8192;
      73         [ +  - ]:         489 :   char* space = new char[kBufferSize];
      74                 :         978 :   while (true) {
      75         [ +  - ]:         978 :     Slice fragment;
      76   [ +  -  -  + ]:         978 :     s = file->Read(kBufferSize, &fragment, space);
      77         [ +  - ]:         978 :     if (!s.ok()) {
      78                 :             :       break;
      79                 :             :     }
      80         [ +  - ]:         978 :     data->append(fragment.data(), fragment.size());
      81         [ +  + ]:         978 :     if (fragment.empty()) {
      82                 :             :       break;
      83                 :             :     }
      84                 :             :   }
      85         [ +  - ]:         489 :   delete[] space;
      86         [ +  - ]:         489 :   delete file;
      87                 :             :   return s;
      88                 :           0 : }
      89                 :             : 
      90                 :         374 : EnvWrapper::~EnvWrapper() {}
      91                 :             : 
      92                 :             : }  // namespace leveldb