fml::MallocMapping Class Reference

A Mapping like NonOwnedMapping, but uses Free as its release proc. More...

#include <mapping.h>

Inheritance diagram for fml::MallocMapping:

Public Member Functions
	MallocMapping ()
	MallocMapping (uint8_t *data, size_t size)
	MallocMapping (fml::MallocMapping &&mapping)
	~MallocMapping () override
size_t	GetSize () const override
const uint8_t *	GetMapping () const override
bool	IsDontNeedSafe () const override
uint8_t *	Release ()
Public Member Functions inherited from fml::Mapping
	Mapping ()
virtual	~Mapping ()

Static Public Member Functions
template<typename T >
static MallocMapping	Copy (const T *begin, const T *end)
static MallocMapping	Copy (const void *begin, size_t length)

Detailed Description

A Mapping like NonOwnedMapping, but uses Free as its release proc.

Definition at line 144 of file mapping.h.

Constructor & Destructor Documentation

MallocMapping() [1/3]

fml::MallocMapping::MallocMapping

(

)

Definition at line 119 of file mapping.cc.

: data_(nullptr), size_(0) {}

MallocMapping() [2/3]

fml::MallocMapping::MallocMapping	(	uint8_t *	data,
		size_t	size
	)

Creates a MallocMapping for a region of memory (without copying it). The function will abort() if the malloc fails.

Parameters

data	The starting address of the mapping.
size	The size of the mapping in bytes.

Definition at line 121 of file mapping.cc.

    : data_(data), size_(size) {}

MallocMapping() [3/3]

fml::MallocMapping::MallocMapping

(

fml::MallocMapping &&

mapping

)

Definition at line 124 of file mapping.cc.

    : data_(mapping.data_), size_(mapping.size_) {
  mapping.data_ = nullptr;
  mapping.size_ = 0;
}

~MallocMapping()

fml::MallocMapping::~MallocMapping ( )

override

Definition at line 130 of file mapping.cc.

                              {
  free(data_);
  data_ = nullptr;
}

Member Function Documentation

Copy() [1/2]

template<typename T >

static MallocMapping fml::MallocMapping::Copy ( const T *  begin, const T *  end  )

inlinestatic

Copies the data from begin to end. It's templated since void* arithemetic isn't allowed and we want support for uint8_t and char.

Definition at line 162 of file mapping.h.

                                                          {
    FML_DCHECK(end >= begin);
    size_t length = end - begin;
    return Copy(begin, length);
  }

Copy() [2/2]

MallocMapping fml::MallocMapping::Copy ( const void *  begin, size_t  length  )

static

Copies a region of memory into a MallocMapping. The function will abort() if the malloc fails.

Parameters

begin	The starting address of where we will copy.
length	The length of the region to copy in bytes.

Definition at line 135 of file mapping.cc.

                                                                  {
  auto result =
      MallocMapping(reinterpret_cast<uint8_t*>(malloc(length)), length);
  FML_CHECK(result.GetMapping() != nullptr);
  memcpy(const_cast<uint8_t*>(result.GetMapping()), begin, length);
  return result;
}

GetMapping()

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

overridevirtual

Implements fml::Mapping.

Definition at line 147 of file mapping.cc.

                                               {
  return data_;
}

GetSize()

size_t fml::MallocMapping::GetSize ( ) const

overridevirtual

Implements fml::Mapping.

Definition at line 143 of file mapping.cc.

                                    {
  return size_;
}

IsDontNeedSafe()

bool fml::MallocMapping::IsDontNeedSafe ( ) const

overridevirtual

Implements fml::Mapping.

Definition at line 151 of file mapping.cc.

                                         {
  return false;
}

Release()

uint8_t * fml::MallocMapping::Release

(

)

Removes ownership of the data buffer. After this is called; the mapping will point to nullptr.

Definition at line 155 of file mapping.cc.

                                {
  uint8_t* result = data_;
  data_ = nullptr;
  size_ = 0;
  return result;
}

---

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

• fml/mapping.h
• fml/mapping.cc