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/status.h"
       6                 :             : 
       7                 :             : #include <stdio.h>
       8                 :             : 
       9                 :             : #include "port/port.h"
      10                 :             : 
      11                 :             : namespace leveldb {
      12                 :             : 
      13                 :          17 : const char* Status::CopyState(const char* state) {
      14                 :          17 :   uint32_t size;
      15                 :          17 :   memcpy(&size, state, sizeof(size));
      16                 :          17 :   char* result = new char[size + 5];
      17                 :          17 :   memcpy(result, state, size + 5);
      18                 :          17 :   return result;
      19                 :             : }
      20                 :             : 
      21                 :     5960590 : Status::Status(Code code, const Slice& msg, const Slice& msg2) {
      22         [ -  + ]:     5960590 :   assert(code != kOk);
      23         [ +  + ]:     5960590 :   const uint32_t len1 = static_cast<uint32_t>(msg.size());
      24                 :     5960590 :   const uint32_t len2 = static_cast<uint32_t>(msg2.size());
      25         [ +  + ]:     5960590 :   const uint32_t size = len1 + (len2 ? (2 + len2) : 0);
      26                 :     5960590 :   char* result = new char[size + 5];
      27         [ +  + ]:     5960590 :   memcpy(result, &size, sizeof(size));
      28                 :     5960590 :   result[4] = static_cast<char>(code);
      29         [ +  + ]:     5960590 :   memcpy(result + 5, msg.data(), len1);
      30         [ +  + ]:     5960590 :   if (len2) {
      31                 :        2495 :     result[5 + len1] = ':';
      32                 :        2495 :     result[6 + len1] = ' ';
      33                 :        2495 :     memcpy(result + 7 + len1, msg2.data(), len2);
      34                 :             :   }
      35                 :     5960590 :   state_ = result;
      36                 :     5960590 : }
      37                 :             : 
      38                 :        1749 : std::string Status::ToString() const {
      39         [ +  + ]:        1749 :   if (state_ == nullptr) {
      40                 :        1736 :     return "OK";
      41                 :             :   } else {
      42                 :          13 :     char tmp[30];
      43                 :          13 :     const char* type;
      44   [ +  +  -  -  :          13 :     switch (code()) {
                -  -  - ]
      45                 :             :       case kOk:
      46                 :             :         type = "OK";
      47                 :             :         break;
      48                 :           1 :       case kNotFound:
      49                 :           1 :         type = "NotFound: ";
      50                 :           1 :         break;
      51                 :          12 :       case kCorruption:
      52                 :          12 :         type = "Corruption: ";
      53                 :          12 :         break;
      54                 :           0 :       case kNotSupported:
      55                 :           0 :         type = "Not implemented: ";
      56                 :           0 :         break;
      57                 :           0 :       case kInvalidArgument:
      58                 :           0 :         type = "Invalid argument: ";
      59                 :           0 :         break;
      60                 :           0 :       case kIOError:
      61                 :           0 :         type = "IO error: ";
      62                 :           0 :         break;
      63                 :           0 :       default:
      64                 :           0 :         snprintf(tmp, sizeof(tmp),
      65                 :           0 :                  "Unknown code(%d): ", static_cast<int>(code()));
      66                 :           0 :         type = tmp;
      67                 :           0 :         break;
      68                 :             :     }
      69                 :          26 :     std::string result(type);
      70                 :          13 :     uint32_t length;
      71         [ +  - ]:          13 :     memcpy(&length, state_, sizeof(length));
      72         [ +  - ]:          13 :     result.append(state_ + 5, length);
      73                 :          13 :     return result;
      74                 :             :   }
      75                 :             : }
      76                 :             : 
      77                 :             : }  // namespace leveldb