fml::FileMapping Class Reference

#include <mapping.h>

Inheritance diagram for fml::FileMapping:

Public Types
enum class	Protection { kRead , kWrite , kExecute }

Public Member Functions
	FileMapping (const fml::UniqueFD &fd, std::initializer_list< Protection > protection={ Protection::kRead})
	~FileMapping () override
size_t	GetSize () const override
const uint8_t *	GetMapping () const override
bool	IsDontNeedSafe () const override
uint8_t *	GetMutableMapping ()
bool	IsValid () const
Public Member Functions inherited from fml::Mapping
	Mapping ()
virtual	~Mapping ()

Static Public Member Functions
static std::unique_ptr< FileMapping >	CreateReadOnly (const std::string &path)
static std::unique_ptr< FileMapping >	CreateReadOnly (const fml::UniqueFD &base_fd, const std::string &sub_path="")
static std::unique_ptr< FileMapping >	CreateReadExecute (const std::string &path)
static std::unique_ptr< FileMapping >	CreateReadExecute (const fml::UniqueFD &base_fd, const std::string &sub_path="")

Detailed Description

Definition at line 39 of file mapping.h.

Member Enumeration Documentation

Protection

enum class fml::FileMapping::Protection

strong

Enumerator
kRead
kWrite
kExecute

Definition at line 41 of file mapping.h.

                        {
    kRead,
    kWrite,
    kExecute,
  };

Constructor & Destructor Documentation

FileMapping()

fml::FileMapping::FileMapping ( const fml::UniqueFD &  fd, std::initializer_list< Protection >  protection = { Protection::kRead}  )

explicit

Definition at line 53 of file mapping_posix.cc.

                                                                     {
  if (!handle.is_valid()) {
    return;
  }
 
  struct stat stat_buffer = {};
 
  if (::fstat(handle.get(), &stat_buffer) != 0) {
    return;
  }
 
  if (stat_buffer.st_size == 0) {
    valid_ = true;
    return;
  }
 
  const auto is_writable = IsWritable(protection);
 
  auto* mapping =
      ::mmap(nullptr, stat_buffer.st_size, ToPosixProtectionFlags(protection),
             is_writable ? MAP_SHARED : MAP_PRIVATE, handle.get(), 0);
 
  if (mapping == MAP_FAILED) {
    return;
  }
 
  mapping_ = static_cast<uint8_t*>(mapping);
  size_ = stat_buffer.st_size;
  valid_ = true;
  if (is_writable) {
    mutable_mapping_ = mapping_;
  }
}

~FileMapping()

fml::FileMapping::~FileMapping ( )

override

Definition at line 88 of file mapping_posix.cc.

                          {
  if (mapping_ != nullptr) {
    ::munmap(mapping_, size_);
  }
}

Member Function Documentation

CreateReadExecute() [1/2]

std::unique_ptr< FileMapping > fml::FileMapping::CreateReadExecute ( const fml::UniqueFD &  base_fd, const std::string &  sub_path = ""  )

static

Definition at line 50 of file mapping.cc.

                               {
  if (!sub_path.empty()) {
    return CreateReadExecute(
        OpenFile(base_fd, sub_path.c_str(), false, FilePermission::kRead), "");
  }
 
  auto mapping = std::make_unique<FileMapping>(
      base_fd, std::initializer_list<Protection>{Protection::kRead,
                                                 Protection::kExecute});
 
  if (!mapping->IsValid()) {
    return nullptr;
  }
 
  return mapping;
}

CreateReadExecute() [2/2]

std::unique_ptr< FileMapping > fml::FileMapping::CreateReadExecute ( const std::string &  path )

static

Definition at line 44 of file mapping.cc.

                           {
  return CreateReadExecute(
      OpenFile(path.c_str(), false, FilePermission::kRead));
}

CreateReadOnly() [1/2]

std::unique_ptr< FileMapping > fml::FileMapping::CreateReadOnly ( const fml::UniqueFD &  base_fd, const std::string &  sub_path = ""  )

static

Definition at line 26 of file mapping.cc.

                               {
  if (!sub_path.empty()) {
    return CreateReadOnly(
        OpenFile(base_fd, sub_path.c_str(), false, FilePermission::kRead), "");
  }
 
  auto mapping = std::make_unique<FileMapping>(
      base_fd, std::initializer_list<Protection>{Protection::kRead});
 
  if (!mapping->IsValid()) {
    return nullptr;
  }
 
  return mapping;
}

CreateReadOnly() [2/2]

std::unique_ptr< FileMapping > fml::FileMapping::CreateReadOnly ( const std::string &  path )

static

Definition at line 20 of file mapping.cc.

                           {
  return CreateReadOnly(OpenFile(path.c_str(), false, FilePermission::kRead),
                        "");
}

GetMapping()

const uint8_t * fml::FileMapping::GetMapping ( ) const

overridevirtual

Implements fml::Mapping.

Definition at line 98 of file mapping_posix.cc.

                                             {
  return mapping_;
}

GetMutableMapping()

uint8_t * fml::FileMapping::GetMutableMapping

(

)

Definition at line 16 of file mapping.cc.

                                        {
  return mutable_mapping_;
}

GetSize()

size_t fml::FileMapping::GetSize ( ) const

overridevirtual

Implements fml::Mapping.

Definition at line 94 of file mapping_posix.cc.

                                  {
  return size_;
}

IsDontNeedSafe()

bool fml::FileMapping::IsDontNeedSafe ( ) const

overridevirtual

Implements fml::Mapping.

Definition at line 102 of file mapping_posix.cc.

                                       {
  return mutable_mapping_ == nullptr;
}

IsValid()

bool fml::FileMapping::IsValid

(

)

const

Definition at line 106 of file mapping_posix.cc.

                                {
  return valid_;
}

---

The documentation for this class was generated from the following files:

• fml/mapping.h
• fml/mapping.cc
• fml/platform/posix/mapping_posix.cc
• fml/platform/win/mapping_win.cc