LCOV - code coverage report
Current view: top level - include/llvm/Support - FileOutputBuffer.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 3 3 100.0 %
Date: 2017-09-14 15:23:50 Functions: 1 1 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //=== FileOutputBuffer.h - File Output Buffer -------------------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // Utility for creating a in-memory buffer that will be written to a file.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_SUPPORT_FILEOUTPUTBUFFER_H
      15             : #define LLVM_SUPPORT_FILEOUTPUTBUFFER_H
      16             : 
      17             : #include "llvm/ADT/SmallString.h"
      18             : #include "llvm/ADT/StringRef.h"
      19             : #include "llvm/Support/DataTypes.h"
      20             : #include "llvm/Support/ErrorOr.h"
      21             : #include "llvm/Support/FileSystem.h"
      22             : 
      23             : namespace llvm {
      24             : /// FileOutputBuffer - This interface provides simple way to create an in-memory
      25             : /// buffer which will be written to a file. During the lifetime of these
      26             : /// objects, the content or existence of the specified file is undefined. That
      27             : /// is, creating an OutputBuffer for a file may immediately remove the file.
      28             : /// If the FileOutputBuffer is committed, the target file's content will become
      29             : /// the buffer content at the time of the commit.  If the FileOutputBuffer is
      30             : /// not committed, the file will be deleted in the FileOutputBuffer destructor.
      31             : class FileOutputBuffer {
      32             : public:
      33             : 
      34             :   enum  {
      35             :     F_executable = 1  /// set the 'x' bit on the resulting file
      36             :   };
      37             : 
      38             :   /// Factory method to create an OutputBuffer object which manages a read/write
      39             :   /// buffer of the specified size. When committed, the buffer will be written
      40             :   /// to the file at the specified path.
      41             :   static ErrorOr<std::unique_ptr<FileOutputBuffer>>
      42             :   create(StringRef FilePath, size_t Size, unsigned Flags = 0);
      43             : 
      44             :   /// Returns a pointer to the start of the buffer.
      45             :   uint8_t *getBufferStart() {
      46       10292 :     return (uint8_t*)Region->data();
      47             :   }
      48             : 
      49             :   /// Returns a pointer to the end of the buffer.
      50          62 :   uint8_t *getBufferEnd() {
      51         186 :     return (uint8_t*)Region->data() + Region->size();
      52             :   }
      53             : 
      54             :   /// Returns size of the buffer.
      55             :   size_t getBufferSize() const {
      56             :     return Region->size();
      57             :   }
      58             : 
      59             :   /// Returns path where file will show up if buffer is committed.
      60             :   StringRef getPath() const {
      61             :     return FinalPath;
      62             :   }
      63             : 
      64             :   /// Flushes the content of the buffer to its file and deallocates the
      65             :   /// buffer.  If commit() is not called before this object's destructor
      66             :   /// is called, the file is deleted in the destructor. The optional parameter
      67             :   /// is used if it turns out you want the file size to be smaller than
      68             :   /// initially requested.
      69             :   std::error_code commit();
      70             : 
      71             :   /// If this object was previously committed, the destructor just deletes
      72             :   /// this object.  If this object was not committed, the destructor
      73             :   /// deallocates the buffer and the target file is never written.
      74             :   ~FileOutputBuffer();
      75             : 
      76             : private:
      77             :   FileOutputBuffer(const FileOutputBuffer &) = delete;
      78             :   FileOutputBuffer &operator=(const FileOutputBuffer &) = delete;
      79             : 
      80             :   FileOutputBuffer(std::unique_ptr<llvm::sys::fs::mapped_file_region> R,
      81             :                    StringRef Path, StringRef TempPath, bool IsRegular);
      82             : 
      83             :   std::unique_ptr<llvm::sys::fs::mapped_file_region> Region;
      84             :   SmallString<128>    FinalPath;
      85             :   SmallString<128>    TempPath;
      86             :   bool IsRegular;
      87             : };
      88             : } // end namespace llvm
      89             : 
      90             : #endif

Generated by: LCOV version 1.13